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

Xompass Client for cloud-api

import {ModelDefinition} from './BaseModels';
import {Log} from './Log';
import {Customer} from './Customer';
import {Asset} from './Asset';
import {AssetTemplate} from './AssetTemplate';
import {CountReport} from './CountReport';
import {HealthcheckEvent} from './HealthcheckEvent';
import {Credential} from './Credential';
import {CctvDashboard} from './CctvDashboard';
import {EventDashboard} from './EventDashboard';
import {EventSummaryForProject} from './EventSummaryForProject';
import {ProcessLayout} from './ProcessLayout';
import {Gis} from './Gis';
import {EmbeddedReport} from './EmbeddedReport';
import {BIPanel} from './BIPanel';
import {PeopleCounterReport} from './PeopleCounterReport';
import {AssetOperabilitySummary} from './AssetOperabilitySummary';
import {ProjectOperabilitySummary} from './ProjectOperabilitySummary';
import {ProjectRestrictionTable} from './ProjectRestrictionTable';
import {ProjectTag} from './ProjectTag';
import {RateLimit} from './RateLimit';
import {Report} from './Report';
import {ResponseProtocol} from './ResponseProtocol';
import {SensorType} from './SensorType';
import {SensorUptime} from './SensorUptime';
import {SensorUptimeCollector} from './SensorUptimeCollector';
import {StoreVideoAnalyticDashboard} from './StoreVideoAnalyticDashboard';
import {Storyline} from './Storyline';
import {Tool} from './Tool';
import {Toolkit} from './Toolkit';
import {TrafficFlowAnalysis} from './TrafficFlowAnalysis';
import {VirtualExpression} from './VirtualExpression';
import {VirtualGroup} from './VirtualGroup';
import {VirtualVariable} from './VirtualVariable';
import {YoloClass} from './YoloClass';
declare var Object: any;

export interface ProjectInterface {
  name?: string;
  description?: string;
  logo?: string;
  sector?: string;
  keywords?: Array<any>;
  created?: Date;
  modified?: Date;
  deleted?: Date;
  id?: any;
  customerId?: any;
  tagIds?: Array<any>;
  _rateLimit?: any;
  adminToolIds?: Array<any>;
  toolIds?: Array<any>;
  toolkitId?: any;
  trackingLogs?: Log[];
  customer?: Customer;
  assets?: Asset[];
  assetTemplates?: AssetTemplate[];
  countReports?: CountReport[];
  healthcheckEvents?: HealthcheckEvent[];
  credentials?: Credential[];
  cctvDashboards?: CctvDashboard[];
  eventDashboards?: EventDashboard[];
  eventSummaryForProjects?: EventSummaryForProject[];
  processLayouts?: ProcessLayout[];
  gis?: Gis[];
  embeddedReports?: EmbeddedReport[];
  biPanels?: BIPanel[];
  peopleCounterReports?: PeopleCounterReport[];
  assetOperabilitySummaries?: AssetOperabilitySummary[];
  operabilitySummaries?: ProjectOperabilitySummary[];
  restrictionTable?: ProjectRestrictionTable;
  tags?: ProjectTag[];
  rateLimit?: RateLimit[];
  reports?: Report[];
  responseProtocols?: ResponseProtocol[];
  allowedSensorTypes?: SensorType[];
  sensorUptime?: SensorUptime[];
  sensorUptimeCollectors?: SensorUptimeCollector[];
  storeVideoAnalyticDashboards?: StoreVideoAnalyticDashboard[];
  storylines?: Storyline[];
  adminTools?: Tool[];
  tools?: Tool[];
  toolkit?: Toolkit;
  trafficFlowAnalysis?: TrafficFlowAnalysis[];
  virtualExpressions?: VirtualExpression[];
  virtualGroups?: VirtualGroup[];
  virtualVariables?: VirtualVariable[];
  yoloClasses?: YoloClass[];
}

