1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 414: 415: 416: 417: 418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430: 431: 432: 433: 434: 435: 436: 437: 438: 439: 440: 441: 442: 443: 444: 445: 446: 447: 448: 449: 450: 451: 452: 453: 454: 455: 456: 457: 458: 459: 460: 461: 462: 463: 464: 465: 466: 467: 468: 469: 470: 471: 472: 473: 474: 475: 476: 477: 478: 479: 480: 481: 482: 483: 484: 485: 486: 487: 488: 489: 490: 491: 492: 493: 494: 495: 496: 497: 498: 499: 500: 501: 502: 503: 504: 505: 506: 507: 508: 509: 510: 511: 512: 513: 514: 515: 516: 517: 518: 519: 520: 521: 522: 523: 524: 525: 526: 527: 528: 529: 530: 531: 532: 533: 534: 535: 536: 537: 538: 539: 540: 541: 542: 543: 544: 545: 546: 547: 548: 549: 550: 551: 552: 553: 554: 555: 556: 557: 558: 559: 560: 561: 562: 563: 564: 565: 566: 567: 568: 

<?php
/**
 * FlexiPeeHP - Třída pro zápis do FlexiBee.
 *
 * @author     Vítězslav Dvořák <vitex@arachne.cz>
 * @copyright  (C) 2015-2017 Spoje.Net
 */

namespace FlexiPeeHP;

/**
 * Základní třída pro zápis do FlexiBee
 *
 * @url https://demo.flexibee.eu/devdoc/http-operations
 */
class FlexiBeeRW extends FlexiBeeRO
{
    /**
     * Sloupeček obsahující datum vložení záznamu do shopu.
     *
     * @var string
     */
    public $myCreateColumn = 'false';

    /**
     * Slopecek obsahujici datum poslení modifikace záznamu do shopu.
     *
     * @var string
     */
    public $myLastModifiedColumn = 'lastUpdate';

    /**
     * Last Inserted ID.
     *
     * @var int
     */
    public $lastInsertedID = null;

    /**
     * Array of fields for next curl POST operation
     * 
     * @var string
     */
    public $postFields = null;

    /**
     * Transaction processing mode
     * 
     * @link https://www.flexibee.eu/api/dokumentace/ref/tx/ Transakční zpracování
     * @var boolean
     */
    public $atomic = null;

    /**
     * Record Copy helper
     * 
     * @var int 
     */
    private $sourceId = null;

    /**
     * SetUp Object to be ready for work
     *
     * @param array $options Object Options (authSessionId,user,password,
     *                                       url,company,evidence,companyUrl
     *                                       prefix,defaultUrlParams,debug,ver
     *                                       detail,offline,atomic,filter,ignore404
     */
    public function setUp($options = array())
    {
        if (array_key_exists('atomic', $options)) {
            $this->atomic = (boolean) $options['atomic'];
        }
        return parent::setUp($options);
    }

    /**
     * Save record (if evidence allow to).
     * Uloží záznam (pokud to evidence dovoluje)
     *
     * @param array $data Data to save
     * @throws Exception Evidence does not support Import
     *
     * @return array odpověď
     */
    public function insertToFlexiBee($data = null)
    {
        if (is_null($data)) {
            $data = $this->getData();
        }
        $this->postFields = $this->getJsonizedData($data,
            $this->debug ? JSON_PRETTY_PRINT : 0);
        return $this->performRequest(null, 'PUT');
    }

    /**
     * Parse Response array
     *
     * @param array $responseDecoded
     * @param int $responseCode Request Response Code
     *
     * @return array main data part of response
     */
    public function parseResponse($responseDecoded, $responseCode)
    {
        $parsedData = parent::parseResponse($responseDecoded, $responseCode);
        switch ($responseCode) {
            case 201: //Success Write
                if (is_array($responseDecoded)) {
                    $this->responseStats = array_key_exists('stats',
                            $responseDecoded) ? (isset($responseDecoded['stats'][0])
                            ? array_map('intval', $responseDecoded['stats'][0]) : array_map('intval',  $responseDecoded['stats']))
                            : null;

                    if (isset($responseDecoded[$this->resultField][0]['id'])) {
                        $this->lastInsertedID = $responseDecoded[$this->resultField][0]['id'];
                        $this->setMyKey($this->lastInsertedID);
                    } else {
                        $this->lastInsertedID = null;
                    }
                    if (count($this->chained)) {
                        $this->assignResultIDs($this->extractResultIDs($responseDecoded[$this->resultField]));
                    }
                }
                $parsedData = $responseDecoded['results'];
        }
        return $parsedData;
    }

