Honeycomb API usage inside Ethereum smart-contract

ShareContent.sol

pragma solidity 0.4.24;

import "https://github.com/smartcontractkit/chainlink/evm/contracts/ChainlinkClient.sol";
import "https://github.com/smartcontractkit/chainlink/evm/contracts/vendor/Ownable.sol";

// last deployed contract - 0x6869bB190b75bf9c058662970A572537DC61d82a

// 0x5D71c462b6fD182dBEaC9ce577b15C6EBB39F821 - 
// oracle address = 0x4a3fbbb385b5efeb4bc84a25aaadcd644bd09721
// jobId - d1d029a5f50c44789f19da3ec4e51e7b (bytes)

// token - 0x20fE562d797A42Dcb3399062AE9546cd06f63280
// oracle Neutrino 0x4a3fbbb385b5efeb4bc84a25aaadcd644bd09721 
// ipinfo - bytes32 68a7a089c830423584ace76fa96967d8
// hex - 0x3638613761303839633833303432333538346163653736666139363936376438

// bad word filter - ebd878dd37464f9f8b5411e3819468b5
// hex - 0x6562643837386464333734363466396638623534313165333831393436386235

// neutrino browser-bot jobId - 29ea1f47f6504ed188e00b3d7b81ac49
// hex - 0x3239656131663437663635303465643138386530306233643762383161633439
// price in wei - 111000000000000000
// 111000000000000000
// or
// 100000000000000000

// {
// "url" : "https://www.add.ua/ua/sumamed-poroshok-dlja-prigotovlenija-suspenzii-100mg-5-ml-flakon-20ml-kalibr-shpr-lozh.html?amp=1",
// "selector": ".price-description"
// }

