@futdevpro/nts-dynamo 1.2.90

package/src/_services/dynamobe-db.service.ts

@@ -0,0 +1,556 @@
+
+import * as mongoose from 'mongoose';
+import { Schema } from 'mongoose';
+import { DynamoBEError } from '../_models/fullstack-models/control-models/dynamobe-error';
+import { Metadata } from '../_models/fullstack-models/data-models/metadata';
+import { DynamoBEDataPropertyParams } from '../_models/fullstack-models/control-models/dynamobe-data-property-params';
+
+export class DynamoBEDBService<T extends Metadata> {
+  dataModel = mongoose.model(this.dataName, this.getSchema());
+
+  private depDataKey: string;
+
+  /**
+   * @param dataName name the model
+   * @param typeSample sample data for scheme creation (dont include Metadata!)
+   * @param schemaSettings additional settings for specific parameters as unique, required, minlength or maxlength
+   * schemaSettings also MUST contain specific types that differs from the listed above (Array, Date)
+   */
+  constructor(
+    private dataName: string,
+    private dataModelParams: DynamoBEDataPropertyParams[]
+  ){
+    this.lookForDependencyDataSettings();
+  }
+
+  /**
+   * save new data
+   * @param data data
+   * @returns data
+   */
+  async createData(data: T, creator: string): Promise<T> {
+    data.__created = new Date();
+    data.__lastModified = new Date();
+    data.__createdBy = creator;
+    data.__lastModifiedBy = creator;
+    const dataModel = new this.dataModel(data);
+    let newData: T;
+    await dataModel.save().then(res => {
+      if (res) {
+        newData = res.toObject() as T;
+      } else {
+        throw new DynamoBEError({ status: 204, message: `${this.dataName} not found! (BD)` });
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 422, message: `Create new ${this.dataName} was unsuccessful (BD)`, error });
+    });
+    if (typeof newData._id === 'object') {
+      newData._id = `${newData._id}`;
+    }
+    data._id = newData._id;
+    data.__v = newData.__v;
+    return data;
+  }
+
+  /**
+   * Find data by _id and update
+   * @param data data
+   * @returns data
+   */
+  async modifyData(data: T, modifier: string): Promise<T> {
+    data.__lastModified = new Date();
+    data.__lastModifiedBy = modifier;
+    const dataModel = new this.dataModel(data);
+    let newData: T;
+    await this.dataModel.findByIdAndUpdate(data._id, dataModel).then(res => {
+      if (res) {
+        newData = res.toObject() as T;
+      } else {
+        throw new DynamoBEError({ status: 204, message: `${this.dataName} not found! (BD)` });
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `modify ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    data.__v = newData.__v;
+    return data;
+  }
+
+  /**
+   * get data by _id, throws error if not found
+   * @param id id
+   * @returns data
+   */
+  async getDataById(id: string): Promise<T> {
+    let data: T;
+    await this.dataModel.findById(id).then(res => {
+      if (res) {
+        data = res.toObject() as T;
+      } else {
+        data = null;
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `get ${this.dataName} by ID was unsuccessful (DB)`, error });
+    });
+    if (data && typeof data._id === 'object') {
+      data._id = `${data._id}`;
+    }
+    return data;
+  }
+
+  /**
+   * get data by dependency data id, throws error if not found
+   * @param dependencyId id
+   * @returns data
+   */
+  async getDataByDependencyId(dependencyId: string): Promise<T> {
+    if (this.depDataKey) {
+      let data: T;
+      await this.dataModel.findOne({ [this.depDataKey]: dependencyId }).then(res => {
+        if (res) {
+          data = res.toObject() as T;
+        } else {
+          data = null;
+        }
+      }).catch(error => {
+        throw new DynamoBEError({ status: 417, message: `get ${this.dataName} by ${this.depDataKey} was unsuccessful (DB)`, error });
+      });
+      if (data && typeof data._id === 'object') {
+        data._id = `${data._id}`;
+      }
+      return data;
+    } else {
+      throw new DynamoBEError({ status: 501, message: `dependencyDataIdKey not setted up for this db-service (${this.dataName}) (BD)` });
+    }
+  }
+
+  /**
+   * get data by dependency data id, throws error if not found
+   * @param dependencyId id
+   * @returns dataList
+   */
+  async getDataListByDependencyId(dependencyId: string): Promise<T[]> {
+    if (this.depDataKey) {
+      let dataList = [];
+      await this.dataModel.find({ [this.depDataKey]: dependencyId }).then(res => {
+        if (res) {
+          dataList = res;
+        }
+      }).catch(error => {
+        throw new DynamoBEError({ status: 417, message: `get ${this.dataName} by ${this.depDataKey} was unsuccessful (DB)`, error });
+      });
+      if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+        dataList.forEach((data: T) => {
+          data._id = `˙${data._id}`;
+        });
+      }
+      return dataList;
+    } else {
+      throw new DynamoBEError({ status: 501, message: `dependencyDataIdKey not setted up for this db-service (${this.dataName}) (BD)` });
+    }
+  }
+
+  /**
+   * get multiple data objects by a list of DependencyIDs, throws error if not found
+   * @param ids ids
+   * @returns dataList
+   */
+  async getDataListByDependencyIds(ids: string[]): Promise<T[]> {
+    if (this.depDataKey) {
+      let dataList = [];
+      await this.dataModel.find({ [this.depDataKey]: { $in: ids }}).then(res => {
+        if (res) {
+          dataList = res;
+        }
+      }).catch(error => {
+        throw new DynamoBEError({ status: 417, message: `get ${this.dataName}s by ${this.depDataKey}s was unsuccessful (DB)`, error });
+      });
+      return dataList;
+    } else {
+      throw new DynamoBEError({ status: 501, message: `dependencyDataIdKey not setted up for this db-service (${this.dataName}) (BD)` });
+    }
+  }
+
+  /**
+   * returns search result for searchBy object params
+   * can use lists or xRange values for searchBy obj properties
+   * @param searchBy filter
+   * @param narrowByDependencyIds id
+   * @returns dataList
+   */
+  async searchData(searchBy: object, narrowByDependencyIds?: string[]): Promise<T[]> {
+    const filter = {};
+
+    if (narrowByDependencyIds.length > 0) {
+      if (this.depDataKey) {
+        filter[this.depDataKey] = { $in: narrowByDependencyIds };
+      } else {
+        throw new DynamoBEError({ status: 501, message: `dependencyDataIdKey not setted up for this db-service (${this.dataName}) (BD)` });
+      }
+    }
+    await this.dataModelParams.forEach((modelParam: DynamoBEDataPropertyParams) => {
+      if ((searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) || searchBy[modelParam.key + 'Range']) {
+        if (modelParam.key.includes('Range') || modelParam.type.includes('[]')) {
+          // inverz search filter (for Range and Array functions)
+          if (modelParam.key.includes('Range')) {
+            const searchParamKeyWithoutRange = modelParam.key.split('Range')[0];
+            if (searchBy[searchParamKeyWithoutRange] !== null && searchBy[searchParamKeyWithoutRange] !== undefined) {
+              filter[modelParam.key] = {
+                from: { $lte: searchBy[searchParamKeyWithoutRange] },
+                to: { $gte: searchBy[searchParamKeyWithoutRange] }
+              };
+            }
+          } else {
+            if (searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) {
+              filter[modelParam.key] = { $in: searchBy[modelParam.key] };
+            }
+          }
+        } else {
+          // basic search filter
+          if (searchBy[modelParam.key + 'Range']) {
+            if (searchBy[modelParam.key + 'Range'].from || searchBy[modelParam.key + 'Range'].to) {
+              filter[modelParam.key] = {};
+              if (searchBy[modelParam.key + 'Range'].from) {
+                filter[modelParam.key].$gte = searchBy[modelParam.key + 'Range'].from;
+              }
+              if (searchBy[modelParam.key + 'Range'].to) {
+                filter[modelParam.key].$lte = searchBy[modelParam.key + 'Range'].to;
+              }
+            }
+          } else if (searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) {
+            if (searchBy[modelParam.key].lenght > 0) {
+              filter[modelParam.key] = { $in: searchBy[modelParam.key] };
+            }
+          }
+        }
+      }
+    });
+
+    let dataList = [];
+    await this.dataModel.find(filter).then(res => {
+      if (res) {
+        dataList = res;
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `search ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+      dataList.forEach((data: T) => {
+        data._id = `˙${data._id}`;
+      });
+    }
+    return dataList as T[];
+  }
+
+  /**
+   * find data by any of its parameters, throws error if not found
+   * @param data etc.: by email: { email: email }
+   * { userIds: { $in: this.userId } }
+   * @returns data
+   */
+  async findData(data: T): Promise<T> {
+    await this.dataModel.findOne(data).then(res => {
+      if (res) {
+        data = res.toObject() as T;
+      } else {
+        data = null;
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `find ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    if (data && typeof data._id === 'object') {
+      data._id = `${data._id}`;
+    }
+    return data;
+  }
+
+  /**
+   * returns all data from database, throws error if not found
+   * @returns dataList
+   */
+  async getAll(): Promise<T[]> {
+    let dataList = [];
+    await this.dataModel.find({}).then(res => {
+      if (res) {
+        dataList = res;
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `get all ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+      dataList.forEach((data: T) => {
+        data._id = `˙${data._id}`;
+      });
+    }
+    return dataList as T[];
+  }
+
+  /**
+   * update one parameter by a specific
+   * { _id: pictureId }, { approved: true }
+   * @param updateBy etc.: { email: email } (always use unique parameters for find!)
+   * @param update etc.: { $inc: { popularity: this.newVote.amount }, emailVerified: true }
+   */
+  /* async updateOneParameter(updateBy: any, update: any, modifier: string): Promise<void> {
+    update.__lastModified = new Date();
+    update.__lastModifiedBy = modifier;
+    await this.dataModel.updateOne(updateBy, update).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `update one parameter on ${this.dataName} was unsuccessful (DB)`, error });
+    });
+  } */
+
+  /**
+   * deleted data by id
+   * @param id id
+   */
+  async deleteDataById(id: string): Promise<void> {
+    await this.dataModel.findByIdAndDelete(id).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `delete ${this.dataName} was unsuccessful (DB)`, error });
+    });
+  }
+
+  /**
+   * deleted data by id
+   * @param dependencyId id
+   */
+  async deleteDataByDependencyId(dependencyId: string): Promise<void> {
+    if (this.depDataKey) {
+      await this.dataModel.deleteMany({ [this.depDataKey]: dependencyId }).catch(error => {
+        throw new DynamoBEError({ status: 417, message: `delete ${this.dataName} by ${this.depDataKey} was unsuccessful (DB)`, error });
+      });
+    } else {
+      throw new DynamoBEError({ status: 501, message: `dependencyDataIdKey not setted up for this db-service (${this.dataName}) (BD)` });
+    }
+  }
+
+  // ----------------------------------------------------------------------------------
+  // ----------------------------------------------------------------------------------
+  // ----------------------------------------------------------------------------------
+  // DIRECT MONGOOSE CALLS (with error handlings)
+
+  /**
+   * find the data first by any of its parameters, throws error if not found
+   * @param filter etc. by email: { email: email }
+   * @returns data
+   */
+  async findOne(filter: any): Promise<T> {
+    let data: T;
+    await this.dataModel.findOne(filter).then(res => {
+      if (res) {
+        data = res.toObject() as T;
+      } else {
+        data = null;
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `findOne ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    if (data && typeof data._id === 'object') {
+      data._id = `${data._id}`;
+    }
+    return data;
+  }
+
+  /**
+   * find all data by any of its parameters, throws error if not found
+   * @param filter etc. by email: { email: email, points: { $gte: 2, $lte: 12 }, userIds: { $in: this.userId } }
+   * @returns dataList
+   */
+  async find(filter: any): Promise<T[]> {
+    let dataList = [];
+    await this.dataModel.find(filter).then(res => {
+      if (res) {
+        dataList = res;
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `find ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+      dataList.forEach((data: T) => {
+        data._id = `˙${data._id}`;
+      });
+    }
+    return dataList as T[];
+  }
+
+  /**
+   * find all data by any of its parameters, throws error if not found
+   * @param filter etc. by email: { email: email, points: { $gte: 2, $lte: 12 }, userIds: { $in: this.userId } }
+   * @param page page
+   * @param pageSize pageSize
+   * @param sort etc. by dateTime: { dateTime: -1 }
+   * @returns dataList
+   */
+  async findWithPaging(filter: any, page: number, pageSize: number, sort?: any): Promise<T[]> {
+    let dataList = [];
+    await this.dataModel.find(filter)
+                        .sort(sort)
+                        .skip(page * pageSize)
+                        .limit(pageSize)
+                        .then(res => {
+      if (res) {
+        dataList = res;
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `findWithPaging ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+      dataList.forEach((data: T) => {
+        data._id = `˙${data._id}`;
+      });
+    }
+    return dataList;
+  }
+
+  /**
+   * Find data by _id and update
+   * @param id id
+   * @param update update
+   * @returns data
+   */
+  async findByIdAndUpdate(id: string, update: any, modifier: string): Promise<T> {
+    let data: T;
+    update.__lastModified = new Date();
+    update.__lastModifiedBy = modifier;
+    await this.dataModel.findByIdAndUpdate(id, update).then(res => {
+      if (res) {
+        data = res.toObject() as T;
+      } else {
+        throw new DynamoBEError({ status: 204, message: `${this.dataName} not found! (BD)` });
+      }
+    }).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `findByIdAndUpdate ${this.dataName} was unsuccessful (DB)`, error });
+    });
+    update.__v = data.__v;
+    return update;
+  }
+
+  /**
+   * update one parameter by a specific
+   * @param updateBy etc.: by email: { email: email, points: { $gte: 2, $lte: 12 }, userIds: { $in: this.userId } } (always use unique parameters for find!)
+   * @param update etc.: { $inc: { popularity: this.newVote.amount }, emailVerified: true }
+   */
+  async updateOne(updateBy: any, update: any, modifier: string): Promise<void> {
+    update.__lastModified = new Date();
+    update.__lastModifiedBy = modifier;
+    await this.dataModel.updateOne(updateBy, update).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `updateOne ${this.dataName} was unsuccessful (DB)`, error });
+    });
+  }
+
+  /**
+   * update one parameter by a specific
+   * @param updateBy etc.: by email: { email: email, points: { $gte: 2, $lte: 12 }, userIds: { $in: this.userId } } (always use unique parameters for find!)
+   * @param update etc.: { $inc: { popularity: this.newVote.amount }, emailVerified: true, reactions: { $push: this.newReaction } }
+   */
+  async updateMany(updateBy: any, update: any, modifier: string): Promise<void> {
+    update.__lastModified = new Date();
+    update.__lastModifiedBy = modifier;
+    await this.dataModel.updateMany(updateBy, update).catch(error => {
+      throw new DynamoBEError({ status: 417, message: `updateMany ${this.dataName} was unsuccessful (DB)`, error });
+    });
+  }
+
+  // ----------------------------------------------------------------------------------
+  // ----------------------------------------------------------------------------------
+  // ----------------------------------------------------------------------------------
+  // PRIVATE BUILD FUNCTIONS
+
+  /**
+   * builds and returns mongoose schema
+   * @returns schema
+   */
+  private getSchema(): mongoose.Schema {
+    let schema: any = this.buildMongooseSchemaByModelParams();
+    schema = this.addMetadataToSchema(schema);
+    // tslint:disable-next-line: no-string-literal
+    if (schema['_id']) {
+      // tslint:disable-next-line: no-string-literal
+      delete schema['_id'];
+    }
+    return new Schema(schema);
+  }
+
+  /**
+   * builds mongoose schema building settings object by dynamoDataModelParamsList
+   * @param params DynamoBEDataPropertyParams
+   * @returns mongoose schema object
+   */
+  private buildMongooseSchemaByModelParams(params?: DynamoBEDataPropertyParams[]): any {
+    const schemaSettingsObj = {};
+    if (!params) {
+      params = this.dataModelParams;
+    }
+    params.forEach((property: DynamoBEDataPropertyParams) => {
+      const beType = this.getBEType(property.type);
+      if (beType !== Object || !property.subObjectParams) {
+        schemaSettingsObj[property.key] = {
+          type: beType
+        };
+        if (property.index) {
+          schemaSettingsObj[property.key].index = true;
+        }
+        if (property.unique) {
+          schemaSettingsObj[property.key].unique = true;
+        }
+        if (property.required) {
+          schemaSettingsObj[property.key].required = true;
+        }
+        if (property.minlength) {
+          schemaSettingsObj[property.key].minlength = property.minlength;
+        }
+        if (property.maxlength) {
+          schemaSettingsObj[property.key].maxlength = property.maxlength;
+        }
+      } else {
+        schemaSettingsObj[property.key] = this.buildMongooseSchemaByModelParams(property.subObjectParams);
+      }
+    });
+    return schemaSettingsObj;
+  }
+
+  private getBEType(type: string): String | Number | Boolean | Object | Function | Array<any> | Date {
+    switch (type) {
+      case 'string':
+        return String;
+      case 'number':
+        return Number;
+      case 'boolean':
+        return Boolean;
+      case 'Date':
+        return Date;
+      case 'object':
+        return Object;
+      default:
+        if (type.includes('[]')) {
+          return Array;
+        } else if (type.includes('=>') || type.includes('function')) {
+          return Function;
+        } else {
+          return Object;
+        }
+    }
+  }
+
+  /**
+   * adds dynamo metadata settings to any mongoose schema building settings object
+   * @param schema schema to update
+   * @returns updated schema
+   */
+  private addMetadataToSchema(schema: any): any {
+    schema.__created = { type: Date };
+    schema.__createdBy = { type: String };
+    schema.__lastModified = { type: Date };
+    schema.__lastModifiedBy = { type: String };
+    return schema;
+  }
+
+  /**
+   * sets depDataKey
+   */
+  private lookForDependencyDataSettings(): void {
+    const dependencyParam: DynamoBEDataPropertyParams = this.dataModelParams.find(
+        (modelParams: DynamoBEDataPropertyParams) => modelParams.isDependencyHook);
+    if (dependencyParam) {
+      this.depDataKey = dependencyParam.key;
+    }
+  }
+}

package/src/_services/dynamobe-email-service-collection.service.ts

@@ -0,0 +1,9 @@
+
+import { DynamoBEEmailService } from './dynamobe-email.service';
+import { DynamoBESingletonService } from './dynamobe-singleton.service';
+
+export class DynamoBEEmailServiceCollection extends DynamoBESingletonService {
+
+  [service: string]: DynamoBEEmailService;
+
+}