@troveng/swagger-gen-js/validate-output/api_gen/V4/profile.js

// @flow
/* eslint-disable import/first */
// PROFILE - API MODULE
// ============================================================================

/*
 * WARNING: This file was automatically generated. Do not modify it directly, or
 * your changes will be overwritten.
 */

import type { RequestStatus, SwaggerFetchPathOptions } from '../../../utility/Fetch';
import { SwaggerFetch } from '../../../utility/Fetch';
import t from 'flow-runtime';

import type {
  TrovCommonModelProfileProfile,
  UnexpectedErrorException,
  TrovCommonModelProfileCustomerProfile,
  CustomerAddressNotSupportedException,
  CustomerAgeNotSupportedException,
  CustomerProfileInformationMissingException,
  StateOfResidenceNotSupportedException,
  ArgumentException,
  UnsupportedImageException,
  DocumentAccessException,
} from '../../types_gen/V4';
import Validators from '../../validators_gen/V4';

/**
 * Gets the profile for the current user.
 * @param {Object} header
 * @param {string} header.Trov-Tenant - The tenant to use for the requests.
 * @param {string} header.Trov-Market - The market to use for the requests.
 * @param {string} header.Trov-Client - The identifier of the client making
 *   the request.
 * @param {string} header.Accept-Language - The language to use for
 *   localization of responses (where applicable).
 * @param {string} header.Authorization - The bearer access token to authorize
 *   the request (e.g. `bearer TOKEN`)
 */
export type getApiProfileHeader = {|
  'Trov-Tenant': string,
  'Trov-Market': string,
  'Trov-Client': string,
  'Accept-Language': string,
  Authorization: string
|};

export type GetApiProfileResponseBody = TrovCommonModelProfileProfile | UnexpectedErrorException;

export type GetApiProfileInit = {
  header: getApiProfileHeader,
} & RequestOptions;

export type GetApiProfileOptions = SwaggerFetchPathOptions;

export class GetApiProfile extends SwaggerFetch {
  constructor(init: GetApiProfileInit, options: GetApiProfileOptions) {
    const finalInit = {
      ...init,
      method: 'GET',
    };
    super(finalInit, options);

    this.endpoint = '/api/v4.0/profile';
  }

  handleResponseStatus(response: Response, parsedBody: GetApiProfileResponseBody): ({
    response: Response,
    body: ?GetApiProfileResponseBody,
    status: RequestStatus,
  }) {
    const body = (parsedBody && typeof parsedBody === 'object') ? parsedBody : null;
    let status = 'MISTAKE';

    switch (response.status) {
      // 2XX STATUSES
      case 200:
        status = 'SUCCESS';
        // OK
        if (process.env.DEV_TOOLS) {
          const TrovCommonModelProfileProfileValidation = Validators.TrovCommonModelProfileProfile.validate(parsedBody);
          if (TrovCommonModelProfileProfileValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(TrovCommonModelProfileProfileValidation), null, 2));
          }
        }
        break;

      // 5XX STATUSES
      case 500:
        status = 'FAILURE';
        // An unexpected error has occurred.
        if (process.env.DEV_TOOLS) {
          const UnexpectedErrorExceptionValidation = Validators.UnexpectedErrorException.validate(parsedBody);
          if (UnexpectedErrorExceptionValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(UnexpectedErrorExceptionValidation), null, 2));
          }
        }
        break;


      default:
        return super.handleResponseStatus(response, parsedBody, true);
    }

    return { response, body, status };
  }
}

/**
 * Updates the profile customer for the current user.
 * @param {unknown} body - The updated info about the profile customer to edit.
 * @param {Object} header
 * @param {string} header.Trov-Tenant - The tenant to use for the requests.
 * @param {string} header.Trov-Market - The market to use for the requests.
 * @param {string} header.Trov-Client - The identifier of the client making
 *   the request.
 * @param {string} header.Accept-Language - The language to use for
 *   localization of responses (where applicable).
 * @param {string} header.Authorization - The bearer access token to authorize
 *   the request (e.g. `bearer TOKEN`)
 */
export type putApiProfileCustomerBody = TrovCommonModelProfileCustomerProfile;

export type putApiProfileCustomerHeader = {|
  'Trov-Tenant': string,
  'Trov-Market': string,
  'Trov-Client': string,
  'Accept-Language': string,
  Authorization: string
|};

