fix models, interfaces, create new controllers for number and phone_t…

…ypes, add services

src/controllers/number.ts

@@ -0,0 +1,75 @@
+import { IDeletedMongoose, IControllers, INumberModel, INumberResponse } from '../interfaces';
+import { OK, INTERNAL_SERVER_ERROR, UNPROCESSABLE_ENTITY, getStatusText } from 'http-status-codes';
+import { createError } from '../utils/error_log';
+import { Request, Response } from 'express';
+
+import NumberService from '../services/number';
+
+class NumberController {
+  private NumberService: NumberService = new NumberService();
+  public findNumber = async (req: Request, res: Response) => {
+    try {
+      if (!req.query.Number) {
+        return res
+          .status(UNPROCESSABLE_ENTITY)
+          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Param Id undefined!'));
+      }
+      const PersonCollection = await this.NumberService.findByNumber(req.query.Number); // get number with person data
+      return res.status(OK).json(PersonCollection);
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+
+  public create = async (req: Request, res: Response): Promise<Response> => {
+    try {
+      const PersonRequest: INumberModel = req.body;
+      const PersonCollection = await this.NumberService.create(PersonRequest);
+      return res.status(OK).json(PersonCollection);
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+
+  public update = async (req: Request, res: Response): Promise<Response> => {
+    try {
+      const PersonRequest: INumberModel = req.body;
+      if (req.params.id) {
+        PersonRequest._id = req.params.id;
+      }
+      const PersonCollection = await this.NumberService.update(PersonRequest);
+      return res.status(OK).json(PersonCollection);
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+
+  public delete = async (req: Request, res: Response): Promise<Response> => {
+    try {
+      if (!req.params.id) {
+        return res
+          .status(UNPROCESSABLE_ENTITY)
+          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Param Id undefined!'));
+      }
+      const deletedRes: IDeletedMongoose = await this.NumberService.delete(req.params.id);
+      if (deletedRes.n !== 1 || deletedRes.ok !== 1) {
+        return res
+          .status(UNPROCESSABLE_ENTITY)
+          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Wrong data request!'));
+      }
+      return res.status(OK).json({ message: 'Deleted!', Id: req.params.id });
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+}
+
+export default new NumberController();

src/controllers/person.ts

@@ -1,22 +1,17 @@
-import { IDeletedMongoose, IControllers, IPersonModel, IPersonResponse } from '../interfaces';
+import { IDeletedMongoose, IControllers, IPersonModel, IPersonUpdateRequest } from '../interfaces';
 import { OK, INTERNAL_SERVER_ERROR, UNPROCESSABLE_ENTITY, getStatusText } from 'http-status-codes';
 import { createError } from '../utils/error_log';
 import { Request, Response } from 'express';
-
 import PersonService from '../services/person';
+import { validatePersonRequest } from '../utils/req_vertification';
 
-class PersonController implements IControllers {
+class PersonController {
   private PersonService: PersonService = new PersonService();
-  private PersonCollection?: IPersonModel | IPersonModel[] | null;
-  private PersonResponse: IPersonResponse = {
-    Person: [],
-  };
 
   public getAll = async (req: Request, res: Response): Promise<Response> => {
     try {
-      this.PersonCollection = await this.PersonService.getAll();
-      this.PersonResponse.Person = this.PersonCollection;
-      return res.status(OK).json(this.PersonResponse);
+      const PersonCollection = await this.PersonService.getAll();
+      return res.status(OK).json(PersonCollection);
     } catch (error) {
       return res
         .status(INTERNAL_SERVER_ERROR)
@@ -31,9 +26,8 @@ class PersonController implements IControllers {
           .status(UNPROCESSABLE_ENTITY)
           .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Param Id undefined!'));
       }
-      this.PersonCollection = await this.PersonService.getOne(req.params.id);
-      this.PersonResponse.Person = this.PersonCollection ? [this.PersonCollection] : [];
-      return res.status(OK).json(this.PersonResponse);
+      const PersonCollection = await this.PersonService.getOne(req.params.id);
+      return res.status(OK).json(PersonCollection);
     } catch (error) {
       return res
         .status(INTERNAL_SERVER_ERROR)
@@ -44,9 +38,13 @@ class PersonController implements IControllers {
   public create = async (req: Request, res: Response): Promise<Response> => {
     try {
       const PersonRequest: IPersonModel = req.body;
-      this.PersonCollection = await this.PersonService.create(PersonRequest);
-      this.PersonResponse.Person = this.PersonCollection || [];
-      return res.status(OK).json(this.PersonResponse);
+      if (!validatePersonRequest(PersonRequest)) {
+        return res
+          .status(UNPROCESSABLE_ENTITY)
+          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Invalid request!'));
+      }
+      const PersonCollection = await this.PersonService.create(PersonRequest);
+      return res.status(OK).json(PersonCollection);
     } catch (error) {
       return res
         .status(INTERNAL_SERVER_ERROR)
@@ -56,13 +54,15 @@ class PersonController implements IControllers {
 
   public update = async (req: Request, res: Response): Promise<Response> => {
     try {
-      const PersonRequest: IPersonModel = req.body;
-      if (req.params.id) {
-        PersonRequest._id = req.params.id;
+      const PersonRequest: IPersonUpdateRequest = req.body;
+      if (!req.params.id) {
+        return res
+          .status(UNPROCESSABLE_ENTITY)
+          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Param Id undefined!'));
       }
-      this.PersonCollection = await this.PersonService.update(PersonRequest);
-      this.PersonResponse.Person = this.PersonCollection || [];
-      return res.status(OK).json(this.PersonResponse);
+      PersonRequest._id = req.params.id;
+      const PersonCollection = await this.PersonService.update(PersonRequest);
+      return res.status(OK).json(PersonCollection);
     } catch (error) {
       return res
         .status(INTERNAL_SERVER_ERROR)
@@ -77,13 +77,8 @@ class PersonController implements IControllers {
           .status(UNPROCESSABLE_ENTITY)
           .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Param Id undefined!'));
       }
-      const deletedRes: IDeletedMongoose = await this.PersonService.delete(req.params.id);
-      if (deletedRes.n !== 1 || deletedRes.ok !== 1) {
-        return res
-          .status(UNPROCESSABLE_ENTITY)
-          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Wrong data request!'));
-      }
-      return res.status(OK).json({ message: 'Deleted!', Id: req.params.id });
+      const deletedRes = await this.PersonService.delete(req.params.id);
+      return res.status(OK).json(deletedRes);
     } catch (error) {
       return res
         .status(INTERNAL_SERVER_ERROR)

src/controllers/phone_type.ts

@@ -0,0 +1,72 @@
+import { IDeletedMongoose, IControllers, IPhoneTypeModel } from '../interfaces';
+import { OK, INTERNAL_SERVER_ERROR, UNPROCESSABLE_ENTITY, getStatusText } from 'http-status-codes';
+import { createError } from '../utils/error_log';
+import { Request, Response } from 'express';
+
+import PhoneTypeService from '../services/phone_types';
+
+class PhoneTypeController {
+  private PhoneTypeService: PhoneTypeService = new PhoneTypeService();
+
+  public getAll = async (req: Request, res: Response): Promise<Response> => {
+    try {
+      const PersonCollection = await this.PhoneTypeService.getAll();
+      return res.status(OK).json(PersonCollection);
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+
+  public create = async (req: Request, res: Response): Promise<Response> => {
+    try {
+      const PersonRequest: IPhoneTypeModel = req.body;
+      const PersonCollection = await this.PhoneTypeService.create(PersonRequest);
+      return res.status(OK).json(PersonCollection);
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+
+  public update = async (req: Request, res: Response): Promise<Response> => {
+    try {
+      const PersonRequest: IPhoneTypeModel = req.body;
+      if (req.params.id) {
+        PersonRequest._id = req.params.id;
+      }
+      const PersonCollection = await this.PhoneTypeService.update(PersonRequest);
+      // this.PersonResponse.Person = this.PersonCollection || [];
+      return res.status(OK).json(PersonCollection);
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+
+  public delete = async (req: Request, res: Response): Promise<Response> => {
+    try {
+      if (!req.params.id) {
+        return res
+          .status(UNPROCESSABLE_ENTITY)
+          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Param Id undefined!'));
+      }
+      const deletedRes: IDeletedMongoose = await this.PhoneTypeService.delete(req.params.id);
+      if (deletedRes.n !== 1 || deletedRes.ok !== 1) {
+        return res
+          .status(UNPROCESSABLE_ENTITY)
+          .json(createError(getStatusText(UNPROCESSABLE_ENTITY), 'Wrong data request!'));
+      }
+      return res.status(OK).json({ message: 'Deleted!', Id: req.params.id });
+    } catch (error) {
+      return res
+        .status(INTERNAL_SERVER_ERROR)
+        .json(createError(getStatusText(INTERNAL_SERVER_ERROR), error.message, error));
+    }
+  };
+}
+
+export default new PhoneTypeController();

src/interfaces/IControllers.ts

@@ -1,28 +1,61 @@
 import { Request, Response } from 'express';
-import { IPersonModel } from '.';
+import { IPerson, INumber, INumberForModel, IPhoneType } from '.';
 
-export interface IPersonResponse {
-  Person: IPersonModel[] | IPersonModel;
+export interface IControllers {
+  getAll(req: Request, res: Response): Promise<Response>;
+  getById(req: Request, res: Response): Promise<Response>;
+  create(req: Request, res: Response): Promise<Response>;
+  update(req: Request, res: Response): Promise<Response>;
+  delete(req: Request, res: Response): Promise<Response>;
 }
 
-export interface IDeletedMongoose {
-  n: number;
-  ok: number;
+// response
+export interface IPersonResponse extends IPerson {
+  Default: string;
+  Numbers: INumberPersonResponse[];
+}
+
+export interface IPhoneTypeRequestResponse extends IPhoneType {
+  _id: string;
 }
 
+interface INumberPersonResponse extends INumber {
+  _type: IPhoneTypeRequestResponse;
+}
+export interface INumberResponse extends INumber {
+  _id: string;
+  _person: string;
+  _type: IPhoneTypeRequestResponse;
+}
+
+// request
 export interface IUserRequest {
-  username?: string;
-  password?: string;
+  Username?: string;
+  Password?: string;
 }
 
-export interface IControllers {
-  getAll(req: Request, res: Response): Promise<Response>;
-  getById(req: Request, res: Response): Promise<Response>;
-  create(req: Request, res: Response): Promise<Response>;
-  update(req: Request, res: Response): Promise<Response>;
-  delete(req: Request, res: Response): Promise<Response>;
+export interface IPersonUpdateRequest extends IPerson {
+  _id: string;
+  Default?: string;
+}
+export interface IPersonCreateRequest extends IPersonUpdateRequest {
+  Numbers: INumberCreateRequest[];
+}
+
+export interface INumberUpdateRequest extends INumberCreateRequest {
+  _id: string;
+}
+export interface INumberCreateRequest extends INumberForModel {
+  Default?: boolean;
+}
+
+// mongoose delete response
+export interface IDeletedMongoose {
+  n: number;
+  ok: number;
 }
 
+// error
 export interface IError {
   Error: string;
   message: string;

src/interfaces/IModels.ts

@@ -16,16 +16,26 @@ export interface IPerson {
   Lng: number;
 }
 
+export interface IPhoneType {
+  Name: string;
+}
+
 export interface INumber {
   Number: string;
 }
 
-export interface IPhoneType {
-  Name: string;
+export interface IPersonForModel extends IPerson {
+  Default: string;
+  Numbers: INumberForModel[];
+}
+
+export interface INumberForModel extends INumber {
+  _type: string;
+  _person: string;
 }
 
-export interface IPersonModel extends IPerson, Document {}
+export interface IPersonModel extends IPersonForModel, Document {}
 
-export interface INumberModel extends INumber, Document {}
+export interface INumberModel extends INumberForModel, Document {}
 
 export interface IPhoneTypeModel extends IPhoneType, Document {}

src/models/number.ts

@@ -1,21 +1,14 @@
 import { Schema, Model, model } from 'mongoose';
 import { INumberModel, IModelClass } from '../interfaces';
 
-class NumberModel implements IModelClass<INumberModel> {
-  public ModelType: Model<INumberModel>;
-  public ModelSchema: Schema;
-  public filter: string = '-__v'; // filter auto-import mongoBD __v
-  constructor() {
-    this.ModelSchema = new Schema({
-      Number: String,
-      PersonId: { type: Schema.Types.ObjectId, ref: 'Person' },
-      Type: {
-        type: Schema.Types.ObjectId,
-        ref: 'Phone_type',
-      },
-    });
-    this.ModelType = model<INumberModel>('Number', this.ModelSchema);
-  }
+class NumberModel {
+  public static filter: string = '-__v'; // filter auto-import mongoBD __v
+  public static readonly ModelSchema: Schema = new Schema({
+    Number: String,
+    _person: { type: Schema.Types.ObjectId, ref: 'Person' },
+    _type: { type: Schema.Types.ObjectId, ref: 'Phone_type' },
+  }).index({ Number: 'text' });
+  public static readonly ModelType: Model<INumberModel> = model<INumberModel>('Number', NumberModel.ModelSchema);
 }
 
 export default NumberModel;