catalog-ui/src/app/services/data-types-service.ts

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 'use strict';
  22 import {DataTypePropertyModel} from "../models/data-type-properties";
  23 import {
  24     ComponentInstance,
  25     DataTypeModel,
  26     DataTypesMap,
  27     IAppConfigurtaion, InputModel,
  28     InputPropertyBase,
  29     PropertyModel,
  30     SchemaProperty
  31 } from "../models";
  32 import {PROPERTY_DATA} from "../utils/constants";
  33 import {List} from "lodash";
  34 import {Observable} from "rxjs/Observable";
  35
  36 export interface IDataTypesService {
  37
  38     dataTypes:DataTypesMap; //Data type map
  39     selectedPropertiesName:string;
  40     selectedInput:PropertyModel;
  41     alreadySelectedProperties:Array<InputPropertyBase>;
  42     selectedInstance:ComponentInstance;
  43     selectedComponentInputs:Array<InputModel>;
  44     //declare methods
  45     loadDataTypesCache(modelName:string):void;
  46     findAllDataTypesByModel(modelName: string): void;
  47     getAllDataTypes():DataTypesMap;
  48     getFirsLevelOfDataTypeProperties(dataTypeName:string):Array<DataTypePropertyModel>;
  49     isDataTypeForSchemaType(property:SchemaProperty):boolean;
  50     isDataTypeForPropertyType(property:PropertyModel):boolean;
  51     isDataTypeForDataTypePropertyType(property:DataTypePropertyModel):boolean;
  52 }
  53
  54 export class DataTypesService implements IDataTypesService {
  55
  56     static '$inject' = [
  57         'sdcConfig',
  58         '$q',
  59         '$http'
  60     ];
  61
  62     constructor(private sdcConfig:IAppConfigurtaion,
  63                 private $q:ng.IQService,
  64                 private $http:ng.IHttpService) {
  65     }
  66
  67     private baseUrl = this.sdcConfig.api.root + this.sdcConfig.api.component_api_root;
  68
  69     dataTypes:DataTypesMap; //Data type map
  70     selectedPropertiesName:string;
  71     selectedInput:PropertyModel;
  72     alreadySelectedProperties:Array<InputPropertyBase>;
  73     selectedInstance:ComponentInstance;
  74     selectedComponentInputs:Array<InputModel>;
  75
  76     public loadDataTypesCache = async (modelName: string): Promise<void> => {
  77         let model;
  78         if (modelName) {
  79             model = {'model': modelName}
  80         }
  81         await this.$http.get(this.baseUrl + "dataTypes", {params: model})
  82         .then((response: any) => {
  83             this.dataTypes = response.data;
  84             delete this.dataTypes['tosca.datatypes.Root'];
  85         });
  86     };
  87
  88     public fetchDataTypesByModel = (modelName: string): angular.IHttpPromise<any> => {
  89         let model;
  90         if (modelName) {
  91             model = {'model': modelName}
  92         }
  93         return this.$http.get(this.baseUrl + "dataTypes", {params: model});
  94     };
  95
  96     public getAllDataTypesFromModel = (modelName: string): DataTypesMap => {
  97         this.loadDataTypesCache(modelName);
  98         return this.dataTypes;
  99     }
 100
 101     public getDataTypesFromAllModel = (): Observable<Array<DataTypeModel>> => {
 102         return new Observable<Array<DataTypeModel>>(subscriber => {
 103             this.$http.get<List<DataTypesMap>>(this.baseUrl + "allDataTypes")
 104             .then(promiseValue => {
 105                 const allDataTypes = this.getDataTypesItems(promiseValue.data);
 106                 subscriber.next(allDataTypes);
 107             });
 108         });
 109     }
 110
 111     private getDataTypesItems(dataTypesListOfMap: List<DataTypesMap>):Array<DataTypeModel> {
 112         const dataTypes = new Array<DataTypeModel>();
 113         angular.forEach(dataTypesListOfMap, (dataTypesMap: DataTypesMap): void => {
 114             for (const dataTypeKey of Object.keys(dataTypesMap)) {
 115                 dataTypes.push(new DataTypeModel(dataTypesMap[dataTypeKey]))
 116             }
 117         });
 118         return dataTypes;
 119     }
 120
 121     public findAllDataTypesByModel = (modelName: string): Promise<Map<string, DataTypeModel>> => {
 122         return new Promise<Map<string, DataTypeModel>>((resolve, reject) => {
 123             this.fetchDataTypesByModel(modelName).then(response => {
 124                 const dataTypes = response.data;
 125                 delete dataTypes[PROPERTY_DATA.ROOT_DATA_TYPE];
 126                 const dataTypeMap = new Map<string, DataTypeModel>();
 127                 for(const dataTypeKey of Object.keys(dataTypes)) {
 128                     dataTypeMap.set(dataTypeKey, new DataTypeModel(dataTypes[dataTypeKey]))
 129                 }
 130                 resolve(dataTypeMap);
 131             }).catch(reason => {
 132                 reject(reason);
 133             });
 134         });
 135     }
 136
 137     public getAllDataTypes = ():DataTypesMap => {
 138         return this.dataTypes;
 139     };
 140
 141     //if the dt derived from simple- return the first parent type, else- return null
 142     private getTypeForDataTypeDerivedFromSimple = (dataTypeName:string):string => {
 143         /////////temporary hack for tosca primitives///////////////////////
 144         if (!this.dataTypes[dataTypeName]) {
 145             return 'string';
 146         }
 147         ///////////////////////////////////////////////////////////////////
 148         if (this.dataTypes[dataTypeName].derivedFromName == "tosca.datatypes.Root" || this.dataTypes[dataTypeName].properties) {
 149             return null;
 150         }
 151         if (PROPERTY_DATA.SIMPLE_TYPES.indexOf(this.dataTypes[dataTypeName].derivedFromName) > -1) {
 152             return this.dataTypes[dataTypeName].derivedFromName
 153         }
 154         return this.getTypeForDataTypeDerivedFromSimple(this.dataTypes[dataTypeName].derivedFromName);
 155     };
 156
 157
 158     //return list of data type properties and all its parents properties
 159     //(not include the properties of its properties, in case this data type has not primitive properties)
 160     public getFirsLevelOfDataTypeProperties = (dataTypeName:string):Array<DataTypePropertyModel> => {
 161         let properties = this.dataTypes[dataTypeName].properties || [];
 162         if (this.dataTypes[dataTypeName].derivedFromName != "tosca.datatypes.Root") {
 163             properties = this.getFirsLevelOfDataTypeProperties(this.dataTypes[dataTypeName].derivedFromName).concat(properties);
 164         }
 165         return properties;
 166     };
 167
 168     //return false when type= data type (=not simple type) that not derived from simple type
 169     public isDataTypeForSchemaType = (property:SchemaProperty):boolean=> {
 170         property.simpleType = "";
 171         if (property.type && PROPERTY_DATA.TYPES.indexOf(property.type) > -1) {
 172             return false;
 173         }
 174         let simpleType = this.getTypeForDataTypeDerivedFromSimple(property.type);
 175         if (simpleType) {
 176             property.simpleType = simpleType;
 177             return false;
 178         }
 179         return true;
 180     };
 181
 182     public isDataTypeForPropertyType = (property:PropertyModel):boolean=> {
 183         property.simpleType = "";
 184         if (property.type && PROPERTY_DATA.TYPES.indexOf(property.type) > -1) {
 185             return false;
 186         }
 187         let simpleType = this.getTypeForDataTypeDerivedFromSimple(property.type);
 188         if (simpleType) {
 189             property.simpleType = simpleType;
 190             return false;
 191         }
 192         return true;
 193     };
 194
 195
 196     public isDataTypeForDataTypePropertyType = (property:DataTypePropertyModel):boolean=> {
 197         property.simpleType = "";
 198         let isScalarForNFoD:boolean = property.type === 'scalar-unit.size';
 199         if (property.type && PROPERTY_DATA.TYPES.indexOf(property.type) > -1 || isScalarForNFoD) {
 200             return false;
 201         }
 202         let simpleType = this.getTypeForDataTypeDerivedFromSimple(property.type);
 203         if (simpleType) {
 204             property.simpleType = simpleType;
 205             return false;
 206         }
 207         return true;
 208     };
 209 }