#159 #161 Refactoring sectors to include type & kind, Adding property address fields & refactoring

backend/package.json

@@ -19,6 +19,7 @@
     "jsonwebtoken": "^8.5.1",
     "mysql": "^2.17.1",
     "password-validator": "^5.0.2",
+    "postcode-validator": "^3.0.0",
     "reflect-metadata": "^0.1.13",
     "validator": "^12.0.0"
   },

backend/src/constants/BodyFields.ts

@@ -1,15 +1,19 @@
 const UserFields = {
     loginFields : ['email', 'password'],
-    createFields : ['email', 'password', 'firstName', 'lastName', 'phoneNumber', 'userType']
-}
+    createFields : ['email', 'password', 'firstName', 'lastName', 'phoneNumber', 'userType'],
+};
 
 const WorkOrderFields = {
-    createFields : ['sectorType', 'workOrderType', 'title', 'cause', 'serviceNeeded', 
-        'priorityType', 'description', 'dueDate', 'priceEstimate']
-}
+    createFields : ['sectorKind', 'workOrderType', 'title', 'cause', 'serviceNeeded',
+        'priorityType', 'description', 'dueDate', 'priceEstimate'],
+};
 
-const PropertyFields = {
-    createFields : ['name', 'propertyType', 'address']
-}
+const PROPERTY_FIELDS = {
+    createFields : ['name', 'propertyType', 'address', 'city', 'province', 'postalCode', 'countryCode'],
+};
 
-export {UserFields, WorkOrderFields, PropertyFields};
+const PROPERTY_SECTOR_FIELDS = {
+    createFields : ['sectorKind'],
+};
+
+export { UserFields, WorkOrderFields, PROPERTY_FIELDS, PROPERTY_SECTOR_FIELDS };

backend/src/constants/FindOptionsFields.ts

@@ -1,69 +1,73 @@
-import { FindOptions } from "typeorm";
-import { Property } from "../entities/Property";
-import { User } from "../entities/User";
-import { WorkOrder } from "../entities/WorkOrder";
+import { FindOptions } from 'typeorm';
+import { Property } from '../entities/Property';
+import { User } from '../entities/User';
+import { WorkOrder } from '../entities/WorkOrder';
+import { PropertySector } from '../entities/PropertySector';
 
 const PropertyFields : FindOptions<Property> = {
     relations: ['activityStatus', 'propertyType', 'user'],
     select: {
-        id: true, 
-        name: true, 
+        id: true,
+        name: true,
         user: {
-            id: true
-        }, 
+            id: true,
+        },
         address: true,
         activityStatus: {
-            id: true, 
-            status: true
-        }, 
+            id: true,
+            status: true,
+        },
         propertyType: {
-            id: true, 
-            type: true
-        }
-    }
-}
+            id: true,
+            type: true,
+        },
+    },
+};
 
 const PropertyFieldsNoUser : FindOptions<Property> = {
     relations: ['activityStatus', 'propertyType'],
     select: {
-        id: true, 
-        name: true, 
+        id: true,
+        name: true,
         address: true,
         activityStatus: {
-            id: true, 
-            status: true
-        }, 
+            id: true,
+            status: true,
+        },
         propertyType: {
-            id: true, 
-            type: true
-        }
-    }
-}
+            id: true,
+            type: true,
+        },
+    },
+};
 
 const UserFields : FindOptions<User> = {
     relations: ['userType'],
     select: {
-        id: true, 
-        firstName: true, 
+        id: true,
+        firstName: true,
         lastName: true,
         email: true,
         userType: {
             id: true,
-            type: true
-        }
-    }
-}
+            type: true,
+        },
+        phoneNumber: true,
+    },
+};
 
 const WorkOrderFields : FindOptions<WorkOrder> = {
-    relations: ['workOrderType', 'priorityType', 'sectorType', 'createdBy', 'lastModifiedBy', 'property'],
+    relations: ['workOrderType', 'priorityType', 'sector', 'createdBy',
+        'lastModifiedBy', 'property'],
     select: {
         id: true,
         property: {
-            id: true
+            id: true,
         },
-        sectorType: {
+        sector: {
             id: true,
-            type: true
+            type: true,
+            kind: true,
         },
         workOrderType: {
             id: true,
@@ -74,31 +78,32 @@ const WorkOrderFields : FindOptions<WorkOrder> = {
         serviceNeeded: true,
         priorityType: {
             id: true,
-            type: true
+            type: true,
         },
         description: true,
         dueDate: true,
         createdDate: true,
         createdBy: {
-            id: true
+            id: true,
         },
         lastModifiedDate: true,
         lastModifiedBy: {
-            id: true
+            id: true,
         },
         dateCompleted: true,
         priceEstimate: true,
-        actualCost: true
-    }
-}
+        actualCost: true,
+    },
+};
 
 const WorkOrderFieldsNoProperty : FindOptions<WorkOrder> = {
-    relations: ['workOrderType', 'priorityType', 'sectorType', 'createdBy', 'lastModifiedBy'],
+    relations: ['workOrderType', 'priorityType', 'sector', 'createdBy', 'lastModifiedBy'],
     select: {
         id: true,
-        sectorType: {
+        sector: {
             id: true,
-            type: true
+            type: true,
+            kind: true,
         },
         workOrderType: {
             id: true,
@@ -109,22 +114,33 @@ const WorkOrderFieldsNoProperty : FindOptions<WorkOrder> = {
         serviceNeeded: true,
         priorityType: {
             id: true,
-            type: true
+            type: true,
         },
         description: true,
         dueDate: true,
         createdDate: true,
         createdBy: {
-            id: true
+            id: true,
         },
         lastModifiedDate: true,
         lastModifiedBy: {
-            id: true
+            id: true,
         },
         dateCompleted: true,
         priceEstimate: true,
-        actualCost: true
-    }
-}
+        actualCost: true,
+    },
+};
+
+const PROPERTY_SECTOR_FIELDS : FindOptions<PropertySector> = {
+    relations: ['sector'],
+    select: {
+        id: true,
+        sector: {
+            id: true,
+        },
+    },
+};
 
-export { PropertyFields, UserFields, WorkOrderFields, PropertyFieldsNoUser, WorkOrderFieldsNoProperty };
+export { PropertyFields, UserFields, WorkOrderFields, PropertyFieldsNoUser,
+    WorkOrderFieldsNoProperty, PROPERTY_SECTOR_FIELDS };

backend/src/controllers/PropertyController.ts

@@ -1,11 +1,19 @@
-import express, {Request, Response } from 'express';
+import express, { Request, Response } from 'express';
 import { PropertyService } from '../services/PropertyService';
 import { PropertyMapper } from '../entity_mappers/PropertyMapper';
 import auth from '../middleware/auth';
-import handleError from '../utils/HttpUtils';
+import { handleError } from '../utils/HttpUtils';
+import { validateArrayBody } from '../middleware/requestValidation';
+import { PROPERTY_SECTOR_FIELDS } from '../constants/BodyFields';
+import { PropertySectorDTO } from '../dtos/PropertySectorDTO';
+import { PropertySector } from '../entities/PropertySector';
+import { PropertySectorService } from '../services/PropertySectorService';
+import { PropertySectorMapper } from '../entity_mappers/PropertySectorMapper';
 
 const propertyService = new PropertyService();
 const propertyMapper = new PropertyMapper();
+const propertySectorService = new PropertySectorService();
+const propertySectorMapper = new PropertySectorMapper();
 
 const propertyController = express.Router();
 
@@ -15,16 +23,34 @@ propertyController.get('/:id', auth, async(req: Request, res: Response) => {
         return res.status(200).json(propertyMapper.toDTO(property));
     } catch (err) {
         return handleError(err, res);
-    } 
-})
+    }
+});
 
 propertyController.patch('/:id', auth, async(req: Request, res: Response) => {
     try {
         await propertyService.updatePropertyById(Number(req.params.id), req.body);
         return res.status(204).end();
     } catch (err) {
         return handleError(err, res);
-    } 
-})
+    }
+});
+
+propertyController.post(
+    '/:propertyId/sectors', validateArrayBody(PROPERTY_SECTOR_FIELDS.createFields), auth,
+    async (req: Request, res: Response) => {
+        try {
+            const { propertyId } = req.params;
+            const propertySectorDTOs : PropertySectorDTO[] = req.body as PropertySectorDTO[];
+            const propertySectors : PropertySector[] = await propertySectorService
+                .createPropertySectors(
+                    Number(propertyId),
+                    propertySectorDTOs.map(propertySectorDTO =>
+                        propertySectorMapper.fromDTO(propertySectorDTO)));
+            return res.status(200).json(propertySectors.map(propertySector =>
+                propertySectorMapper.toDTO(propertySector)));
+        } catch (err) {
+            return handleError(err, res);
+        }
+    });
 
 export { propertyController };