    /**
     * Assign result IDs to its source objects
     * 
     * @param array $candidates FlexiBee insert IDs  prepared by extractResultIDs()
     */
    public function assignResultIDs($candidates)
    {
        foreach ($this->chained as $chid => $chained) {
            $chainedEvidence = $chained->getEvidence();
            $chainedExtid    = $chained->getRecordID();
            if (is_array($chainedExtid)) { //if there are more IDs
                foreach ($chainedExtid as $extId) { //find external ID in format ext:.....
                    if (stripos($extId, 'ext:') === 0) {
                        $chainedExtid = $extId;
                        break;
                    }
                }
            }
            $chained->getData();
            if (isset($candidates[$chainedEvidence][$chainedExtid])) {
                $chained->setMyKey($candidates[$chainedEvidence][$chainedExtid]);
                $chained->setDataValue('external-ids', [$chainedExtid]);
            }
            if (count($this->chained[$chid]->chained)) {
                $this->chained[$chid]->assignResultIDs($candidates);
            }
        }
    }

    /**
     * Extract IDs from FlexiBee response Array
     * 
     * @param array $resultInfo FlexiBee response
     * 
     * @return array List of [ 'evidence1'=>[ 'original-id'=>numericID,'original-id2'=>numericID2 ], 'evidence2'=> ... ]
     */
    public function extractResultIDs($resultInfo)
    {
        $candidates = [];
        foreach ($resultInfo as $insertResult) {
            $newID = $insertResult['id'];
            if (array_key_exists('request-id', $insertResult)) {
                $extid = $insertResult['request-id'];
            } else {
                $extid = null;
            }
            $evidence                      = explode('/', $insertResult['ref'])[3];
            $candidates[$evidence][$extid] = $newID;
        }
        return $candidates;
    }

    /**
     * Give you last inserted record ID.
     * 
     * @return int
     */
    public function getLastInsertedId()
    {
        return $this->lastInsertedID;
    }

    /**
     * Smaže záznam
     * Delete record in FlexiBee
     *
     * @param int|string $id identifikátor záznamu
     * 
     * @return boolean Response code is 200 ?
     */
    public function deleteFromFlexiBee($id = null)
    {
        if (is_null($id)) {
            $id = $this->getMyKey();
        }

        $this->performRequest($this->getEvidenceUrl().'/'.self::urlizeId($id),
            'DELETE');
        return $this->lastResponseCode == 200;
    }

    /**
     * Control for existing column names in evidence and take data
     *
     * @param array $data Data to keep
     * 
     * @return int number of records taken
     */
    public function takeData($data)
    {
        if ($this->debug === true) {
            $fbRelations = [];
            $fbColumns   = $this->getColumnsInfo();
            foreach ($this->getRelationsInfo() as $relation) {
                if (is_array($relation) && isset($relation['url'])) {
                    $fbRelations[$relation['url']] = $relation['url'];
                }
            }
            if (count($fbColumns)) {
                foreach ($data as $key => $value) {
                    if (!array_key_exists($key, $fbColumns)) {

                        if (!array_key_exists($key, $fbRelations)) {
                            $this->addStatusMessage(sprintf('unknown column %s for evidence %s',
                                    $key, $this->getEvidence()), 'warning');
                        } else {
                            if (!is_array($value)) {
                                $this->addStatusMessage(sprintf('subevidence %s in evidence %s must bee an array',
                                        $key, $this->getEvidence()), 'warning');
                            }
                        }
                    }
                }
            }
        }
        return parent::takeData($data);
    }

    /**
     * Control data for mandatory columns presence.
     *
     * @deprecated since version 1.8.7
     * 
     * @param array $data
     * 
     * @return array List of missing columns. Empty if all is ok
     */
    public function controlMandatoryColumns($data = null)
    {
        if (is_null($data)) {
            $data = $this->getData();
        }
        $missingMandatoryColumns = [];
        if (!empty($data) && count($data)) {
            $fbColumns = $this->getColumnsInfo();
            if (count($fbColumns)) {
                foreach ($fbColumns as $columnName => $columnInfo) {
                    $mandatory = ($columnInfo['mandatory'] == 'true');
                    if ($mandatory && !array_key_exists($columnName, $data)) {
                        $missingMandatoryColumns[$columnName] = $columnInfo['name'];
                    }
                }
            }
        }
        return $missingMandatoryColumns;
    }

