FileMaker Data API workshop – activity five

$client = new Client();
$response = $client->request($method, $uri, $options);

$client = new Client();
$options = [
    'headers' => [
        'Content-Type' => 'application/json'
    ],
    'auth' => [
        'username', 'password'
    ]
];
$response = $client->request('POST', 'https://your.server/fmi/data/v1/databases/your-database/sessions', $options);

$content = json_decode($response->getBody()->getContents());
$token = $content->response->token;

$body = [
    'fieldData' => [
         'Title' => 'Dr',
         'First' => 'Frederic',
         'Last' => 'Spoon',
         'Company' => 'FileMaker Inc',
         'Job Title' => 'Chief Cook and Bottle Wash'
    ]
];
$options = [
    'headers' => [
        'Content-Type' => 'application/json',
        'Authorization' => sprintf('Bearer %s', $token),
    ],
    'body' => json_encode($body)
];
$response = $client->request('POST', 'https://your.server/fmi/data/v1/databases/your-database/layouts/your-layout/records', $options);

/**
 * @param array $params
 *
 * @throws Exception
 */
private function fetchToken(array $params)
{
    $client = new Client();
    try {
        // Use a Guzzle request to access the FileMaker Data API setting the necessary
        // headers and credentials
        $options = [
            'headers' => [
                'Content-Type' => 'application/json'
            ],
            'auth' => [
                $params['username'], $params['password']
            ]
        ];
        $response = $client->request('POST', $this->baseURI . 'sessions', $options);

        // We get JSON back from the FileMaker Data API. The Guzzle response object stores
        // that in 'contents' which can be accessed with $response->getBody()->getContents()
        // we then need to json_decode that so that we can access the object in PHP
        $content = json_decode($response->getBody()->getContents());

        // The token is in response.token. We need to save that for future use. You could write it
        // to a file, but because we want this to be user-specific one good place to store it is
        // in the user's session
        $this->saveToken($content->response->token);
    } catch (Exception $exception) {
        // We need to catch any exceptions which occur and try and provide more useful feedback
        // The Data API uses standard HTTP responses (see https://httpstatuses.com/)

        /** @var ClientException $exception */
        if (404 == $exception->getResponse()->getStatusCode()) {
            // 404 is 'not found' and that's what gets returned when the user credentials are wrong
            throw new Exception($exception->getResponse()->getReasonPhrase(), 404);
        }

        // FileMaker is also really good at giving other error information if things go wrong. That's also
        // in the body contents which we can get from the exception using
        // $exception->getResponse()->getBody()->getContents()
        $content = json_decode($exception->getResponse()->getBody()->getContents());

        // Extract the message and throw an exception which we can use in the calling method
        // to access information about what went wrong.
        throw new Exception($content->messages[0]->message, $content->messages[0]->code);
    } catch (GuzzleException $exception) {
        throw new Exception('Unknown error', -1);
    }
}

/**
 * @param string $method    HTTP method to use for the request (e.g. GET, POST, PATCH etc)
 * @param string $uri       The endpoint to call - everything after the name of the database
 * @param array $options    Any data to send to the API with this call
 *
 * @return array
 *
 * @throws Exception
 */
public function performRequest(string $method, string $uri, array $options)
{
    // Set the standard headers which are needed for every call. We need to set
    // the Content-Type and the Authorization header. These are merged into the
    // options passed in which allows them to be overridden by any requests which
    // require different headers (e.g. container uploads)
    $headers = [
        'headers' => [
            'Content-Type' => 'application/json',
            'Authorization' => sprintf('Bearer %s', $this->retrieveToken()),
        ]
    ];

    // Create a Guzzle client
    $client = new Client();
    try {

        // Actually make the call with Guzzle. We pass through the method, we add the baseURI to the
        // requested uri, then merge the default headers with the other cURL options have have been
        // passed in to the request
        $response = $client->request($method, $this->baseURI . $uri, array_merge($headers, $options));

        // The JSON response from the Data API is in the body of the response which we can access
        // using $response->getBody()->getContents()
        $content = json_decode($response->getBody()->getContents(), true);

        // Depending on exactly which endpoint we're calling we either want the data, or the whole response
        // if there's a data set, send that, otherwise the whole response array.
        return isset($content['response']['data']) ? $content['response']['data'] : $content['response'];
    } catch (Exception $e) {
        /** @var ClientException $e */
        $content = json_decode($e->getResponse()->getBody()->getContents());
        if (401 == $content->messages[0]->code) {
            // no records found
            return [];
        }

        // if the token has expired or is invalid then in theory 952 will come back
        // but sometimes you get 105 missing layout (go figure), so try a token refresh
        if (in_array($content->messages[0]->code, [105, 952]) && !$this->retried) {
            // TODO (Activity six) come up with some way to try logging the user back in
        }
        throw new Exception($content->messages[0]->message, $content->messages[0]->code);
    } catch (GuzzleException $e) {
        throw new Exception('Unknown error', -1);
    }
}