export class Project implements ProjectInterface {
  name: string;
  description: string;
  logo: string;
  sector: string;
  keywords: Array<any>;
  created: Date;
  modified: Date;
  deleted: Date;
  id: any;
  customerId: any;
  tagIds: Array<any> = [];
  _rateLimit: any;
  adminToolIds: Array<any> = [];
  toolIds: Array<any> = [];
  toolkitId: any;
  trackingLogs?: Log[];
  customer?: Customer;
  assets?: Asset[];
  assetTemplates?: AssetTemplate[];
  countReports?: CountReport[];
  healthcheckEvents?: HealthcheckEvent[];
  credentials?: Credential[];
  cctvDashboards?: CctvDashboard[];
  eventDashboards?: EventDashboard[];
  eventSummaryForProjects?: EventSummaryForProject[];
  processLayouts?: ProcessLayout[];
  gis?: Gis[];
  embeddedReports?: EmbeddedReport[];
  biPanels?: BIPanel[];
  peopleCounterReports?: PeopleCounterReport[];
  assetOperabilitySummaries?: AssetOperabilitySummary[];
  operabilitySummaries?: ProjectOperabilitySummary[];
  restrictionTable?: ProjectRestrictionTable;
  tags?: ProjectTag[];
  rateLimit?: RateLimit[];
  reports?: Report[];
  responseProtocols?: ResponseProtocol[];
  allowedSensorTypes?: SensorType[];
  sensorUptime?: SensorUptime[];
  sensorUptimeCollectors?: SensorUptimeCollector[];
  storeVideoAnalyticDashboards?: StoreVideoAnalyticDashboard[];
  storylines?: Storyline[];
  adminTools?: Tool[];
  tools?: Tool[];
  toolkit?: Toolkit;
  trafficFlowAnalysis?: TrafficFlowAnalysis[];
  virtualExpressions?: VirtualExpression[];
  virtualGroups?: VirtualGroup[];
  virtualVariables?: VirtualVariable[];
  yoloClasses?: YoloClass[];
  constructor(data?: ProjectInterface) {
    Object.assign(this, data);
  }

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