export type PutApiProfileCustomerResponseBody =
  | TrovCommonModelProfileProfile
  | CustomerAddressNotSupportedException
  | CustomerAgeNotSupportedException
  | CustomerProfileInformationMissingException
  | StateOfResidenceNotSupportedException
  | UnexpectedErrorException;

export type PutApiProfileCustomerInit = {
  header: putApiProfileCustomerHeader,
} & RequestOptions;

export type PutApiProfileCustomerOptions = {
  body: putApiProfileCustomerBody,
} & SwaggerFetchPathOptions;

export class PutApiProfileCustomer extends SwaggerFetch {
  constructor(init: PutApiProfileCustomerInit, options: PutApiProfileCustomerOptions) {
    const finalInit = {
      ...init,
      method: 'PUT',
      body: typeof options.body === 'string' ? options.body : JSON.stringify(options.body),
    };
    super(finalInit, options);

    this.endpoint = '/api/v4.0/profile/customer';
  }

  handleResponseStatus(response: Response, parsedBody: PutApiProfileCustomerResponseBody): ({
    response: Response,
    body: ?PutApiProfileCustomerResponseBody,
    status: RequestStatus,
  }) {
    const body = (parsedBody && typeof parsedBody === 'object') ? parsedBody : null;
    let status = 'MISTAKE';

    switch (response.status) {
      // 2XX STATUSES
      case 200:
        status = 'SUCCESS';
        // OK
        if (process.env.DEV_TOOLS) {
          const TrovCommonModelProfileProfileValidation = Validators.TrovCommonModelProfileProfile.validate(parsedBody);
          if (TrovCommonModelProfileProfileValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(TrovCommonModelProfileProfileValidation), null, 2));
          }
        }
        break;

      // 4XX STATUSES
      case 400:
        status = 'FAILURE';

        if (process.env.DEV_TOOLS && parsedBody && typeof parsedBody === 'object' && parsedBody.ExceptionType) {
          switch (parsedBody.ExceptionType) {
            case 'CustomerAddressNotSupportedException':
              // The customer address is valid, but the address is not
              // supported.
              if (process.env.DEV_TOOLS) {
                Validators.CustomerAddressNotSupportedException.assert(parsedBody);
              }
              break;

            case 'CustomerAgeNotSupportedException':
              // The customer has an age that is not supported.
              if (process.env.DEV_TOOLS) {
                Validators.CustomerAgeNotSupportedException.assert(parsedBody);
              }
              break;

            case 'CustomerProfileInformationMissingException':
              // The customer profile is missing information.
              if (process.env.DEV_TOOLS) {
                Validators.CustomerProfileInformationMissingException.assert(parsedBody);
              }
              break;

            default:
              console.warn(`${this.constructor.name} has no case for a "${response.status}" status and a differentiating key "ExceptionType" of ${JSON.stringify(parsedBody.ExceptionType)}.`);
              break;
          }
        }

        break;

      // 5XX STATUSES
      case 500:
        status = 'FAILURE';

        if (process.env.DEV_TOOLS && parsedBody && typeof parsedBody === 'object' && parsedBody.ExceptionType) {
          switch (parsedBody.ExceptionType) {
            case 'StateOfResidenceNotSupportedException':
              // Customer does not reside in an active US state.
              if (process.env.DEV_TOOLS) {
                Validators.StateOfResidenceNotSupportedException.assert(parsedBody);
              }
              break;

            case 'UnexpectedErrorException':
              // An unexpected error has occurred.
              if (process.env.DEV_TOOLS) {
                Validators.UnexpectedErrorException.assert(parsedBody);
              }
              break;

            default:
              console.warn(`${this.constructor.name} has no case for a "${response.status}" status and a differentiating key "ExceptionType" of ${JSON.stringify(parsedBody.ExceptionType)}.`);
              break;
          }
        }

        break;


      default:
        return super.handleResponseStatus(response, parsedBody, true);
    }

    return { response, body, status };
  }
}

