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: 

<?php
namespace Comprobo\Verify;

use Comprobo\Verify\Factory;

/**
 * Comprobo\Verify\Api is the public API for the Verify SDK. All public methods should be considered
 * normal operation of the SDK.
 *
 * It is possible to retrieve individual objects and make calls directly to different services although
 * this should not be a requirement for normal usage.
 *
 * USAGE:
 *
 * $env = 'local' // 'staging' or 'production'
 *
 * $verify = Comprobo\Verify\Api::create($env);
 *
 * $verify->authenticate($key, $secret);
 *
 * ...
 *
 */
class Api
{
    private $factory;
    private $config;
    private $state;

    /**
     * Bootstrap the Verify API. Custom configuration options are currently not supported.
     *
     * @param string $env  'local', 'staging' or 'production'
     * @param array  $config additional configuration options
     * @return Comprobo\Verify\Api
     */
    public static function create($env = 'local', array $config = [])
    {
        if (!is_string($env) || empty($env)) {
            $env = 'local';
        }

        $config['env'] = $env;
        $factory = new Factory($config);
        return new static($factory);
    }

    /**
     * Used by the factory itself. If you happen to need to instantiate the API this way then you can.
     *
     * @param Factory $factory
     */
    public function __construct(Factory $factory)
    {
        $this->factory = $factory;
        $this->config  = $factory->getConfig();
        $this->state   = $factory->getState();
    }

    /**
     * Helper method to provide javascript asset location.
     *
     * @return string path to JavaScript file for inclusion where Verify is to be used
     */
    public function javascriptPath()
    {
        return $this->factory->javascriptPath();
    }

    /**
     * Use your application key and secret
     * to set JWT token and organisation ID
     * in the current API context
     *
     * After this is called, you may continue to use the rest of the API
     * methods provided here.
     *
     * @param  $key    string
     * @param  $secret string
     * @return boolean true
     */
    public function authenticate($key, $secret)
    {
        $body = $this->factory->getServerAuth()->authenticate($key, $secret);

        $token = isset($body['token']) ? $body['token'] : false;
        if (!$token) {
            return false;
        }

        $orgId = isset($body['orgId']) ? $body['orgId'] : false;
        if (!$token) {
            return false;
        }

        $this->state->set('organisationId', $orgId);
        $this->state->set('token', $token);
        return true;
    }

    /**
     * Add a user to Comprobo. Pass in your own particulars to receive a valid uuid.
     *
     * Returns an existing user if one is found that matches the given details.
     *
     * @param  string $clientId your local identifier for this user
     * @param  string $firstName
     * @param  string $lastName
     * @param  string $email
     * @return string Comprobo user id (uuidv4)
     */
    public function createUser($clientId, $firstName, $lastName, $email)
    {
        $existing = $this->findExistingUser($clientId);
        if ($existing) {
            return $existing;
        }

        $body = $this->factory->getUser()->create($firstName, $lastName, $email);
        $newUserId = $body['id'];

        $this->saveUserMapping($clientId, $newUserId);

        return $newUserId;
    }

    /**
     * Clones the selected template to create an assignable Workflow instance.
     * Any custom fields provided are persisted at this stage and may not be changed.
     *
     * @param  string $templateId      uuid4 template workflow ID.
     * @param  string $newWorkflowName provide a name that will appear for this in the reporting tools
     * @param  array  $customFields    any merge fields defined by the template will be accepted at clone time.
     * @return string                  uuid4 the workflow ID
     */
    public function setupTemplate($templateId, $newWorkflowName, array $customFields = [])
    {
        $existing = $this->findExistingWorkflow($templateId, $newWorkflowName);
        if ($existing) {
            return $existing;
        }

        $body = $this->factory->getWorkflow()->cloneTemplate($templateId, $newWorkflowName, $customFields);
        $newWorkflowId = $body['id'];

        $this->saveTemplateMapping($templateId, $newWorkflowName, $newWorkflowId);

        return $newWorkflowId;
    }

    /**
     * Returns any custom merge fields defined for the given workflow
     *
     * @param $workflowId an active workflowId retrieved from setupTemplate
     * @return array list of fieldnames required to update the merge fields
     */
    public function listCustomFields($workflowId)
    {
        return $this->factory->getWorkflow()->getMergeFields($workflowId);
    }

    /**
     * List the available templates for monitoring, used for configuration
     *
     * @return array available templates to clone
     */
    public function listTemplates()
    {
        return $this->factory->getWorkflow()->listTemplates();
    }

    /**
     * @param  string $comproboUserId [description]
     * @param  string $workflowId     [description]
     * @return bool   true
     */
    public function assignWorkflow($comproboUserId, $workflowId)
    {
        return $this->comprobo->getUser()->assignWorkflow($comproboUserId, $workflowId);
    }

    public function impersonate($comproboUserId)
    {
        return $this->comprobo->getUser()->token($comproboUserId);
    }

    private function findExistingWorkflow($templateId, $newWorkflowName)
    {
        $mappings = $this->getMapping('workflow');
        foreach ($mappings as $mapping) {
            if ($mapping['templateId'] === $templateId &&
                $mapping['workflowName'] === $newWorkflowName
            ) {
                return $mapping['workflowId'];
            }
        }
        return false;
    }

    private function findExistingUser($clientId)
    {
        $mappings = $this->getMapping('user');
        foreach ($mappings as $mapping) {
            if ($mapping['clientId'] === $clientId) {
                return $mapping['comproboId'];
            }
        }

        return false;
    }
    private function saveUserMapping($clientId, $comproboId)
    {
        $mappings = $this->getMapping('user');
        $mappings[] = [
            'clientId' => $clientId,
            'comproboId' => $comproboId,
        ];
        $this->saveMapping('user', $mappings);
    }

    private function saveTemplateMapping($templateId, $newWorkflowName, $newWorkflowId)
    {
        $mappings = $this->getMapping('workflow');
        $mappings[] = [
            'templateId' => $templateId,
            'workflowName' => $newWorkflowName,
            'workflowId' => $newWorkflowId,
        ];
        $this->saveMapping('workflow', $mappings);
    }

    private function saveMapping($type, $data)
    {
        $filename = $this->config['data']['mappingsFile'];
        $mappings = $this->getAllMappings();
        $mappings[$type] = $data;
        file_put_contents($filename, json_encode($mappings));
    }

    private function getMapping($type)
    {
        $mappings = $this->getAllMappings();

        if (!array_key_exists($type, $mappings) || !is_array($mappings[$type])) {
            return [];
        }

        return $mappings[$type];
    }

    private function getAllMappings()
    {
        $filename = $this->config['data']['mappingsFile'];
        if (!file_exists($filename)) {
            return [];
        }

        $mappings = json_decode(file_get_contents($filename), true);

        if (!$mappings || !is_array($mappings)) {
            return [];
        }
        return $mappings;
    }
}