Stratification Factor Feature

backend/package.json

@@ -12,6 +12,7 @@
     },
     "license": "ISC",
     "dependencies": {
+        "dayjs": "^1.11.10",
         "jsonfile": "^6.0.1"
     },
     "devDependencies": {

backend/packages/Upgrade/package.json

@@ -96,6 +96,7 @@
         "nodemon": "^2.0.20",
         "npm": "^8.5.1",
         "objects-to-csv": "^1.3.6",
+        "papaparse": "^5.4.1",
         "pg": "^8.3.0",
         "reflect-metadata": "^0.1.13",
         "routing-controllers": "^0.9.0",

backend/packages/Upgrade/src/api/DTO/ExperimentDTO.ts

@@ -33,6 +33,7 @@ import {
   PAYLOAD_TYPE,
   REPEATED_MEASURE,
   EXPERIMENT_TYPE,
+  ASSIGNMENT_ALGORITHM,
 } from 'upgrade_types';
 import { Type } from 'class-transformer';
 
@@ -315,6 +316,12 @@ class StateTimeLogValidator {
   public timeLog: Date;
 }
 
+class StratificationFactor {
+  @IsString()
+  @IsNotEmpty()
+  public stratificationFactorName: string;
+}
+
 export class ExperimentDTO {
   @IsString()
   @IsOptional()
@@ -354,6 +361,10 @@ export class ExperimentDTO {
   @IsEnum(POST_EXPERIMENT_RULE)
   public postExperimentRule: POST_EXPERIMENT_RULE;
 
+  @IsOptional()
+  @IsEnum(ASSIGNMENT_ALGORITHM)
+  public assignmentAlgorithm?: ASSIGNMENT_ALGORITHM;
+
   // TODO add conditional validity here ie endOn is null
   @IsOptional()
   public enrollmentCompleteCondition?: Partial<IEnrollmentCompleteCondition>;
@@ -388,6 +399,11 @@ export class ExperimentDTO {
   @IsEnum(FILTER_MODE)
   public filterMode: FILTER_MODE;
 
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => StratificationFactor)
+  public stratificationFactor?: StratificationFactor;
+
   @IsNotEmpty()
   @IsArray()
   @ValidateNested({ each: true })

backend/packages/Upgrade/src/api/controllers/StratificationController.ts

@@ -0,0 +1,202 @@
+import { JsonController, Get, Delete, Param, Authorized, Post, Req, UseBefore, Res } from 'routing-controllers';
+import { SERVER_ERROR } from 'upgrade_types';
+import { AppRequest } from '../../types';
+import { UserStratificationFactor } from '../models/UserStratificationFactor';
+import { StratificationService } from '../services/StratificationService';
+import { FactorStrata } from './validators/StratificationValidator';
+import { StratificationFactor } from '../models/StratificationFactor';
+import * as express from 'express';
+import multer from 'multer';
+const storage = multer.memoryStorage();
+const upload = multer({ storage: storage });
+
+/**
+ * @swagger
+ * definitions:
+ *   FactorStrata:
+ *     description: ''
+ *     type: object
+ *     required:
+ *       - factor
+ *       - value
+ *     properties:
+ *       factor:
+ *         type: string
+ *       value:
+ *         type: object
+ *   UserStratificationFactor:
+ *     description: ''
+ *     type: object
+ *     properties:
+ *       user:
+ *         type: object
+ *         required:
+ *           - id
+ *         properties:
+ *           id:
+ *             type: string
+ *           group:
+ *             type: object
+ *           workingGroup:
+ *             type: object
+ *       stratificationFactor:
+ *         type: object
+ *         required:
+ *           - stratificationFactorName
+ *         properties:
+ *           stratificationFactorName:
+ *             type: string
+ *       stratificationFactorValue:
+ *         type: string
+ */
+
+/**
+ * @swagger
+ * tags:
+ *   - name: Stratification
+ *     description: CRUD operations related to Stratification
+ */
+@Authorized()
+@JsonController('/stratification')
+export class StratificationController {
+  constructor(public stratificatonService: StratificationService) {}
+
+  /**
+   * @swagger
+   * /stratification:
+   *    get:
+   *       description: Get all stratification
+   *       tags:
+   *         - Stratification
+   *       produces:
+   *         - application/json
+   *       responses:
+   *          '200':
+   *            description: Get all stratification
+   *            schema:
+   *              type: array
+   *              items:
+   *                $ref: '#/definitions/FactorStrata'
+   *          '401':
+   *            description: Authorization Required Error
+   */
+  @Get()
+  public async getAllStratification(@Req() request: AppRequest): Promise<FactorStrata[]> {
+    return this.stratificatonService.getAllStratification(request.logger);
+  }
+
+  /**
+   * @swagger
+   * /stratification/download/{factor}:
+   *    get:
+   *      description: Get stratificationFactor CSV by factorName
+   *      tags:
+   *        - Stratification
+   *      produces:
+   *        - application/json
+   *      parameters:
+   *        - in: path
+   *          name: factor
+   *          description: Factor name
+   *          required: true
+   *          schema:
+   *            type: string
+   *      responses:
+   *        '200':
+   *          description: Get stratificationFactor detailed CSV by name
+   *        '401':
+   *          description: Authorization Required Error
+   *        '404':
+   *          description: Factor name not found
+   *        '500':
+   *          description: Internal Server Error, FactorName is not valid
+   */
+  @Get('/download/:factor')
+  public async getStratificationByFactor(
+    @Param('factor') factor: string,
+    @Req() request: AppRequest,
+    @Res() res: express.Response
+  ): Promise<express.Response> {
+    if (!factor) {
+      return Promise.reject(new Error(SERVER_ERROR.MISSING_PARAMS + ' : stratification Factor should not be null.'));
+    }
+
+    const csvData = await this.stratificatonService.getCSVDataByFactor(factor, request.logger);
+
+    // return csv file with appropriate headers to request;
+    res.setHeader('Content-Type', 'text/csv; charset=UTF-8');
+    res.setHeader('Content-Disposition', `attachment; filename=data-${factor}.csv`);
+    return res.send(csvData);
+  }
+
+  /**
+   * @swagger
+   * /stratification:
+   *    post:
+   *      description: Create a new stratificationFactor by CSV
+   *      tags:
+   *        - Stratification
+   *      produces:
+   *        - application/json
+   *      parameters:
+   *        - in: body
+   *          name: file
+   *          description: CSV file
+   *          required: true
+   *          schema:
+   *            type: file
+   *      responses:
+   *        '200':
+   *          description: Create a new UserStratificationFactors by CSV
+   *          schema:
+   *            type: array
+   *            items:
+   *              $ref: '#/definitions/UserStratificationFactor'
+   *        '401':
+   *          description: Authorization Required Error
+   *        '500':
+   *          description: Internal Server Error, Insert Error in database, CSV file is not valid
+   */
+  @Post()
+  @UseBefore(upload.single('file'))
+  public insertStratification(@Req() request: AppRequest): Promise<UserStratificationFactor[]> {
+    return this.stratificatonService.insertStratification(request.body[0].file, request.logger);
+  }
+
+  /**
+   * @swagger
+   * /stratification/{factor}:
+   *    delete:
+   *      description: Delete a stratificationFactor by factorName
+   *      tags:
+   *      - Stratification
+   *      produces:
+   *        - application/json
+   *      parameters:
+   *        - in: path
+   *          name: factor
+   *          description: Factor name
+   *          required: true
+   *          schema:
+   *            type: string
+   *      responses:
+   *        '200':
+   *          description: Delete a stratificationFactor by factorName
+   *          schema:
+   *            $ref: '#/definitions/FactorStrata'
+   *        '401':
+   *          description: Authorization Required Error
+   *        '500':
+   *          description: Internal Server Error, FactorName is not valid
+   */
+  @Delete('/:factor')
+  public deleteStratification(
+    @Param('factor') stratificationFactor: string,
+    @Req() request: AppRequest
+  ): Promise<StratificationFactor> {
+    if (!stratificationFactor) {
+      return Promise.reject(new Error(SERVER_ERROR.MISSING_PARAMS + ' : stratification Factor should not be null.'));
+    }
+    return this.stratificatonService.deleteStratification(stratificationFactor, request.logger);
+  }
+}

backend/packages/Upgrade/src/api/controllers/validators/StratificationValidator.ts

@@ -0,0 +1,29 @@
+import { IsNotEmpty, IsObject, IsOptional, IsString, IsArray } from 'class-validator';
+
+export class FactorStrata {
+  @IsNotEmpty()
+  @IsString()
+  public factor: string;
+
+  @IsObject()
+  public factorValue: Record<string, number>;
+}
+
+export class StratificationInputValidator {
+  @IsNotEmpty()
+  @IsString()
+  public userId: string;
+
+  @IsNotEmpty()
+  @IsString()
+  public factor: string;
+
+  @IsOptional()
+  @IsString()
+  public value?: string;
+
+  @IsNotEmpty()
+  @IsArray()
+  @IsString({ each: true })
+  public experimentIds: string[];
+}

backend/packages/Upgrade/src/api/controllers/validators/UserDetailsValidator.ts

@@ -1,5 +1,16 @@
 import { Type } from 'class-transformer';
-import { IsNotEmpty, IsString, IsEnum, IsOptional, IsUrl, IsTimeZone, ValidateNested, IsArray, IsJSON, IsEmail } from 'class-validator';
+import {
+  IsNotEmpty,
+  IsString,
+  IsEnum,
+  IsOptional,
+  IsUrl,
+  IsTimeZone,
+  ValidateNested,
+  IsArray,
+  IsJSON,
+  IsEmail,
+} from 'class-validator';
 import { EXPERIMENT_LOG_TYPE, UserRole } from 'upgrade_types';
 
 class ExperimentAuditLogValidator {
@@ -18,11 +29,11 @@ class ExperimentAuditLogValidator {
 
 export class UserDetailsValidator {
   @IsString()
-  @IsNotEmpty()
+  @IsOptional()
   public firstName: string;
 
   @IsString()
-  @IsNotEmpty()
+  @IsOptional()
   public lastName: string;
 
   @IsNotEmpty()
@@ -44,7 +55,7 @@ export class UserDetailsValidator {
 
   @IsOptional()
   @IsArray()
-  @ValidateNested({each: true})
+  @ValidateNested({ each: true })
   @Type(() => ExperimentAuditLogValidator)
-  auditLogs?: ExperimentAuditLogValidator[]
+  auditLogs?: ExperimentAuditLogValidator[];
 }