@xompass/sdk-cloud-api/models/Customer.ts

Xompass Client for cloud-api

import {ModelDefinition} from './BaseModels';
import {AssetTag} from './AssetTag';
import {Asset} from './Asset';
import {AssetTemplate} from './AssetTemplate';
import {CountReport} from './CountReport';
import {Credential} from './Credential';
import {ApiKey} from './ApiKey';
import {Country} from './Country';
import {AssetStateChange} from './AssetStateChange';
import {CustomerOperabilitySummary} from './CustomerOperabilitySummary';
import {CustomerRestrictionTable} from './CustomerRestrictionTable';
import {DefaultEventComment} from './DefaultEventComment';
import {Device} from './Device';
import {DeviceEventType} from './DeviceEventType';
import {EdgeAgent} from './EdgeAgent';
import {EmergencyContact} from './EmergencyContact';
import {EventState} from './EventState';
import {Log} from './Log';
import {Manager} from './Manager';
import {Project} from './Project';
import {SensorUptime} from './SensorUptime';
import {SensorUptimeCollector} from './SensorUptimeCollector';
import {Storyline} from './Storyline';
import {StorylineCategory} from './StorylineCategory';
import {TelegramChat} from './TelegramChat';
import {TimeZone} from './TimeZone';
import {Toolkit} from './Toolkit';
import {Var} from './Var';
import {YoloClass} from './YoloClass';
declare var Object: any;

export interface CustomerInterface {
  name: string;
  businessName?: string;
  description?: string;
  address?: string;
  created?: Date;
  modified?: Date;
  deleted?: Date;
  id?: any;
  countryId?: any;
  _config?: any;
  timeZoneId?: any;
  toolkitIds?: Array<any>;
  varId?: any;
  assetTags?: AssetTag[];
  assets?: Asset[];
  assetTemplates?: AssetTemplate[];
  countReports?: CountReport[];
  credentials?: Credential[];
  apiKeys?: ApiKey[];
  country?: Country;
  assetStateChanges?: AssetStateChange[];
  activeDirectory?: any;
  config?: any[];
  operabilitySummaries?: CustomerOperabilitySummary[];
  restrictionTable?: CustomerRestrictionTable;
  container?: any;
  defaultEventComments?: DefaultEventComment[];
  devices?: Device[];
  deviceEventTypes?: DeviceEventType[];
  edgeAgents?: EdgeAgent[];
  emergencyContacts?: EmergencyContact[];
  eventStates?: EventState[];
  trackingLogs?: Log[];
  managers?: Manager[];
  projects?: Project[];
  sensorUptime?: SensorUptime[];
  sensorUptimeCollector?: SensorUptimeCollector[];
  storylines?: Storyline[];
  storylineCategories?: StorylineCategory[];
  telegramChats?: TelegramChat[];
  timeZone?: TimeZone;
  toolkits?: Toolkit[];
  var?: Var;
  yoloClasses?: YoloClass[];
}

export class Customer implements CustomerInterface {
  name: string;
  businessName: string;
  description: string;
  address: string;
  created: Date;
  modified: Date;
  deleted: Date;
  id: any;
  countryId: any;
  _config: any;
  timeZoneId: any;
  toolkitIds: Array<any> = [];
  varId: any;
  assetTags?: AssetTag[];
  assets?: Asset[];
  assetTemplates?: AssetTemplate[];
  countReports?: CountReport[];
  credentials?: Credential[];
  apiKeys?: ApiKey[];
  country?: Country;
  assetStateChanges?: AssetStateChange[];
  activeDirectory?: any;
  config?: any[];
  operabilitySummaries?: CustomerOperabilitySummary[];
  restrictionTable?: CustomerRestrictionTable;
  container?: any;
  defaultEventComments?: DefaultEventComment[];
  devices?: Device[];
  deviceEventTypes?: DeviceEventType[];
  edgeAgents?: EdgeAgent[];
  emergencyContacts?: EmergencyContact[];
  eventStates?: EventState[];
  trackingLogs?: Log[];
  managers?: Manager[];
  projects?: Project[];
  sensorUptime?: SensorUptime[];
  sensorUptimeCollector?: SensorUptimeCollector[];
  storylines?: Storyline[];
  storylineCategories?: StorylineCategory[];
  telegramChats?: TelegramChat[];
  timeZone?: TimeZone;
  toolkits?: Toolkit[];
  var?: Var;
  yoloClasses?: YoloClass[];
  constructor(data?: CustomerInterface) {
    Object.assign(this, data);
  }

  /**
   * The name of the model represented by this $resource,
   * i.e. `Customer`.
   */
  public static getModelName(): string {
    return 'Customer';
  }

  /**
   * @method factory
   * @author Jonathan Casarrubias
   * @license MIT
   * This method creates an instance of Customer for dynamic purposes.
   */
  public static factory(data: CustomerInterface): Customer{
    return new Customer(data);
  }