/**
 * Updates the current user's profile photo. The endpoint requires a
 *   MimeMultipart request body, with a single part:- Must contain a single byte
 *   array (binary blob) of the images data.- The 'Content-Type' header set to
 *   the corresponding type of the blob (e.g. a jpg photo may have it set as
 *   'image/jpeg');
 * @param {Object} header
 * @param {string} header.Trov-Tenant - The tenant to use for the requests.
 * @param {string} header.Trov-Market - The market to use for the requests.
 * @param {string} header.Trov-Client - The identifier of the client making
 *   the request.
 * @param {string} header.Accept-Language - The language to use for
 *   localization of responses (where applicable).
 * @param {string} header.Authorization - The bearer access token to authorize
 *   the request (e.g. `bearer TOKEN`)
 */
export type postApiProfilePhotosProfileHeader = {|
  'Trov-Tenant': string,
  'Trov-Market': string,
  'Trov-Client': string,
  'Accept-Language': string,
  Authorization: string
|};

export type PostApiProfilePhotosProfileResponseBody =
  | TrovCommonModelProfileProfile
  | ArgumentException
  | UnsupportedImageException
  | DocumentAccessException
  | UnexpectedErrorException;

export type PostApiProfilePhotosProfileInit = {
  header: postApiProfilePhotosProfileHeader,
} & RequestOptions;

export type PostApiProfilePhotosProfileOptions = SwaggerFetchPathOptions;

export class PostApiProfilePhotosProfile extends SwaggerFetch {
  constructor(init: PostApiProfilePhotosProfileInit, options: PostApiProfilePhotosProfileOptions) {
    const finalInit = {
      ...init,
      method: 'POST',
    };
    super(finalInit, options);

    this.endpoint = '/api/v4.0/profile/photos/profile';
  }

  handleResponseStatus(response: Response, parsedBody: PostApiProfilePhotosProfileResponseBody): ({
    response: Response,
    body: ?PostApiProfilePhotosProfileResponseBody,
    status: RequestStatus,
  }) {
    const body = (parsedBody && typeof parsedBody === 'object') ? parsedBody : null;
    let status = 'MISTAKE';

    switch (response.status) {
      // 2XX STATUSES
      case 200:
        status = 'SUCCESS';
        // OK
        if (process.env.DEV_TOOLS) {
          const TrovCommonModelProfileProfileValidation = Validators.TrovCommonModelProfileProfile.validate(parsedBody);
          if (TrovCommonModelProfileProfileValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(TrovCommonModelProfileProfileValidation), null, 2));
          }
        }
        break;

      // 4XX STATUSES
      case 400:
        status = 'FAILURE';

        if (process.env.DEV_TOOLS && parsedBody && typeof parsedBody === 'object' && parsedBody.ExceptionType) {
          switch (parsedBody.ExceptionType) {
            case 'ArgumentException':
              // The user id is an invalid format.
              if (process.env.DEV_TOOLS) {
                Validators.ArgumentException.assert(parsedBody);
              }
              break;

            case 'UnsupportedImageException':
              // The file was not a supported image.
              if (process.env.DEV_TOOLS) {
                Validators.UnsupportedImageException.assert(parsedBody);
              }
              break;

            default:
              console.warn(`${this.constructor.name} has no case for a "${response.status}" status and a differentiating key "ExceptionType" of ${JSON.stringify(parsedBody.ExceptionType)}.`);
              break;
          }
        }

        break;

      case 404:
        status = 'FAILURE';
        // The user does not have access to update the profile photo. The
        // customer does not exist.
        if (process.env.DEV_TOOLS) {
          const DocumentAccessExceptionValidation = Validators.DocumentAccessException.validate(parsedBody);
          if (DocumentAccessExceptionValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(DocumentAccessExceptionValidation), null, 2));
          }
        }
        break;

      // 5XX STATUSES
      case 500:
        status = 'FAILURE';
        // An unexpected error has occurred.
        if (process.env.DEV_TOOLS) {
          const UnexpectedErrorExceptionValidation = Validators.UnexpectedErrorException.validate(parsedBody);
          if (UnexpectedErrorExceptionValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(UnexpectedErrorExceptionValidation), null, 2));
          }
        }
        break;


      default:
        return super.handleResponseStatus(response, parsedBody, true);
    }

    return { response, body, status };
  }
}

