基于Fisco-Bcos的区块链智能合约-业务数据上链SDK实现
合约的编写
基于springboot ： https://github.com/FISCO-BCOS/spring-boot-starter
pragma solidity ^0.4.24;
contract TableFactory {
function openTable(string) public constant returns (Table); // 打开表
function createTable(string,string,string) public returns(int); // 创建表
}
// 查询条件
contract Condition {
//等于
function EQ(string, int) public;
function EQ(string, string) public;
//不等于
function NE(string, int) public;
function NE(string, string) public;
//大于
function GT(string, int) public;
//大于或等于
function GE(string, int) public;
//小于
function LT(string, int) public;
//小于或等于
function LE(string, int) public;
//限制返回记录条数
function limit(int) public;
function limit(int, int) public; }
// 单条数据记录
contract Entry {
function getInt(string) public constant returns(int);
function getAddress(string) public constant returns(address);
function getBytes64(string) public constant returns(byte[64]);
function getBytes32(string) public constant returns(bytes32);
function getString(string) public constant returns(string);
function set(string, int) public;
function set(string, string) public;
function set(string, address) public; }
// 数据记录集
contract Entries {
function get(int) public constant returns(Entry);
function size() public constant returns(int);
}
// Table主类
contract Table {
// 查询接口
function select(string, Condition) public constant returns(Entries);
// 插入接口
function insert(string, Entry) public returns(int);
// 更新接口
function update(string, Entry, Condition) public returns(int);
// 删除接口
function remove(string, Condition) public returns(int);
function newEntry() public constant returns(Entry);
function newCondition() public constant returns(Condition); }
LibStrings.sol
/*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson arachnid@notdot.net
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a single character, or even no
* characters at all (a 0-length slice). Since a slice only has to specify
* an offset and a length, copying and manipulating slices is a lot less
* expensive than copying and manipulating the strings they reference.
*
* To further reduce gas costs, most functions on slice that need to return
* a slice modify the original one instead of allocating a new one; for
* instance, `s.split(".")` will return the text up to the first '.',
* modifying s to only contain the remainder of the string after the '.'.
* In situations where you do not want to modify the original slice, you
* can make a copy first with `.copy()`, for example:
* `s.copy().split(".")`. Try and avoid using this idiom in loops; since
* Solidity has no memory management, it will result in allocating many
* short-lived slices that are later discarded.
*
* Functions that return two slices come in two versions: a non-allocating
* version that takes the second slice as an argument, modifying it in
* place, and an allocating version that allocates and returns the second
* slice; see `nextRune` for example.
*
* Functions that have to copy string data will return strings rather than
* slices; these can be cast back to slices for further processing if
* required.
*
* For convenience, some functions are provided with non-modifying
* variants that create a new slice and return both; for instance,
* `s.splitNew('.')` leaves s unmodified, and returns two values
* corresponding to the left and right parts of the string.
*/
pragma solidity ^0.4.24;
library LibStrings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 \*\* (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
/\*
\* @dev Returns a slice containing the entire string.
\* @param self The string to make a slice from.
\* @return A newly allocated slice containing the entire string.
\*/
function toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
/\*
\* @dev Returns the length of a null-terminated bytes32 string.
\* @param self The value to find the length of.
\* @return The length of the string, from 0 to 32.
\* TODO 此处将self改为uint(self)
\*/
function len(bytes32 self) internal pure returns (uint) {
uint ret;
if (self == 0)
return 0;
if (uint(self) & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (uint(self) & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (uint(self) & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (uint(self) & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (uint(self) & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
/\*
\* @dev Returns a slice containing the entire bytes32, interpreted as a
\* null-terminated utf-8 string.
\* @param self The bytes32 value to convert to a slice.
\* @return A new slice containing the value of the input argument up to the
\* first null.
\*/
function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
// Allocate space for \`self\` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret.\_len = len(self);
}
/\*
\* @dev Returns a new slice containing the same data as the current slice.
\* @param self The slice to copy.
\* @return A new slice containing the same data as \`self\`.
\*/
function copy(slice memory self) internal pure returns (slice memory) {
return slice(self.\_len, self.\_ptr);
}
/\*
\* @dev Copies a slice to a new string.
\* @param self The slice to copy.
\* @return A newly allocated string containing the slice's text.
\*/
function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self.\_len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self.\_ptr, self.\_len);
return ret;
}
/\*
\* @dev Returns the length in runes of the slice. Note that this operation
\* takes time proportional to the length of the slice; avoid using it
\* in loops, and call \`slice.empty()\` if you only need to know whether
\* the slice is empty or not.
\* @param self The slice to operate on.
\* @return The length of the slice in runes.
\*/
function len(slice memory self) internal pure returns (uint l) {
// Starting at ptr-31 means the LSB will be the byte we care about
uint ptr = self.\_ptr - 31;
uint end = ptr + self.\_len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
/\*
\* @dev Returns true if the slice is empty (has a length of 0).
\* @param self The slice to operate on.
\* @return True if the slice is empty, False otherwise.
\*/
function empty(slice memory self) internal pure returns (bool) {
return self.\_len == 0;
}
/\*
\* @dev Returns a positive number if \`other\` comes lexicographically after
\* \`self\`, a negative number if it comes before, or zero if the
\* contents of the two slices are equal. Comparison is done per-rune,
\* on unicode codepoints.
\* @param self The first slice to compare.
\* @param other The second slice to compare.
\* @return The result of the comparison.
\*/
function compare(slice memory self, slice memory other) internal pure returns (int) {
uint shortest = self.\_len;
if (other.\_len < self.\_len)
shortest = other.\_len;
uint selfptr = self.\_ptr;
uint otherptr = other.\_ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint256 mask = uint256(-1); // 0xffff...
if(shortest < 32) {
mask = ~(2 \*\* (8 \* (32 - shortest + idx)) - 1);
}
uint256 diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self.\_len) - int(other.\_len);
}
/\*
\* @dev Returns true if the two slices contain the same text.
\* @param self The first slice to compare.
\* @param self The second slice to compare.
\* @return True if the slices are equal, false otherwise.
\*/
function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
/\*
\* @dev Extracts the first rune in the slice into \`rune\`, advancing the
\* slice to point to the next rune and returning \`self\`.
\* @param self The slice to operate on.
\* @param rune The slice that will contain the first rune.
\* @return \`rune\`.
\*/
function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune.\_ptr = self.\_ptr;
if (self.\_len == 0) {
rune.\_len = 0;
return rune;
}
uint l;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
l = 1;
} else if(b < 0xE0) {
l = 2;
} else if(b < 0xF0) {
l = 3;
} else {
l = 4;
}
// Check for truncated codepoints
if (l > self.\_len) {
rune.\_len = self.\_len;
self.\_ptr += self.\_len;
self.\_len = 0;
return rune;
}
self.\_ptr += l;
self.\_len -= l;
rune.\_len = l;
return rune;
}
/\*
\* @dev Returns the first rune in the slice, advancing the slice to point
\* to the next rune.
\* @param self The slice to operate on.
\* @return A slice containing only the first rune from \`self\`.
\*/
function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
/\*
\* @dev Returns the number of the first codepoint in the slice.
\* @param self The slice to operate on.
\* @return The number of the first codepoint in the slice.
\*/
function ord(slice memory self) internal pure returns (uint ret) {
if (self.\_len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 \*\* 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
// Check for truncated codepoints
if (length > self.\_len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret \* 64) | (b & 0x3F);
}
return ret;
}
/\*
\* @dev Returns the keccak-256 hash of the slice.
\* @param self The slice to hash.
\* @return The hash of the slice.
\*/
function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
/\*
\* @dev Returns true if \`self\` starts with \`needle\`.
\* @param self The slice to operate on.
\* @param needle The slice to search for.
\* @return True if the slice starts with the provided text, false otherwise.
\*/
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self.\_len < needle.\_len) {
return false;
}
if (self.\_ptr == needle.\_ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
/\*
\* @dev If \`self\` starts with \`needle\`, \`needle\` is removed from the
\* beginning of \`self\`. Otherwise, \`self\` is unmodified.
\* @param self The slice to operate on.
\* @param needle The slice to search for.
\* @return \`self\`
\*/
function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self.\_len < needle.\_len) {
return self;
}
bool equal = true;
if (self.\_ptr != needle.\_ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self.\_len -= needle.\_len;
self.\_ptr += needle.\_len;
}
return self;
}
/\*
\* @dev Returns true if the slice ends with \`needle\`.
\* @param self The slice to operate on.
\* @param needle The slice to search for.
\* @return True if the slice starts with the provided text, false otherwise.
\*/
function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self.\_len < needle.\_len) {
return false;
}
uint selfptr = self.\_ptr + self.\_len - needle.\_len;
if (selfptr == needle.\_ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
/\*
\* @dev If \`self\` ends with \`needle\`, \`needle\` is removed from the
\* end of \`self\`. Otherwise, \`self\` is unmodified.
\* @param self The slice to operate on.
\* @param needle The slice to search for.
\* @return \`self\`
\*/
function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self.\_len < needle.\_len) {
return self;
}
uint selfptr = self.\_ptr + self.\_len - needle.\_len;
bool equal = true;
if (selfptr != needle.\_ptr) {
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self.\_len -= needle.\_len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// \`needle\` in \`self\`, or the first byte after \`self\` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr = selfptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 \*\* (8 \* (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
uint end = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr >= end)
return selfptr + selflen;
ptr++;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// \`needle\` in \`self\`, or the address of \`self\` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 \*\* (8 \* (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
ptr = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr <= selfptr)
return selfptr;
ptr--;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr + needlelen;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
/\*
\* @dev Modifies \`self\` to contain everything from the first occurrence of
\* \`needle\` to the end of the slice. \`self\` is set to the empty slice
\* if \`needle\` is not found.
\* @param self The slice to search and modify.
\* @param needle The text to search for.
\* @return \`self\`.
\*/
function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = findPtr(self.\_len, self.\_ptr, needle.\_len, needle.\_ptr);
self.\_len -= ptr - self.\_ptr;
self.\_ptr = ptr;
return self;
}
/\*
\* @dev Modifies \`self\` to contain the part of the string from the start of
\* \`self\` to the end of the first occurrence of \`needle\`. If \`needle\`
\* is not found, \`self\` is set to the empty slice.
\* @param self The slice to search and modify.
\* @param needle The text to search for.
\* @return \`self\`.
\*/
function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = rfindPtr(self.\_len, self.\_ptr, needle.\_len, needle.\_ptr);
self.\_len = ptr - self.\_ptr;
return self;
}
/\*
\* @dev Splits the slice, setting \`self\` to everything after the first
\* occurrence of \`needle\`, and \`token\` to everything before it. If
\* \`needle\` does not occur in \`self\`, \`self\` is set to the empty slice,
\* and \`token\` is set to the entirety of \`self\`.
\* @param self The slice to split.
\* @param needle The text to search for in \`self\`.
\* @param token An output parameter to which the first token is written.
\* @return \`token\`.
\*/
function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self.\_len, self.\_ptr, needle.\_len, needle.\_ptr);
token.\_ptr = self.\_ptr;
token.\_len = ptr - self.\_ptr;
if (ptr == self.\_ptr + self.\_len) {
// Not found
self.\_len = 0;
} else {
self.\_len -= token.\_len + needle.\_len;
self.\_ptr = ptr + needle.\_len;
}
return token;
}
/\*
\* @dev Splits the slice, setting \`self\` to everything after the first
\* occurrence of \`needle\`, and returning everything before it. If
\* \`needle\` does not occur in \`self\`, \`self\` is set to the empty slice,
\* and the entirety of \`self\` is returned.
\* @param self The slice to split.
\* @param needle The text to search for in \`self\`.
\* @return The part of \`self\` up to the first occurrence of \`delim\`.
\*/
function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
split(self, needle, token);
}
/\*
\* @dev Splits the slice, setting \`self\` to everything before the last
\* occurrence of \`needle\`, and \`token\` to everything after it. If
\* \`needle\` does not occur in \`self\`, \`self\` is set to the empty slice,
\* and \`token\` is set to the entirety of \`self\`.
\* @param self The slice to split.
\* @param needle The text to search for in \`self\`.
\* @param token An output parameter to which the first token is written.
\* @return \`token\`.
\*/
function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = rfindPtr(self.\_len, self.\_ptr, needle.\_len, needle.\_ptr);
token.\_ptr = ptr;
token.\_len = self.\_len - (ptr - self.\_ptr);
if (ptr == self.\_ptr) {
// Not found
self.\_len = 0;
} else {
self.\_len -= token.\_len + needle.\_len;
}
return token;
}
/\*
\* @dev Splits the slice, setting \`self\` to everything before the last
\* occurrence of \`needle\`, and returning everything after it. If
\* \`needle\` does not occur in \`self\`, \`self\` is set to the empty slice,
\* and the entirety of \`self\` is returned.
\* @param self The slice to split.
\* @param needle The text to search for in \`self\`.
\* @return The part of \`self\` after the last occurrence of \`delim\`.
\*/
function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
/\*
\* @dev Counts the number of nonoverlapping occurrences of \`needle\` in \`self\`.
\* @param self The slice to search.
\* @param needle The text to search for in \`self\`.
\* @return The number of occurrences of \`needle\` found in \`self\`.
\*/
function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
uint ptr = findPtr(self.\_len, self.\_ptr, needle.\_len, needle.\_ptr) + needle.\_len;
while (ptr <= self.\_ptr + self.\_len) {
cnt++;
ptr = findPtr(self.\_len - (ptr - self.\_ptr), ptr, needle.\_len, needle.\_ptr) + needle.\_len;
}
}
/\*
\* @dev Returns True if \`self\` contains \`needle\`.
\* @param self The slice to search.
\* @param needle The text to search for in \`self\`.
\* @return True if \`needle\` is found in \`self\`, false otherwise.
\*/
function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self.\_len, self.\_ptr, needle.\_len, needle.\_ptr) != self.\_ptr;
}
/\*
\* @dev Returns a newly allocated string containing the concatenation of
\* \`self\` and \`other\`.
\* @param self The first slice to concatenate.
\* @param other The second slice to concatenate.
\* @return The concatenation of the two strings.
\*/
function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self.\_len + other.\_len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self.\_ptr, self.\_len);
memcpy(retptr + self.\_len, other.\_ptr, other.\_len);
return ret;
}
/\*
\* @dev Joins an array of slices, using \`self\` as a delimiter, returning a
\* newly allocated string.
\* @param self The delimiter to use.
\* @param parts A list of slices to join.
\* @return A newly allocated string containing all the slices in \`parts\`,
\* joined with \`self\`.
\*/
function join(slice memory self, slice\[\] memory parts) internal pure returns (string memory) {
if (parts.length == 0)
return "";
uint length = self.\_len \* (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
length += parts\[i\].\_len;
string memory ret = new string(length);
uint retptr;
assembly { retptr := add(ret, 32) }
for(uint i1 = 0; i1 < parts.length; i1++) {
memcpy(retptr, parts\[i1\].\_ptr, parts\[i1\].\_len);
retptr += parts\[i1\].\_len;
if (i < parts.length - 1) {
memcpy(retptr, self.\_ptr, self.\_len);
retptr += self.\_len;
}
}
return ret;
} }
LibStringUtil.sol
pragma solidity ^0.4.24;
import "./Table.sol";
/**
@title 将Bean格式化为json
*/
library LibStringUtil {
function getEntry(string\[\] memory fields, Entry entry) internal view returns (string\[\] memory) {
string\[\] memory values = new string\[\](fields.length);
for (uint i = 0; i < fields.length; i++) {
values\[i\] = entry.getString(fields\[i\]);
}
return values;
}
function getJsonString(string\[\] memory fields, Entries entries) internal view returns (int, string memory) {
string memory detail;
if (0 == entries.size()) {
return (- 1, detail);
}
else {
// \[{"index":"",{"key1":"","key2":""}}\]
detail = "\[";
// 获取Bean的值
for (uint i = 0; i < uint(entries.size()); i++) {
string\[\] memory values = getEntry(fields, entries.get(int(i)));
for (uint j = 0; j < values.length; j++) {
if (j == 0) {
detail = strConcat4(detail, "{\\"index\\":\\"", values\[0\], "\\",\\"data\\":{");
}
detail = strConcat6(detail, "\\"", fields\[j\], "\\":\\"", values\[j\], "\\"");
if (j == values.length - 1) {
detail = strConcat2(detail, "}}");
} else {
detail = strConcat2(detail, ",");
}
}
if (i != uint(entries.size()) - 1) {
detail = strConcat2(detail, ",");
}
}
detail = strConcat2(detail, "\]");
return (0, detail);
}
}
function strConcat6(
string memory str1,
string memory str2,
string memory str3,
string memory str4,
string memory str5,
string memory str6
) internal pure returns (string memory) {
string\[\] memory strings = new string\[\](6);
strings\[0\] = str1;
strings\[1\] = str2;
strings\[2\] = str3;
strings\[3\] = str4;
strings\[4\] = str5;
strings\[5\] = str6;
return strConcat(strings);
}
function strConcat5(
string memory str1,
string memory str2,
string memory str3,
string memory str4,
string memory str5
) internal pure returns (string memory) {
string\[\] memory strings = new string\[\](5);
strings\[0\] = str1;
strings\[1\] = str2;
strings\[2\] = str3;
strings\[3\] = str4;
strings\[4\] = str5;
return strConcat(strings);
}
function strConcat4(
string memory str1,
string memory str2,
string memory str3,
string memory str4
) internal pure returns (string memory) {
string\[\] memory strings = new string\[\](4);
strings\[0\] = str1;
strings\[1\] = str2;
strings\[2\] = str3;
strings\[3\] = str4;
return strConcat(strings);
}
function strConcat3(
string memory str1,
string memory str2,
string memory str3
) internal pure returns (string memory) {
string\[\] memory strings = new string\[\](3);
strings\[0\] = str1;
strings\[1\] = str2;
strings\[2\] = str3;
return strConcat(strings);
}
function strConcat2(string memory str1, string memory str2) internal pure returns (string memory) {
string\[\] memory strings = new string\[\](2);
strings\[0\] = str1;
strings\[1\] = str2;
return strConcat(strings);
}
function strConcat(string\[\] memory strings) internal pure returns (string memory) {
// 计算字节长度
uint bLength = 0;
for (uint i = 0; i < strings.length; i++) {
bLength += bytes(strings\[i\]).length;
}
// 实例化字符串
string memory result = new string(bLength);
bytes memory bResult = bytes(result);
// 填充字符串
uint currLength = 0;
for (uint i1 = 0; i1 < strings.length; i1++) {
// 将当前字符串转换为字节数组
bytes memory bs = bytes(strings\[i1\]);
for (uint j = 0; j < bs.length; j++) {
bResult\[currLength\] = bs\[j\];
currLength++;
}
}
return string(bResult);
}}
基于Table.sol 、LibStrings.sol、LibStringUtil.sol 实现返回例子
pragma solidity ^0.4.24;
pragma experimental ABIEncoderV2;
import "./Table.sol";
import "./LibStrings.sol";
import "./LibStringUtil.sol";
contract BudgetApp{
TableFactory tf = TableFactory(0X1001);
constructor() public{
tf.createTable("t\_sichuan\_bud","dwbm","dwmc,zcgnflbm,zcgnfl,zcjjflbm,zcjjfl,zfjjkmdm,zfjjfl,je,xm,jsonData");
}
function get(string dwbm,string\[\] yskey,string\[\] ystr,int startPage,int endPage)constant public returns(int, string memory){
Table table = tf.openTable("t\_sichuan\_bud");
// 条件为空表示不筛选 也可以根据需要使用条件筛选
Condition condition = table.newCondition();
for (uint i = 0; i < yskey.length; i++) {
condition.EQ(yskey\[i\],ystr\[i\]);
}
condition.limit(startPage,endPage);
Entries entries = table.select(dwbm, condition);
string\[\] memory info = new string\[\](11);
info\[0\] = "dwbm";
info\[1\] = "dwmc";
info\[2\] = "zcgnflbm";
info\[3\] = "zcgnfl";
info\[4\] = "zcjjflbm";
info\[5\] = "zcjjfl";
info\[6\] = "zfjjkmdm";
info\[7\] = "zfjjfl";
info\[8\] = "je";
info\[9\] = "xm";
info\[10\] = "jsonData";
return LibStringUtil.getJsonString(info, entries);
}
function set(string dwbm,string\[\] paystr,string jsonData) public returns(int){
Table tb = tf.openTable("t\_sichuan\_bud");
Entry entry = tb.newEntry();
entry.set("dwbm",dwbm);
entry.set("dwmc",paystr\[1\]);
entry.set("zcgnflbm",paystr\[2\]);
entry.set("zcgnfl",paystr\[3\]);
entry.set("zcjjflbm",paystr\[4\]);
entry.set("zcjjfl",paystr\[5\]);
entry.set("zfjjkmdm",paystr\[6\]);
entry.set("zfjjfl",paystr\[7\]);
entry.set("je",paystr\[8\]);
entry.set("xm",paystr\[9\]);
entry.set("jsonData",jsonData);
int count = tb.insert(dwbm,entry);
return count;
}}
对外接口
public interface CommonService {
<T> boolean set(T t,String flag);
<T> TransactionInfo setData(T t, String flag); }
@Service
public class CommonServiceImpl implements CommonService {
private Logger log = LoggerFactory.getLogger(CommonServiceImpl.class);
@Autowired
private Web3j web3j;
//BudgetApp
@Autowired
private BudgetApp budgetApp;
// DataSourIndi
@Autowired
private DataSourIndi dataSourIndi;
//
@Autowired
private TargetRele targetRele;
//
@Autowired
private TargetReleDown targetReleDown;
//
@Autowired
private IndexTobeDiv indexTobeDiv;
//
@Autowired
private ExecutableIndi executableIndi;
//
@Autowired
private DirectPayVoucher directPayVoucher;
//
@Autowired
private DirectPayVoucherItem vouitem;
//
@Autowired
private OneCardSolu oneCardSolu;
//
@Autowired
private AccountingBook account;
//
@Autowired
private Generalplan generalplan;
//直接支付申请
@Autowired
private DirectPayment directPayment;
//预警数据
@Autowired
private Earlywarning earlywarning;
/\*\*
\* 公共查询
\* 查询时dwdm || yslydm 不能为空null 或"" 为空返回null
\*
\* @param t
\* @param startPage 0
\* @param endPage 10
\* @param flag
\* @param <T>
\* @return
\*/
@Override
public <T> String get(T t, int startPage, int endPage, String flag) {
log.info(">>>>>>>>>>>>>>get>>>>>>>>>>>>T" + JSONObject.toJSON(t).toString() + " startPage:" + startPage + " endPage" + endPage + " flag" + flag);
List<String> keylist = new ArrayList<>();
List<String> vallist = new ArrayList<>();
Field fields\[\] = t.getClass().getDeclaredFields();//t 是实体类名称
String\[\] name = new String\[fields.length\];
Object\[\] value = new Object\[fields.length\];
String dwdm = "";
String yslydm = "";
Tuple2<BigInteger, String> send = null;
try {
Field.setAccessible(fields, true);
for (int i = 0; i < name.length; i++) {
if (fields\[i\].get(t) != null && fields\[i\].get(t) != "") {
keylist.add(fields\[i\].getName());
vallist.add((String) fields\[i\].get(t));
}
if ("dwbm".equals(fields\[i\].getName()) || "dwdm".equals(fields\[i\].getName())) {
dwdm = (String) fields\[i\].get(t);
}
if ("yslydm".equals(fields\[i\].getName())) {
yslydm = (String) fields\[i\].get(t);
}
}
send = doGetDown(startPage, endPage, flag, keylist, vallist, dwdm, yslydm, send);
if (send != null) {
return send.getValue2();
} else {
return null;
}
} catch (Exception e) {
log.error(">>>>>>>>>>>>>set>>>>>>>>>errorinfo", e);
return null;
}
}
/\*\*
\* 公共添加
\* dwdm || yslydm 不能为空null 或"" 为空返回false
\*
\* @param t
\* @param flag
\* @param <T>
\* @return
\*/
@Override
public <T> boolean set(T t, String flag) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>>>>>T" + JSONObject.toJSON(t).toString() + " flag" + flag);
List<String> keylist = new ArrayList<>();
List<String> vallist = new ArrayList<>();
Field fields\[\] = t.getClass().getDeclaredFields();//t 是实体类名称
String\[\] name = new String\[fields.length\];
Object\[\] value = new Object\[fields.length\];
String dwdm = "";
String yslydm = "";
String jsonData = "";
TransactionReceipt \_temp = null;
try {
Field.setAccessible(fields, true);
for (int i = 0; i < name.length; i++) {
keylist.add(fields\[i\].getName());
if (fields\[i\].get(t) != null) {
vallist.add((String) fields\[i\].get(t));
} else {
vallist.add("");
}
if ("dwbm".equals(fields\[i\].getName()) || "dwdm".equals(fields\[i\].getName())) {
dwdm = (String) fields\[i\].get(t);
}
if ("yslydm".equals(fields\[i\].getName())) {
yslydm = (String) fields\[i\].get(t);
}
if ("jsonData".equals(fields\[i\].getName())) {
jsonData = (String) fields\[i\].get(t);
}
}
\_temp = doSetDown(flag, vallist, dwdm, yslydm, jsonData, \_temp);
if (\_temp != null) {
return true;
} else {
return false;
}
} catch (Exception e) {
log.error(">>>>>>>>>>>>>set>>>>>>>>>errorinfo", e);
return false;
}
}
/\*\*
\* 公共添加
\* dwdm || yslydm 不能为空null 或"" 为空返回 null
\*
\* @param <T>
\* @param t
\* @param flag
\* @return
\*/
@Override
public <T> TransactionInfo setData(T t, String flag) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>>>>>T" + JSONObject.toJSON(t).toString() + " flag" + flag);
List<String> keylist = new ArrayList<>();
List<String> vallist = new ArrayList<>();
Field fields\[\] = t.getClass().getDeclaredFields();//t 是实体类名称
String\[\] name = new String\[fields.length\];
Object\[\] value = new Object\[fields.length\];
String dwdm = "";
String yslydm = "";
String jsonData = "";
TransactionReceipt \_temp = null;
TransactionInfo transactionInfo=new TransactionInfo();
try {
Field.setAccessible(fields, true);
for (int i = 0; i < name.length; i++) {
keylist.add(fields\[i\].getName());
if (fields\[i\].get(t) != null) {
vallist.add((String) fields\[i\].get(t));
} else {
vallist.add("");
}
if ("dwbm".equals(fields\[i\].getName()) || "dwdm".equals(fields\[i\].getName())) {
dwdm = (String) fields\[i\].get(t);
}
if ("yslydm".equals(fields\[i\].getName())) {
yslydm = (String) fields\[i\].get(t);
}
if ("jsonData".equals(fields\[i\].getName())) {
jsonData = (String) fields\[i\].get(t);
}
}
\_temp = doSetDown(flag, vallist, dwdm, yslydm, jsonData, \_temp);
if (\_temp != null) {
transactionInfo.setTransactionHash(\_temp.getTransactionHash());
transactionInfo.setBlockHash(\_temp.getBlockHash());
transactionInfo.setBlockNumber(\_temp.getBlockNumber());
return transactionInfo;
} else {
return null;
}
} catch (Exception e) {
log.error(">>>>>>>>>>>>>set>>>>>>>>>errorinfo", e);
return null;
}
}
/\*\*
\* get
\*
\* @param startPage
\* @param endPage
\* @param flag
\* @param keylist
\* @param vallist
\* @param dwdm
\* @param yslydm
\* @param send
\* @return
\* @throws Exception
\*/
private Tuple2<BigInteger, String> doGetDown(int startPage, int endPage, String flag, List<String> keylist, List<String> vallist, String dwdm, String yslydm, Tuple2<BigInteger, String> send) throws Exception {
if ("1".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = budgetApp.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>get>>>>>>>>>>>budgetApp:" + send);
} else {
log.info(">>>>>>>>>>>>>budgetApp dwdm is null.skip...>>>>>>>>");
}
} else if ("2".equals(flag)) {
if (StringUtils.isNotBlank(yslydm)) {
send = dataSourIndi.get(yslydm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>get>>>>>>>>>>dataSourIndi:" + send);
} else {
log.info(">>>>>>>>>>>>>dataSourIndi yslydm is null.skip...>>>>>>>>");
}
} else if ("3".equals(flag)) {
if (StringUtils.isNotBlank(yslydm)) {
send = targetRele.get(yslydm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>targetRele:" + send);
} else {
log.info(">>>>>>>>>>>>>targetRele yslydm is null.skip...>>>>>>>>");
}
} else if ("4".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = targetReleDown.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>targetRele:" + send);
} else {
log.info(">>>>>>>>>>>>>targetReleDown dwdm is null.skip...>>>>>>>>");
}
} else if ("5".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = indexTobeDiv.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>indexTobeDiv:" + send);
} else {
log.info(">>>>>>>>>>>>>indexTobeDiv dwdm is null.skip...>>>>>>>>");
}
} else if ("6".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = executableIndi.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>executableIndi:" + send);
} else {
log.info(">>>>>>>>>>>>>executableIndi dwdm is null.skip...>>>>>>>>");
}
} else if ("7".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = directPayVoucher.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>directPayVoucher:" + send);
} else {
log.info(">>>>>>>>>>>>>directPayVoucher dwdm is null.skip...>>>>>>>>");
}
} else if ("8".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = vouitem.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>vouitem:" + send);
} else {
log.info(">>>>>>>>>>>>>vouitem dwdm is null.skip...>>>>>>>>");
}
} else if ("9".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = oneCardSolu.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>oneCardSolu:" + send);
} else {
log.info(">>>>>>>>>>>>>oneCardSolu dwdm is null.skip...>>>>>>>>");
}
} else if ("10".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = account.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>account:" + send);
} else {
log.info(">>>>>>>>>>>>>account dwdm is null.skip...>>>>>>>>");
}
} else if ("11".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = generalplan.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>generalplan:" + send);
} else {
log.info(">>>>>>>>>>>>>generalplan dwdm is null.skip...>>>>>>>>");
}
} else if ("12".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = directPayment.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>directPayment:" + send);
} else {
log.info(">>>>>>>>>>>>>directPayment dwdm is null.skip...>>>>>>>>");
}
} else if ("13".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
send = earlywarning.get(dwdm, keylist, vallist, BigInteger.valueOf(startPage), BigInteger.valueOf(endPage)).send();
log.info(">>>>>>>>>>>>>get>>>>>>>>>earlywarning:" + send);
} else {
log.info(">>>>>>>>>>>>>earlywarning dwdm is null.skip...>>>>>>>>");
}
}
return send;
}
/\*\*
\* doSetDown 添加方法提取
\*
\* @param flag
\* @param vallist
\* @param dwdm
\* @param yslydm
\* @param jsonData
\* @param \_temp
\* @return
\* @throws Exception
\*/
private TransactionReceipt doSetDown(String flag, List<String> vallist, String dwdm, String yslydm, String jsonData, TransactionReceipt \_temp) throws Exception {
if ("1".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>budgetApp:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
\_temp = budgetApp.set(dwdm, vallist, jsonData).send(); // String strs = BudgetApp.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>budgetApp dwdm is null.skip…>>>>>>>>");
}
} else if ("2".equals(flag)) {
if (StringUtils.isNotBlank(yslydm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>dataSourIndi:" + yslydm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = dataSourIndi.set(yslydm, vallist, jsonData).send();
// String strs = DataSourIndi.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>dataSourIndi yslydm is null.skip…>>>>>>>>");
}
} else if ("3".equals(flag)) {
if (StringUtils.isNotBlank(yslydm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>targetRele:" + yslydm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = targetRele.set(yslydm, vallist, jsonData).send();
// String strs = TargetRele.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>targetRele yslydm is null.skip…>>>>>>>>");
}
} else if ("4".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>targetReleDown:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = targetReleDown.set(dwdm, vallist, jsonData).send();
// String strs = TargetReleDown.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>targetReleDown dwdm is null.skip…>>>>>>>>");
}
} else if ("5".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>indexTobeDiv:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
\_temp = indexTobeDiv.set(dwdm, vallist, jsonData).send(); // String strs = IndexTobeDiv.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>indexTobeDiv dwdm is null.skip…>>>>>>>>");
}
} else if ("6".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>executableIndi:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = executableIndi.set(dwdm, vallist, jsonData).send();
// String strs = ExecutableIndi.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>executableIndi dwdm is null.skip…>>>>>>>>");
}
} else if ("7".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>directPayVoucher:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = directPayVoucher.set(dwdm, vallist, jsonData).send();
// String strs = DirectPayVoucher.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>directPayVoucher dwdm is null.skip…>>>>>>>>");
}
} else if ("8".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>vouitem:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = vouitem.set(dwdm, vallist, jsonData).send();
// String strs = DirectPayVoucherItem.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>vouitem dwdm is null.skip…>>>>>>>>");
}
} else if ("9".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>oneCardSolu:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
\_temp = oneCardSolu.set(dwdm, vallist, jsonData).send(); // String strs = OneCardSolu.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>oneCardSolu dwdm is null.skip…>>>>>>>>");
}
} else if ("10".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>account:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = account.set(dwdm, vallist, jsonData).send();
// String strs = AccountingBook.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>account dwdm is null.skip…>>>>>>>>");
}
} else if ("11".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>generalplan:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = generalplan.set(dwdm, vallist, jsonData).send();
// String strs = Generalplan.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>generalplan dwdm is null.skip…>>>>>>>>");
}
}else if ("12".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>directPayment:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = directPayment.set(dwdm, vallist, jsonData).send();
// String strs = Generalplan.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>directPayment dwdm is null.skip…>>>>>>>>");
}
}else if ("13".equals(flag)) {
if (StringUtils.isNotBlank(dwdm)) {
log.info(">>>>>>>>>>>>>set>>>>>>>>>earlywarning:" + dwdm + " vallist:" + vallist + " jsonData:" + jsonData);
_temp = earlywarning.set(dwdm, vallist, jsonData).send();
// String strs = Generalplan.getTransactionDecoder().decodeOutputReturnJson(_temp.getInput(), _temp.getOutput());
log.info(">>>>>>>>>>>>>set>>>>>>>>>BlockNumber: " + _temp.getBlockNumber() + " BlockHash: " + _temp.getBlockHash());
} else {
log.info(">>>>>>>>>>>>>earlywarning dwdm is null.skip…>>>>>>>>");
}
}
return _temp;
}
手机扫一扫
移动阅读更方便
你可能感兴趣的文章