  /**
   * @method getModelDefinition
   * @author Julien Ledun
   * @license MIT
   * This method returns an object that represents some of the model
   * definitions.
   */
  public static getModelDefinition(): ModelDefinition {
    return {
      name: 'Customer',
      plural: 'Customers',
      path: 'Customers',
      idName: 'id',
      properties: {
        name: {
          name: 'name',
          type: 'string'
        },
        businessName: {
          name: 'businessName',
          type: 'string'
        },
        description: {
          name: 'description',
          type: 'string'
        },
        address: {
          name: 'address',
          type: 'string'
        },
        created: {
          name: 'created',
          type: 'Date'
        },
        modified: {
          name: 'modified',
          type: 'Date'
        },
        deleted: {
          name: 'deleted',
          type: 'Date',
          default: undefined
        },
        id: {
          name: 'id',
          type: 'any'
        },
        countryId: {
          name: 'countryId',
          type: 'any'
        },
        _config: {
          name: '_config',
          type: 'any'
        },
        timeZoneId: {
          name: 'timeZoneId',
          type: 'any'
        },
        toolkitIds: {
          name: 'toolkitIds',
          type: 'Array&lt;any&gt;',
          default: []
        },
        varId: {
          name: 'varId',
          type: 'any'
        },
      },
      relations: {
        assetTags: {
          name: 'assetTags',
          type: 'AssetTag[]',
          model: 'AssetTag',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        assets: {
          name: 'assets',
          type: 'Asset[]',
          model: 'Asset',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        assetTemplates: {
          name: 'assetTemplates',
          type: 'AssetTemplate[]',
          model: 'AssetTemplate',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        countReports: {
          name: 'countReports',
          type: 'CountReport[]',
          model: 'CountReport',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        credentials: {
          name: 'credentials',
          type: 'Credential[]',
          model: 'Credential',
          relationType: 'hasMany',
          modelThrough: 'CredentialCustomer',
          keyThrough: 'credentialId',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        apiKeys: {
          name: 'apiKeys',
          type: 'ApiKey[]',
          model: 'ApiKey',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        country: {
          name: 'country',
          type: 'Country',
          model: 'Country',
          relationType: 'belongsTo',
          keyFrom: 'countryId',
          keyTo: 'id'
        },
        assetStateChanges: {
          name: 'assetStateChanges',
          type: 'AssetStateChange[]',
          model: 'AssetStateChange',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        activeDirectory: {
          name: 'activeDirectory',
          type: 'any',
          model: '',
          relationType: 'hasOne',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        config: {
          name: 'config',
          type: 'any[]',
          model: '',
          relationType: 'embedsOne',
          keyFrom: '_config',
          keyTo: 'id'
        },
        operabilitySummaries: {
          name: 'operabilitySummaries',
          type: 'CustomerOperabilitySummary[]',
          model: 'CustomerOperabilitySummary',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        restrictionTable: {
          name: 'restrictionTable',
          type: 'CustomerRestrictionTable',
          model: 'CustomerRestrictionTable',
          relationType: 'hasOne',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        container: {
          name: 'container',
          type: 'any',
          model: '',
          relationType: 'hasOne',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        defaultEventComments: {
          name: 'defaultEventComments',
          type: 'DefaultEventComment[]',
          model: 'DefaultEventComment',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        devices: {
          name: 'devices',
          type: 'Device[]',
          model: 'Device',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        deviceEventTypes: {
          name: 'deviceEventTypes',
          type: 'DeviceEventType[]',
          model: 'DeviceEventType',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        edgeAgents: {
          name: 'edgeAgents',
          type: 'EdgeAgent[]',
          model: 'EdgeAgent',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        emergencyContacts: {
          name: 'emergencyContacts',
          type: 'EmergencyContact[]',
          model: 'EmergencyContact',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        eventStates: {
          name: 'eventStates',
          type: 'EventState[]',
          model: 'EventState',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        trackingLogs: {
          name: 'trackingLogs',
          type: 'Log[]',
          model: 'Log',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'trackingModelId'
        },
        managers: {
          name: 'managers',
          type: 'Manager[]',
          model: 'Manager',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        projects: {
          name: 'projects',
          type: 'Project[]',
          model: 'Project',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        sensorUptime: {
          name: 'sensorUptime',
          type: 'SensorUptime[]',
          model: 'SensorUptime',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        sensorUptimeCollector: {
          name: 'sensorUptimeCollector',
          type: 'SensorUptimeCollector[]',
          model: 'SensorUptimeCollector',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        storylines: {
          name: 'storylines',
          type: 'Storyline[]',
          model: 'Storyline',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        storylineCategories: {
          name: 'storylineCategories',
          type: 'StorylineCategory[]',
          model: 'StorylineCategory',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        telegramChats: {
          name: 'telegramChats',
          type: 'TelegramChat[]',
          model: 'TelegramChat',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
        timeZone: {
          name: 'timeZone',
          type: 'TimeZone',
          model: 'TimeZone',
          relationType: 'belongsTo',
          keyFrom: 'timeZoneId',
          keyTo: 'id'
        },
        toolkits: {
          name: 'toolkits',
          type: 'Toolkit[]',
          model: 'Toolkit',
          relationType: 'referencesMany',
          keyFrom: 'toolkitIds',
          keyTo: 'id'
        },
        var: {
          name: 'var',
          type: 'Var',
          model: 'Var',
          relationType: 'belongsTo',
          keyFrom: 'varId',
          keyTo: 'id'
        },
        yoloClasses: {
          name: 'yoloClasses',
          type: 'YoloClass[]',
          model: 'YoloClass',
          relationType: 'hasMany',
          modelThrough: 'YoloClassCustomer',
          keyThrough: 'yoloClassId',
          keyFrom: 'id',
          keyTo: 'customerId'
        },
      }
    };
  }
}