    /**
     * Control data for readonly columns presence.
     *
     * @param array $data
     * 
     * @return array List of ReadOnly columns. Empty if all is ok
     */
    public function controlReadOnlyColumns($data = null)
    {
        if (is_null($data)) {
            $data = $this->getData();
        }

        $readonlyColumns = [];

        $fbColumns = $this->getColumnsInfo();
        if (!empty($fbColumns) && count($fbColumns)) {
            foreach ($fbColumns as $columnName => $columnInfo) {
                $writable = ($columnInfo['isWritable'] == 'true');
                if (!$writable && !array_key_exists($columnName, $data)) {
                    $readonlyColumns[$columnName] = $columnInfo['name'];
                }
            }
        }
        return $readonlyColumns;
    }

    /**
     * Convert Timestamp to FlexiBee Date format.
     *
     * @param int $timpestamp
     *
     * @return string FlexiBee Date or NULL
     */
    public static function timestampToFlexiDate($timpestamp = null)
    {
        $flexiDate = null;
        if (!is_null($timpestamp)) {
            $date      = new \DateTime();
            $date->setTimestamp($timpestamp);
            $flexiDate = $date->format('Y-m-d');
        }
        return $flexiDate;
    }

    /**
     * Convert Timestamp to Flexi DateTime format.
     *
     * @param int $timpestamp
     *
     * @return string FlexiBee DateTime or NULL
     */
    public static function timestampToFlexiDateTime($timpestamp = null)
    {
        $flexiDateTime = null;
        if (!is_null($timpestamp)) {
            $date          = new \DateTime();
            $date->setTimestamp($timpestamp);
            $flexiDateTime = $date->format('Y-m-dTH:i:s');
        }
        return $flexiDateTime;
    }

    /**
     * Add Data to evidence Branch
     * Přidá data do větve
     *
     * @thanksto Karel Běl
     *
     * @see Relations
     *
     * @param array   $data pole dat
     * @param string  $relationPath path evidence (relation) pro vkládaná data
     * @param boolean $removeAll
     *
     * @return boolean Operation success
     */
    public function addArrayToBranch($data, $relationPath = 'polozkyDokladu',
                                     $removeAll = false)
    {
        $currentBranchData = $this->getDataValue($relationPath);
        $branchData        = $currentBranchData;
        $branchData[]      = $data;
        if (is_array($this->getEvidence()) && array_key_exists('bezPolozek',
                $this->getColumnsInfo())) {
            $this->setDataValue('bezPolozek', false);
        }
        if ($removeAll === true) {
            $this->setDataValue($relationPath.'@removeAll', true);
        }
        return $this->setDataValue($relationPath, $branchData);
    }

    /**
     * Vloží do větve data z objektu
     *
     * @param FlexiBeeRO $object    objekt evidence
     * @param boolean    $removeAll flush older items 
     */
    public function addObjectToBranch($object, $removeAll = false)
    {
        $this->addArrayToBranch([$object->getEvidence() => $object->getData()],
            'polozkyDokladu', $removeAll);
    }

    /**
     * Přidá uživatelskou vazbu
     *
     * @see https://www.flexibee.eu/api/dokumentace/ref/uzivatelske-vazby/
     * @param string $vazba
     */
    public function vazbaAdd($vazba)
    {
        $this->addArrayToBranch(['uzivatelska-vazba' => $vazba],
            'uzivatelske-vazby');
    }

    /**
     * Smaže uživatelskou vazbu
     *
     * @see https://www.flexibee.eu/api/dokumentace/ref/uzivatelske-vazby/
     * @param string $vazba
     */
    public function vazbaDel($vazba)
    {
        $this->setDataValue('uzivatelska-vazba@action', 'delete');
        $this->addArrayToBranch(['uzivatelska-vazba' => $vazba],
            'uzivatelske-vazby');
    }