backend/src/controllers/PropertySectorsController.ts

@@ -0,0 +1,26 @@
+import express, { Request, Response } from 'express';
+import { PropertySectorService } from '../services/PropertySectorService';
+import { PropertySectorMapper } from '../entity_mappers/PropertySectorMapper';
+import auth from '../middleware/auth';
+import { handleError } from '../utils/HttpUtils';
+import { PropertySectorDTO } from '../dtos/PropertySectorDTO';
+
+const propertySectorService = new PropertySectorService();
+const propertySectorMapper = new PropertySectorMapper();
+
+const propertySectorsController = express.Router({ mergeParams: true });
+
+propertySectorsController.patch('/:propertySectorId', auth, async (req: Request, res: Response) => {
+    try {
+        const { propertySectorId } = req.params;
+        const propertySectorDTO : PropertySectorDTO = req.body as PropertySectorDTO;
+        await propertySectorService.update(
+            Number(propertySectorId),
+            propertySectorMapper.fromDTO(propertySectorDTO));
+        return res.status(204).end();
+    } catch (err) {
+        return handleError(err, res);
+    }
+})
+
+export { propertySectorsController };

backend/src/controllers/PropertyWorkOrdersController.ts

@@ -3,8 +3,8 @@ import { WorkOrderService } from '../services/WorkOrderService';
 import { WorkOrderMapper } from '../entity_mappers/WorkOrderMapper';
 import { WorkOrderDTO } from '../dtos/WorkOrderDTO';
 import auth from '../middleware/auth';
-import handleError from '../utils/HttpUtils';
-import validateBody from '../middleware/requestValidation';
+import { handleError } from '../utils/HttpUtils';
+import { validateBody } from '../middleware/requestValidation';
 import { WorkOrderFields } from '../constants/BodyFields';
 
 const propertyWorkOrdersController = express.Router({mergeParams: true});

backend/src/controllers/UserController.ts

@@ -2,8 +2,8 @@ import express, {Request, Response} from 'express';
 import { UserService } from '../services/UserService';
 import { UserMapper } from '../entity_mappers/UserMapper';
 import auth from '../middleware/auth';
-import handleError from '../utils/HttpUtils';
-import validateBody from '../middleware/requestValidation';
+import { handleError } from '../utils/HttpUtils';
+import { validateBody } from '../middleware/requestValidation';
 import { UserFields } from '../constants/BodyFields';
 import { UserDTO } from 'src/dtos/UserDTO';