etrusts2.0-test.sol

pragma solidity ^0.4.21;


library strings {
    struct slice {
        uint _len;
        uint _ptr;
    }

    function memcpy(uint dest, uint src, uint len) private pure {

        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))
        }
    }


    function toSlice(string self) internal pure returns (slice) {
        uint ptr;
        assembly {
            ptr := add(self, 0x20)
        }
        return slice(bytes(self).length, ptr);
    }

    function len(bytes32 self) internal pure returns (uint) {
        uint ret;
        if (self == 0)
            return 0;
        if (self & 0xffffffffffffffffffffffffffffffff == 0) {
            ret += 16;
            self = bytes32(uint(self) / 0x100000000000000000000000000000000);
        }
        if (self & 0xffffffffffffffff == 0) {
            ret += 8;
            self = bytes32(uint(self) / 0x10000000000000000);
        }
        if (self & 0xffffffff == 0) {
            ret += 4;
            self = bytes32(uint(self) / 0x100000000);
        }
        if (self & 0xffff == 0) {
            ret += 2;
            self = bytes32(uint(self) / 0x10000);
        }
        if (self & 0xff == 0) {
            ret += 1;
        }
        return 32 - ret;
    }

    function toSliceB32(bytes32 self) internal pure returns (slice 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 self) internal pure returns (slice) {
        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 self) internal pure returns (string) {
        string memory ret = new string(self._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        memcpy(retptr, self._ptr, self._len);
        return ret;
    }


    function len(slice 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 self) internal pure returns (bool) {
        return self._len == 0;
    }


    function compare(slice self, slice 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 = ~(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 self, slice 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 self, slice rune) internal pure returns (slice) {
        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 self) internal pure returns (slice 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 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 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 self, slice 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 self, slice needle) internal pure returns (slice) {
        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(sha3(selfptr, length), sha3(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 self, slice 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;
    }


    function until(slice self, slice needle) internal pure returns (slice) {
        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;
    }

    event log_bytemask(bytes32 mask);

    // 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 := sha3(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := sha3(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 := sha3(needleptr, needlelen) }
                ptr = selfptr + (selflen - needlelen);
                while (ptr >= selfptr) {
                    bytes32 testHash;
                    assembly { testHash := sha3(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 self, slice needle) internal pure returns (slice) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len -= ptr - self._ptr;
        self._ptr = ptr;
        return self;
    }


    function rfind(slice self, slice needle) internal pure returns (slice) {
        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 self, slice needle, slice token) internal pure returns (slice) {
        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 self, slice needle) internal pure returns (slice 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 self, slice needle, slice token) internal pure returns (slice) {
        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 self, slice needle) internal pure returns (slice 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 self, slice 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 self, slice 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 self, slice other) internal pure returns (string) {
        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 self, slice[] parts) internal pure returns (string) {
        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(i = 0; i < parts.length; i++) {
            memcpy(retptr, parts[i]._ptr, parts[i]._len);
            retptr += parts[i]._len;
            if (i < parts.length - 1) {
                memcpy(retptr, self._ptr, self._len);
                retptr += self._len;
            }
        }

        return ret;
    }
}

/*
 * @title String & slice utility library for Solidity contracts.
 * @author from stackoverflow community <https://ethereum.stackexchange.com>
 *
 * @dev transform type to type
 */
 contract Converter {

    function stringToBytes32(string memory source) public pure returns (bytes32 result) {
        bytes memory tempEmptyStringTest = bytes(source);
        if (tempEmptyStringTest.length == 0) {
            return 0x0;
        }
        assembly {
            result := mload(add(source, 32))
        }
    }

    function bytes32ToString(bytes32 x) public pure returns (string) {
        bytes memory bytesString = new bytes(32);
        uint charCount = 0;
        for (uint j = 0; j < 32; j++) {
            byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
            if (char != 0) {
                bytesString[charCount] = char;
                charCount++;
            }
        }
        bytes memory bytesStringTrimmed = new bytes(charCount);
        for (j = 0; j < charCount; j++) {
            bytesStringTrimmed[j] = bytesString[j];
        }
        return string(bytesStringTrimmed);
    }

    function stringToBytes(string s) internal pure returns(bytes) {
        bytes memory b3 = bytes(s);
        return b3;
    }
}

contract Ownable {

     uint256 public howManyOwnersDecide;
     address[] public owners;
     bytes32[] public allOperations;
     address insideOnlyManyOwners;

     // Reverse lookup tables for owners and allOperations
     mapping(address => uint) ownersIndices; // Starts from 1
     mapping(bytes32 => uint) allOperationsIndicies;

     // Owners voting mask per operations
     mapping(bytes32 => uint256) public votesMaskByOperation;
     mapping(bytes32 => uint256) public votesCountByOperation;

     // EVENTS

     event OwnershipTransferred(address[] previousOwners, address[] newOwners);

     // ACCESSORS

     function isOwner(address wallet) public constant returns(bool) {
         return ownersIndices[wallet] > 0;
     }

     function ownersCount() public constant returns(uint) {
         return owners.length;
     }

     function allOperationsCount() public constant returns(uint) {
         return allOperations.length;
     }

     // MODIFIERS

     /**
     * @dev Allows to perform method by any of the owners
     */
     modifier onlyAnyOwner {
         require(isOwner(msg.sender));
         _;
     }

     /**
     * @dev Allows to perform method only after all owners call it with the same arguments
     */
     modifier onlyManyOwners {
         if (insideOnlyManyOwners == msg.sender) {
             _;
             return;
         }
         require(isOwner(msg.sender));

         uint ownerIndex = ownersIndices[msg.sender] - 1;
         bytes32 operation = keccak256(msg.data);

         if (votesMaskByOperation[operation] == 0) {
             allOperationsIndicies[operation] = allOperations.length;
             allOperations.push(operation);
         }
         require((votesMaskByOperation[operation] & (2 ** ownerIndex)) == 0);
         votesMaskByOperation[operation] |= (2 ** ownerIndex);
         votesCountByOperation[operation] += 1;

         // If all owners confirm same operation
         if (votesCountByOperation[operation] == howManyOwnersDecide) {
             deleteOperation(operation);
             insideOnlyManyOwners = msg.sender;
             _;
             insideOnlyManyOwners = address(0);
         }
     }

     // CONSTRUCTOR

     function ManagmentRights() public {
         owners.push(msg.sender);
         ownersIndices[msg.sender] = 1;
         howManyOwnersDecide = 1;
     }

     // INTERNAL METHODS

     /**
     * @dev Used to delete cancelled or performed operation
     * @param operation defines which operation to delete
     */
     function deleteOperation(bytes32 operation) internal {
         uint index = allOperationsIndicies[operation];
         if (index < allOperations.length - 1) {
             allOperations[index] = allOperations[allOperations.length - 1];
             allOperationsIndicies[allOperations[index]] = index;
         }
         allOperations.length--;

         delete votesMaskByOperation[operation];
         delete votesCountByOperation[operation];
         delete allOperationsIndicies[operation];
     }

     // PUBLIC METHODS

     /**
     * @dev Allows owners to change their mind by cacnelling votesMaskByOperation operations
     * @param operation defines which operation to delete
     */
     function cancelPending(bytes32 operation) public onlyAnyOwner {
         uint ownerIndex = ownersIndices[msg.sender] - 1;
         require((votesMaskByOperation[operation] & (2 ** ownerIndex)) != 0);

         votesMaskByOperation[operation] &= ~(2 ** ownerIndex);
         votesCountByOperation[operation]--;
         if (votesCountByOperation[operation] == 0) {
             deleteOperation(operation);
         }
     }

     /**
     * @dev Allows owners to change ownership
     * @param newOwners defines array of addresses of new owners
     */
     function transferOwnership(address[] newOwners) public {
         transferOwnershipWithHowMany(newOwners, newOwners.length);
     }

     /**
     * @dev Allows owners to change ownership
     * @param newOwners defines array of addresses of new owners
     * @param newHowManyOwnersDecide defines how many owners can decide
     */
     function transferOwnershipWithHowMany(address[] newOwners, uint256 newHowManyOwnersDecide) public onlyManyOwners {
         require(newOwners.length > 0);
         require(newOwners.length <= 256);
         require(newHowManyOwnersDecide > 0);
         require(newHowManyOwnersDecide <= newOwners.length);
         for (uint i = 0; i < newOwners.length; i++) {
             require(newOwners[i] != address(0));
         }

         emit OwnershipTransferred(owners, newOwners);

         // Reset owners array and index reverse lookup table
         for (i = 0; i < owners.length; i++) {
             delete ownersIndices[owners[i]];
         }
         for (i = 0; i < newOwners.length; i++) {
             require(ownersIndices[newOwners[i]] == 0);
             ownersIndices[newOwners[i]] = i + 1;
         }
         owners = newOwners;
         howManyOwnersDecide = newHowManyOwnersDecide;

         // Discard all pendign operations
         for (i = 0; i < allOperations.length; i++) {
             delete votesMaskByOperation[allOperations[i]];
             delete votesCountByOperation[allOperations[i]];
             delete allOperationsIndicies[allOperations[i]];
         }
         allOperations.length = 0;
     }
 }

 // котнтракт хранилище для заданий клиентов - TaskStorage
 // контракт менеджмента - ManagmentRights
 // контракт выбора исполнителя -
 // контракт приема клиентов (добавление клиентов)
 // контракт хранилище контрактов (тут будут храниться адресса контрактов сисметы)
 // контракт рейтинга исполнителей RaitingSystem (на основе системы оценок)

hierarhy system
    // ядро типо супер овнер.
interface Fabric {}
interface Upgradeable {}
interface Migration {}

interface ArtificialIntelligence/SystemLogicHandler {
    function comparePerformers() internal returns (bool);
    function pickPerformers(address[] _performers) external returns (bool, address);
    function findAvaliable(address[] _performers) external returns (address[]);
}

interface RaitingSystem {
    /** получаем весь список испольнителей */
    function getAllPerformers() external view returns (address[] all_performers);
    /** получаем список исполнителей за набором скилов (сектор энономики, род деятельности) */
    function getSelectedPerformers(bytes32[] behind_skills) external view returns (address[] sel_performers); // by the skills
    /** */
    function getPFManagers() external view returns (address[] pf_managers);
    function getCRManagers() external view returns (address[] cr_managers);

    function setPFManagers() external returns (bool, address);
    function setCRManagers() external returns (bool, address);

    function setPerformerForTask(address perfomer, address client, bytes32 task_id) external returns (bool);

    function standClient() external returns (bool, address);
    function checkNewClient() external returns (address[]);
    function confirmNewClient() external returns (bool);

    function increaseRaiting(address _performer) external returns (bool);
    function decreaseRaiting(address _performer) external returns (bool);
}

interface TaskHandler {

    function addNewTask(address user, string cli_task) external returns (bool, bytes32);
    function countCliTasks(address _cli) public view returns (uint256);
    function getCliTaskData(address _cli, uint256 _id) public view returns (uint256);

    function isTaskOverflow(address _cli) internal returns (bool);

    function completedTasks() external view returns (address, uint256[] clist);
    function uncompletedTasks() external view returns (address, uint256[] clist);
    function pendingTasks() external view returns (address, uint256[] clist);
}

contract EthernalTrust is Ownable, Converter {

    using strings for *;

    mapping (address => bool) pf_manager; // SP maganer, Artificial Intelligence AI in the fuature
    uint256[] pf_m_count; // clients tasks counter

    mapping (address => bool) performers;
    uint256[] pf_count; // clients tasks counter

    mapping (address => bool) cr_manager; // client relations manager CR-Manager
    uint256[] cr_count; // clients tasks counter

    mapping (address => bool) clients;
    uint256[] cli_count; // clients tasks counter

    mapping (address => mapping(uint256 => ctask) ) clients_tasks;
    mapping (address => uint256) cli_t_count; // clients tasks counter

    struct ctask {
        uint256 id;
    }

    mapping (bytes32 => address) internal pft;

    function setPerformerForTask() public {
         //
    }

    // MODIFIERS
    modifier is_cli() {
        require(clients[msg.sender] == true);
        _;
    }

    modifier is_no_cli() {
        require(clients[msg.sender] == true);
        _;
    }

    modifier is_cr_mng() {
        require(cr_manager[msg.sender] == true);
        _;
    }

    modifier is_pfm() {
        require(performers[msg.sender] == true);
        _;
    }

    modifier is_pf_mng() {
        require(pf_manager[msg.sender] == true);
        _;
    }

    function setPFManager(address _manager) public onlyAnyOwner
        returns (bool, address)
    {
        pf_manager[_manager] = true;
        pf_m_count.push(1);
        return (true, _manager);
    }

    function setCRManager(address _manager) public onlyAnyOwner
        returns (bool, address)
    {
        cr_manager[_manager] = true;
        cr_count.push(1);
        return (true, _manager);
    }

    /** work with tasks */
    function addNewTask(address user, string cli_task) public is_cr_mng
        returns (bool, bytes32)
    {
        bytes32 cli_key = keccak256(stringToBytes(cli_task));
        uint256 task_id = cli_t_count[user];
        clients_tasks[user][task_id + 1]; // add k=>v pair
        cli_t_count[user] = task_id + 1; // set k task length

        return (true, cli_key);
    }

    /** get client task length */
    function countCliTasks(address _cli) public view returns (uint256) {
        return cli_t_count[_cli];
    }

    /** get client task data, text */
    function getCliTaskData(address _cli, uint256 _id) public view returns (uint256) {
        // add prevent id oferflow
        return clients_tasks[_cli][_id].id;
    }



    // Обработка выполненных заданий [выполнены/в процессе/еще в поиске исполнителя]
}