/**
 * Updates the current user's background photo. The endpoint requires a
 *   MimeMultipart request body, with a single part:- Must contain a single byte
 *   array (binary blob) of the images data.- The 'Content-Type' header set to
 *   the corresponding type of the blob (e.g. a jpg photo may have it set as
 *   'image/jpeg');
 * @param {Object} header
 * @param {string} header.Trov-Tenant - The tenant to use for the requests.
 * @param {string} header.Trov-Market - The market to use for the requests.
 * @param {string} header.Trov-Client - The identifier of the client making
 *   the request.
 * @param {string} header.Accept-Language - The language to use for
 *   localization of responses (where applicable).
 * @param {string} header.Authorization - The bearer access token to authorize
 *   the request (e.g. `bearer TOKEN`)
 */
export type postApiProfilePhotosBackgroundHeader = {|
  'Trov-Tenant': string,
  'Trov-Market': string,
  'Trov-Client': string,
  'Accept-Language': string,
  Authorization: string
|};

export type PostApiProfilePhotosBackgroundResponseBody =
  | TrovCommonModelProfileProfile
  | ArgumentException
  | UnsupportedImageException
  | DocumentAccessException
  | UnexpectedErrorException;

export type PostApiProfilePhotosBackgroundInit = {
  header: postApiProfilePhotosBackgroundHeader,
} & RequestOptions;

export type PostApiProfilePhotosBackgroundOptions = SwaggerFetchPathOptions;

export class PostApiProfilePhotosBackground extends SwaggerFetch {
  constructor(init: PostApiProfilePhotosBackgroundInit, options: PostApiProfilePhotosBackgroundOptions) {
    const finalInit = {
      ...init,
      method: 'POST',
    };
    super(finalInit, options);

    this.endpoint = '/api/v4.0/profile/photos/background';
  }

  handleResponseStatus(response: Response, parsedBody: PostApiProfilePhotosBackgroundResponseBody): ({
    response: Response,
    body: ?PostApiProfilePhotosBackgroundResponseBody,
    status: RequestStatus,
  }) {
    const body = (parsedBody && typeof parsedBody === 'object') ? parsedBody : null;
    let status = 'MISTAKE';

    switch (response.status) {
      // 2XX STATUSES
      case 200:
        status = 'SUCCESS';
        // OK
        if (process.env.DEV_TOOLS) {
          const TrovCommonModelProfileProfileValidation = Validators.TrovCommonModelProfileProfile.validate(parsedBody);
          if (TrovCommonModelProfileProfileValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(TrovCommonModelProfileProfileValidation), null, 2));
          }
        }
        break;

      // 4XX STATUSES
      case 400:
        status = 'FAILURE';

        if (process.env.DEV_TOOLS && parsedBody && typeof parsedBody === 'object' && parsedBody.ExceptionType) {
          switch (parsedBody.ExceptionType) {
            case 'ArgumentException':
              // The user id is an invalid format.
              if (process.env.DEV_TOOLS) {
                Validators.ArgumentException.assert(parsedBody);
              }
              break;

            case 'UnsupportedImageException':
              // The file was not a supported image.
              if (process.env.DEV_TOOLS) {
                Validators.UnsupportedImageException.assert(parsedBody);
              }
              break;

            default:
              console.warn(`${this.constructor.name} has no case for a "${response.status}" status and a differentiating key "ExceptionType" of ${JSON.stringify(parsedBody.ExceptionType)}.`);
              break;
          }
        }

        break;

      case 404:
        status = 'FAILURE';
        // The user does not have access to update the background photo. The
        // customer does not exist.
        if (process.env.DEV_TOOLS) {
          const DocumentAccessExceptionValidation = Validators.DocumentAccessException.validate(parsedBody);
          if (DocumentAccessExceptionValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(DocumentAccessExceptionValidation), null, 2));
          }
        }
        break;

      // 5XX STATUSES
      case 500:
        status = 'FAILURE';
        // An unexpected error has occurred.
        if (process.env.DEV_TOOLS) {
          const UnexpectedErrorExceptionValidation = Validators.UnexpectedErrorException.validate(parsedBody);
          if (UnexpectedErrorExceptionValidation.hasErrors()) {
            console.error(JSON.stringify(t.makeJSONError(UnexpectedErrorExceptionValidation), null, 2));
          }
        }
        break;


      default:
        return super.handleResponseStatus(response, parsedBody, true);
    }

    return { response, body, status };
  }
}