    /**
     * Převede data do Json formátu pro FlexiBee.
     * Pokud jsou štítky pole, jsou převedeny na seznam oddělený čárkou.
     * Convert data to FlexiBee like Json format.
     * Array of Labels is converted to coma separated list
     *
     * @param array $data
     * @param int   $options json_encode options like JSON_PRETTY_PRINT etc 
     *
     * @return string
     */
    public function getJsonizedData($data = null, $options = 0)
    {
        if (is_null($data)) {
            $data = $this->getData();
        }

        if (array_key_exists('stitky', $data)) {
            if (is_array($data['stitky'])) {
                $data['stitky'] = implode(',', $data['stitky']);
            }
        }
        $dataToJsonize = parent::getJsonizedData($data, $options);
        return $dataToJsonize;
    }

    /**
     * Get Data Fragment specific for current object
     * 
     * @param array $data
     * 
     * @return array
     */
    public function getDataForJSON($data = null)
    {
        if (is_null($data)) {
            $data = $this->getData();
        }
        $dataForJSON = parent::getDataForJSON($data);
        if (!is_null($this->atomic)) {
            $dataForJSON['@atomic'] = $this->atomic;
        }
        if (isset($this->sourceId)) {
            $dataForJSON['@sourceId'] = $this->sourceId;
            $this->sourceId           = null;
        }
        return $dataForJSON;
    }

    /**
     * Insert current data into FlexiBee and load actual record data back
     *
     * @param array $data Initial data to save
     * 
     * @return boolean Operation success
     */
    public function sync($data = null)
    {
        $this->insertToFlexiBee($data);
        $insertResult = $this->lastResponseCode;
        if ($insertResult == 201) {
            $this->reload();
        }
        $loadResult = $this->lastResponseCode;
        return ($insertResult + $loadResult) == 401;
    }

    /**
     * Make Copy of given record with optional modifiactions
     * 
     * !!!Experimental Feature!!!
     * 
     * @param int  $source
     * @param array $overrides
     * 
     * @return FlexiBeeRW|null copied record object or null in case of failure
     */
    public function copy($source, $overrides = [])
    {
        $this->sourceId = $source;
        return $this->sync($overrides) ? $this : null;
    }

    /**
     * Perform given action (if availble) on current evidence/record
     * @url https://demo.flexibee.eu/devdoc/actions
     *
     * @param string $action one of evidence actions
     * @param string $method ext|int External method call operation in URL.
     *                               Internal add the @action element to request body
     *
     * @return boolean operation success
     */
    public function performAction($action, $method = 'int')
    {
        $actionsAvailble = $this->getActionsInfo();

        if (is_array($actionsAvailble) && array_key_exists($action,
                $actionsAvailble)) {
            switch ($actionsAvailble[$action]['actionMakesSense']) {
                case 'ONLY_WITH_INSTANCE_AND_NOT_IN_EDIT':
                case 'ONLY_WITH_INSTANCE': //Add instance
                    $urlSuffix = '/'.$this->__toString().'/'.$action;
                    break;

                default:
                    $urlSuffix = '/'.$action;
                    break;
            }

            switch ($method) {
                case 'int':
                    $this->setAction($action);
                    $this->setPostFields($this->getJsonizedData(['id' => $this]));
                    $this->performRequest(null, 'POST');
                    $result = $this->lastResponseCode == 201;
                    break;

                default:
                    $result = $this->performRequest($this->evidenceUrlWithSuffix($urlSuffix),
                        'GET');
                    break;
            }
        } else {
            throw new \Exception(sprintf(_('Unsupported action %s for evidence %s'),
                    $action, $this->getEvidence()));
        }

        return $result;
    }

    /**
     * Add External ID to Current Record
     * 
     * @param string $extId ext:whatever:123 or simplay whatever:123
     * 
     * @return array Insert result
     */
    public function addExternalID($extId)
    {
        return $this->insertToFlexiBee(['id' => [$this->getRecordID(), 'ext:'.preg_replace('/^ext:/',
                        '', $extId)]]);
    }

    /**
     * Change Value of external id identified by selector. Add new if not exists
     * 
     * @param string     $selector ext:$selector:$newValue
     * @param string|int $newValue string or number
     * @param string|int $forID    Other than current record id
     * 
     * @return array operation result
     */
    public function changeExternalID($selector, $newValue, $forID = null)
    {
        $change['@removeExternalIds'] = 'ext:'.$selector.':';
        $change['id']                 = [is_null($forID) ? $this->getRecordID() : $forID,
            'ext:'.$selector.':'.$newValue];
        return $this->insertToFlexiBee($change);
    }
}