contract ShareAnalyzes is ChainlinkClient, Ownable {
    
    struct ShareData {
        address doctor;
        string content;
        string url;
        bytes32 city;
    }
    
     struct SecureNote {
        address[] trustedAccount;
        string content;
        bytes32 trustedCity;
        bool active;
        uint256 ts;
    }
    
    uint256 private oraclePaymentAmount;
    bytes32 private jobIpInfoId;
    bytes32 private jobBadWordId;
    bytes32 private jobBrowserBotId;
    
    // requestId -> city defined
    mapping (bytes32 => bool) public resultCityRecivedMapping;
    mapping (bytes32 => bytes32) public resultCityMapping;
    
    // requestId -> contains bad words
    mapping (bytes32 => bool) public resultBadWordRecivedMapping;
    mapping (bytes32 => bool) public resultBadWordMapping;
    
    // requestId -> use vpn 
    mapping (bytes32 => bool) public resultIsVpnRecivedMapping;
    mapping (bytes32 => bool) public resultIsVpnMapping;
    
    // requestId -> price from website
    mapping (bytes32 => bool) public resultPriceRecievedMapping;
    mapping (bytes32 => bytes32) public resultPriceMapping;
    
    //uuid - data
    mapping(string => ShareData) private accessMapping;
    // mapping(string => bool) private hasDataForMapping;
    
    mapping(address => SecureNote) private secureNoteMapping;
    
    constructor(
        address _link,
        address _oracle,
        bytes32 _jobId,
        bytes32 _jobId2,
        bytes32 _jobId3,
        uint256 _oraclePaymentAmount
        )
    public
    {
        setChainlinkToken(_link);
        setChainlinkOracle(_oracle);
        jobIpInfoId = _jobId;
        jobBadWordId = _jobId2;
        jobBrowserBotId = _jobId3;
        oraclePaymentAmount = _oraclePaymentAmount;
    }
    
    function setAccess(string _uuid, address _who, bytes32 _badWordsRequestId, string _url, bytes32 _city) external returns  (bool successfull){
        require(resultBadWordRecivedMapping[_badWordsRequestId] = true);
        require(resultBadWordMapping[_badWordsRequestId] == false);
        ShareData memory newData = ShareData({url : _url, content : "", city : _city, doctor : _who});
        accessMapping[_uuid] = newData;
        successfull = true;
    }
    
    function setAccess(string _uuid, address _who, string _content, bytes32 _badWordsRequestId, bytes32 _city) external returns  (bool successfull){
        require(resultBadWordRecivedMapping[_badWordsRequestId] = true);
        require(resultBadWordMapping[_badWordsRequestId] == false);
        ShareData memory newData = ShareData({url : "", content: _content, city : _city, doctor : _who});
        accessMapping[_uuid] = newData;
        successfull = true;
    }
    
      function compareStrings (string memory a, string memory b) public pure returns (bool) {
            return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))) );
       }
       
    function readLink(string _uuid, bytes32 _requestId, bytes32 _cityRequestId) external view  returns  (string url){
        require(resultCityRecivedMapping[_cityRequestId] == true );
        require(resultIsVpnRecivedMapping[_requestId] == true );
        require(resultIsVpnMapping[_requestId] == false);
        // string memory _city = accessMapping[msg.sender].city;
        bytes32 userCity =  resultCityMapping[_cityRequestId];
        bytes32 city = accessMapping[_uuid].city;
        // require(compareStrings(userCity, city));
        require(city == userCity);
        url = accessMapping[_uuid].url;
    }
    
    function readSharedDataContent(string _uuid, bytes32 _requestId, bytes32 _cityRequestId) external view  returns  (string content){
        require(resultCityRecivedMapping[_cityRequestId] == true );
        require(resultIsVpnRecivedMapping[_requestId] == true );
        require(resultIsVpnMapping[_requestId] == false);
        // string memory _city = accessMapping[msg.sender].city;
        bytes32 userCity =  resultCityMapping[_cityRequestId];
        bytes32 city = accessMapping[_uuid].city;
        // require(compareStrings(userCity, city));
        require(city == userCity);
        content = accessMapping[_uuid].content;
    }
    
    // location by ip
     function makeRequest(string _ip) external returns (bytes32 requestId){
        Chainlink.Request memory req = buildChainlinkRequest(jobIpInfoId, this, this.fulfill.selector);
        req.add("ip", _ip);
        req.add("copyPath", "city");
        requestId = sendChainlinkRequestTo(chainlinkOracleAddress(), req, oraclePaymentAmount);
    }
    
    // get bad words contains info
    function makeRequest2(string _content) external returns (bytes32 requestId){
        Chainlink.Request memory req = buildChainlinkRequest(jobBadWordId, this, this.fulfill2.selector);
        req.add("content", _content);
        req.add("copyPath", "is-bad");
        requestId = sendChainlinkRequestTo(chainlinkOracleAddress(), req, oraclePaymentAmount);
    }
    
    // is_vpn - from ip
     function makeRequest3(string _ip) external returns (bytes32 requestId){
        Chainlink.Request memory req = buildChainlinkRequest(jobIpInfoId, this, this.fulfill3.selector);
        req.add("ip", _ip);
        req.add("copyPath", "is-vpn");
        requestId = sendChainlinkRequestTo(chainlinkOracleAddress(), req, oraclePaymentAmount);
    }
    
    // price
     function requestPrice(string url, string _selector) external returns (bytes32 requestId){
        Chainlink.Request memory req = buildChainlinkRequest(jobBrowserBotId, this, this.fulfillPrice.selector);
        req.add("url", url);
        req.add("selector", _selector);
        req.add("copyPath", "title");
        requestId = sendChainlinkRequestTo(chainlinkOracleAddress(), req, oraclePaymentAmount);
    }

    // for city
    function fulfill(bytes32 _requestId, bytes32 _result) public recordChainlinkFulfillment(_requestId){
        resultCityRecivedMapping[_requestId] = true;
        resultCityMapping[_requestId] = _result;
    }
    
    // for bad words
    function fulfill2(bytes32 _requestId, bool _result) public recordChainlinkFulfillment(_requestId){
        resultBadWordRecivedMapping[_requestId] = true;
        resultBadWordMapping[_requestId] = _result;
    }
    
    // for is-vpn 
    function fulfill3(bytes32 _requestId, bool _result) public recordChainlinkFulfillment(_requestId){
        resultIsVpnRecivedMapping[_requestId] = true;
        resultIsVpnMapping[_requestId] = _result;
    }
    
    // for price
    function fulfillPrice(bytes32 _requestId, bytes32 _result) public recordChainlinkFulfillment(_requestId){
        resultPriceRecievedMapping[_requestId] = true;
        resultPriceMapping[_requestId] = _result;
    }
    
    function hasSecureNote(address _owner) view returns (bool){
        if(!secureNoteMapping[_owner].active){
            return false;
        }
        return true;
    }
    
    function writeSecureNote(address[] _trustedAccount, string _content, bytes32 _trustedCity) external returns (bool){
        SecureNote memory newNote = SecureNote({trustedAccount: _trustedAccount, content : _content, trustedCity : _trustedCity, active : true, ts : block.timestamp   });
        secureNoteMapping[msg.sender] = newNote;
        return true;
    }
    
    function getSecureNote(address _owner, bytes32 __cityRequestId, bytes32 _vpnRequestId) external returns (string content){
        require(resultIsVpnRecivedMapping[_vpnRequestId]);
        require(resultCityRecivedMapping[_vpnRequestId]);
        require(resultIsVpnMapping[_vpnRequestId] == false);
        require(secureNoteMapping[_owner].active == true);
        bytes32 trustedCity = secureNoteMapping[_owner].trustedCity;
        require(trustedCity == resultCityMapping[__cityRequestId]);
        content = secureNoteMapping[_owner].content;
    }
    
    
}