  /**
   * @method factory
   * @author Jonathan Casarrubias
   * @license MIT
   * This method creates an instance of Project for dynamic purposes.
   */
  public static factory(data: ProjectInterface): Project{
    return new Project(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: 'Project',
      plural: 'Projects',
      path: 'Projects',
      idName: 'id',
      properties: {
        name: {
          name: 'name',
          type: 'string'
        },
        description: {
          name: 'description',
          type: 'string'
        },
        logo: {
          name: 'logo',
          type: 'string'
        },
        sector: {
          name: 'sector',
          type: 'string'
        },
        keywords: {
          name: 'keywords',
          type: 'Array&lt;any&gt;'
        },
        created: {
          name: 'created',
          type: 'Date'
        },
        modified: {
          name: 'modified',
          type: 'Date'
        },
        deleted: {
          name: 'deleted',
          type: 'Date',
          default: undefined
        },
        id: {
          name: 'id',
          type: 'any'
        },
        customerId: {
          name: 'customerId',
          type: 'any'
        },
        tagIds: {
          name: 'tagIds',
          type: 'Array&lt;any&gt;',
          default: []
        },
        _rateLimit: {
          name: '_rateLimit',
          type: 'any'
        },
        adminToolIds: {
          name: 'adminToolIds',
          type: 'Array&lt;any&gt;',
          default: []
        },
        toolIds: {
          name: 'toolIds',
          type: 'Array&lt;any&gt;',
          default: []
        },
        toolkitId: {
          name: 'toolkitId',
          type: 'any'
        },
      },
      relations: {
        trackingLogs: {
          name: 'trackingLogs',
          type: 'Log[]',
          model: 'Log',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'trackingModelId'
        },
        customer: {
          name: 'customer',
          type: 'Customer',
          model: 'Customer',
          relationType: 'belongsTo',
          keyFrom: 'customerId',
          keyTo: 'id'
        },
        assets: {
          name: 'assets',
          type: 'Asset[]',
          model: 'Asset',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        assetTemplates: {
          name: 'assetTemplates',
          type: 'AssetTemplate[]',
          model: 'AssetTemplate',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        countReports: {
          name: 'countReports',
          type: 'CountReport[]',
          model: 'CountReport',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        healthcheckEvents: {
          name: 'healthcheckEvents',
          type: 'HealthcheckEvent[]',
          model: 'HealthcheckEvent',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        credentials: {
          name: 'credentials',
          type: 'Credential[]',
          model: 'Credential',
          relationType: 'hasMany',
          modelThrough: 'CredentialProject',
          keyThrough: 'credentialId',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        cctvDashboards: {
          name: 'cctvDashboards',
          type: 'CctvDashboard[]',
          model: 'CctvDashboard',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        eventDashboards: {
          name: 'eventDashboards',
          type: 'EventDashboard[]',
          model: 'EventDashboard',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        eventSummaryForProjects: {
          name: 'eventSummaryForProjects',
          type: 'EventSummaryForProject[]',
          model: 'EventSummaryForProject',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        processLayouts: {
          name: 'processLayouts',
          type: 'ProcessLayout[]',
          model: 'ProcessLayout',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        gis: {
          name: 'gis',
          type: 'Gis[]',
          model: 'Gis',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        embeddedReports: {
          name: 'embeddedReports',
          type: 'EmbeddedReport[]',
          model: 'EmbeddedReport',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        biPanels: {
          name: 'biPanels',
          type: 'BIPanel[]',
          model: 'BIPanel',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        peopleCounterReports: {
          name: 'peopleCounterReports',
          type: 'PeopleCounterReport[]',
          model: 'PeopleCounterReport',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        assetOperabilitySummaries: {
          name: 'assetOperabilitySummaries',
          type: 'AssetOperabilitySummary[]',
          model: 'AssetOperabilitySummary',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        operabilitySummaries: {
          name: 'operabilitySummaries',
          type: 'ProjectOperabilitySummary[]',
          model: 'ProjectOperabilitySummary',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        restrictionTable: {
          name: 'restrictionTable',
          type: 'ProjectRestrictionTable',
          model: 'ProjectRestrictionTable',
          relationType: 'hasOne',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        tags: {
          name: 'tags',
          type: 'ProjectTag[]',
          model: 'ProjectTag',
          relationType: 'referencesMany',
          keyFrom: 'tagIds',
          keyTo: 'id'
        },
        rateLimit: {
          name: 'rateLimit',
          type: 'RateLimit[]',
          model: 'RateLimit',
          relationType: 'embedsOne',
          keyFrom: '_rateLimit',
          keyTo: 'id'
        },
        reports: {
          name: 'reports',
          type: 'Report[]',
          model: 'Report',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        responseProtocols: {
          name: 'responseProtocols',
          type: 'ResponseProtocol[]',
          model: 'ResponseProtocol',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        allowedSensorTypes: {
          name: 'allowedSensorTypes',
          type: 'SensorType[]',
          model: 'SensorType',
          relationType: 'hasMany',
          modelThrough: 'ProjectAllowedSensorType',
          keyThrough: 'sensorTypeId',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        sensorUptime: {
          name: 'sensorUptime',
          type: 'SensorUptime[]',
          model: 'SensorUptime',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        sensorUptimeCollectors: {
          name: 'sensorUptimeCollectors',
          type: 'SensorUptimeCollector[]',
          model: 'SensorUptimeCollector',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        storeVideoAnalyticDashboards: {
          name: 'storeVideoAnalyticDashboards',
          type: 'StoreVideoAnalyticDashboard[]',
          model: 'StoreVideoAnalyticDashboard',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        storylines: {
          name: 'storylines',
          type: 'Storyline[]',
          model: 'Storyline',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        adminTools: {
          name: 'adminTools',
          type: 'Tool[]',
          model: 'Tool',
          relationType: 'referencesMany',
          keyFrom: 'adminToolIds',
          keyTo: 'id'
        },
        tools: {
          name: 'tools',
          type: 'Tool[]',
          model: 'Tool',
          relationType: 'referencesMany',
          keyFrom: 'toolIds',
          keyTo: 'id'
        },
        toolkit: {
          name: 'toolkit',
          type: 'Toolkit',
          model: 'Toolkit',
          relationType: 'belongsTo',
          keyFrom: 'toolkitId',
          keyTo: 'id'
        },
        trafficFlowAnalysis: {
          name: 'trafficFlowAnalysis',
          type: 'TrafficFlowAnalysis[]',
          model: 'TrafficFlowAnalysis',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        virtualExpressions: {
          name: 'virtualExpressions',
          type: 'VirtualExpression[]',
          model: 'VirtualExpression',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        virtualGroups: {
          name: 'virtualGroups',
          type: 'VirtualGroup[]',
          model: 'VirtualGroup',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        virtualVariables: {
          name: 'virtualVariables',
          type: 'VirtualVariable[]',
          model: 'VirtualVariable',
          relationType: 'hasMany',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
        yoloClasses: {
          name: 'yoloClasses',
          type: 'YoloClass[]',
          model: 'YoloClass',
          relationType: 'hasMany',
          modelThrough: 'YoloClassProject',
          keyThrough: 'yoloClassId',
          keyFrom: 'id',
          keyTo: 'projectId'
        },
      }
    };
  }
}