tango-app-api-task 1.0.0-alpha.0

package/.eslintrc.cjs

@@ -0,0 +1,41 @@
+
+module.exports = {
+  'env': {
+    'es2021': true,
+    'node': true,
+  },
+  'extends': 'google',
+  'overrides': [
+    {
+      'env': {
+        'node': true,
+      },
+      'files': [
+        '.eslintrc.{js,cjs}',
+      ],
+      'parserOptions': {
+        'sourceType': 'script',
+      },
+    },
+  ],
+  'parserOptions': {
+    'ecmaVersion': 'latest',
+    'sourceType': 'module',
+  },
+  'rules': {
+    'linebreak-style': [ 'error', 'windows' ],
+    'require-jsdoc': 'off',
+    'arrow-spacing': 'error',
+    'key-spacing': [ 'error', { 'beforeColon': false, 'afterColon': true } ],
+    'object-curly-spacing': [ 'error', 'always' ],
+    'space-in-parens': [ 'error', 'always' ],
+    'keyword-spacing': 'error',
+    'array-bracket-spacing': [ 'error', 'always' ],
+    'spaced-comment': [ 'error', 'always' ],
+    'max-len': [ 'error', { 'code': 700 } ],
+    'no-unused-vars': 'error',
+    'new-cap': [ 'error', { 'newIsCap': true, 'capIsNew': false } ],
+    'prefer-const': 'off',
+  },
+};
+

package/README.md

@@ -0,0 +1,29 @@
+# README #
+
+This README would normally document whatever steps are necessary to get your application up and running.
+
+### What is this repository for? ###
+
+* Quick summary
+* Version
+* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)
+
+### How do I get set up? ###
+
+* Summary of set up
+* Configuration
+* Dependencies
+* Database configuration
+* How to run tests
+* Deployment instructions
+
+### Contribution guidelines ###
+
+* Writing tests
+* Code review
+* Other guidelines
+
+### Who do I talk to? ###
+
+* Repo owner or admin
+* Other community or team contact

package/index.js

@@ -0,0 +1,10 @@
+
+
+import { taskRouter } from './src/routes/task.routes.js';
+import { internalAPIRouter } from './src/routes/internalAPI.routes.js';
+import { taskDashboardRouter } from './src/routes/taskDashboard.routes.js';
+import { taskActionCenterRouter } from './src/routes/taskActionCenter.routes.js';
+
+export { taskRouter, internalAPIRouter, taskDashboardRouter, taskActionCenterRouter };
+
+

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "tango-app-api-task",
+    "version": "1.0.0-alpha.0",
+    "description": "Task",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+    },
+    "engines": {
+        "node": ">=18.10.0"
+    },
+    "author": "praveenraj",
+    "license": "ISC",
+    "dependencies": {
+        "aws-sdk": "^2.1692.0",
+        "body-parser": "^1.20.3",
+        "cors": "^2.8.5",
+        "dayjs": "^1.11.13",
+        "dotenv": "^16.4.5",
+        "express": "^4.21.1",
+        "express-fileupload": "^1.5.1",
+        "handlebars": "^4.7.8",
+        "mongodb": "^6.10.0",
+        "nodemon": "^3.1.7",
+        "tango-api-schema": "^2.1.86",
+        "tango-app-api-middleware": "^3.1.43-alpha.9",
+        "winston": "^3.17.0",
+        "winston-daily-rotate-file": "^5.0.0"
+    },
+    "devDependencies": {
+        "eslint": "^8.57.1",
+        "eslint-config-google": "^0.14.0",
+        "eslint-config-semistandard": "^17.0.0",
+        "eslint-config-standard": "^17.1.0",
+        "eslint-plugin-import": "^2.31.0",
+        "eslint-plugin-promise": "^6.6.0"
+    }
+}

package/src/controllers/internalAPI.controller.js

@@ -0,0 +1,304 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import timeZone from 'dayjs/plugin/timezone.js';
+import utc from 'dayjs/plugin/utc.js';
+import * as taskService from '../service/task.service.js';
+import * as taskQuestionService from '../service/taskQuestion.service.js';
+import * as taskAssignService from '../service/taskAssign.service.js';
+import * as taskProcessedConfigService from '../service/processedTaskConfig.service.js';
+import * as taskProcessedService from '../service/processedTaskList.service.js';
+import { logger } from 'tango-app-api-middleware';
+import mongoose from 'mongoose';
+const ObjectId = mongoose.Types.ObjectId;
+dayjs.extend( customParseFormat );
+dayjs.extend( utc );
+dayjs.extend( timeZone );
+
+export async function PCLTaskCreationValidator( req, res, next ) {
+  try {
+    let requestData = req.body;
+    let validateError = [];
+    if (
+      !requestData.hasOwnProperty( 'date' ) ||
+        requestData.date === undefined ||
+        requestData.date === null ||
+        requestData.date == ''
+    ) {
+      validateError.push( 'Date Is Required' );
+    }
+
+    if ( !requestData.hasOwnProperty( 'client_id' ) ) {
+      validateError.push( 'client_id Is Required' );
+    }
+
+    if ( validateError.length > 0 ) {
+      return res.sendError( validateError + ',', 400 );
+    } else {
+      let dateList = [];
+      let date = dayjs();
+      let reqDate = dayjs( requestData.date );
+      let loopCount = parseInt( requestData.numberofDays ) || 1;
+      for ( let i = 1; i <= loopCount; i++ ) {
+        if ( reqDate > date || reqDate.format( 'YYYY-MM-DD' ) == date.format( 'YYYY-MM-DD' ) ) {
+          dateList.push( reqDate.format( 'YYYY-MM-DD' ) );
+        }
+        reqDate = reqDate.add( 1, 'days' );
+      }
+      req.body.date = dateList;
+      next();
+    }
+  } catch ( error ) {
+    logger.error( { function: 'PCLTaskCreationValidator', error: error } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function PCLTaskconfigCreation( req, res ) {
+  try {
+    let requestData = req.body;
+    let dateList = [ ...requestData.date ];
+    requestData.date = [ requestData.date[0] ];
+    let response = await insertData( requestData );
+    if ( response.success == true ) {
+      dateList.splice( 0, 1 );
+      requestData.date = dateList;
+      if ( dateList.length ) {
+        insertData( requestData );
+      }
+      return res.sendSuccess( { message: 'Processed Daily Task Created Successfully', error: response.error } );
+    } else {
+      if ( response.error == 'no Content' ) {
+        if ( requestData.numberofDays == 1 || !requestData?.numberofDays ) {
+          return res.sendError( 'no data', 204 );
+        } else {
+          dateList.splice( 0, 1 );
+          requestData.date = dateList;
+          requestData.numberofDays = requestData.numberofDays -1;
+          req.body = requestData;
+          PCLTaskconfigCreation( req, res );
+        }
+      } else {
+        return res.sendSuccess( { message: response.error } );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { function: 'PCLTaskconfigCreation', error: e } );
+    return res.sendError( e, 500 );
+  }
+};
+
+async function insertData( requestData ) {
+  for ( let [ dateIndex, date ] of requestData.date.entries() ) {
+    let currentdate = dayjs( date ).format( 'YYYY-MM-DD' );
+    let clientCount = 0;
+    let start = new Date( date );
+    let userTimezoneOffset = start.getTimezoneOffset() * 60000;
+    start = new Date( start.getTime() - userTimezoneOffset );
+    start.setUTCHours( 0, 0, 0, 0 );
+    let end = new Date( date );
+    end = new Date( end.getTime() - userTimezoneOffset );
+    end.setUTCHours( 23, 59, 59, 59 );
+    let alreadyExist = [];
+    for ( let [ clientlistIndex, clientlist ] of requestData.client_id.entries() ) {
+      let getuniquechecklistquery = [];
+      getuniquechecklistquery.push( {
+        $match: {
+          client_id: clientlist,
+          isdeleted: false,
+          publish: true,
+        },
+      } );
+      let getuniquechecklist = await taskService.aggregate( getuniquechecklistquery );
+      clientCount += getuniquechecklist.length;
+
+      if ( clientCount == 0 && clientlistIndex == requestData.client_id.length - 1 ) {
+        return { success: false, error: 'no Content' };
+      }
+
+      if ( getuniquechecklist.length ) {
+        let resultchecklist = [];
+
+        for ( let element1 of getuniquechecklist ) {
+          let endDate = dayjs( element1?.scheduleDate ).format( 'YYYY-MM-DD' ) + ' ' + element1.scheduleEndTime;
+          endDate = dayjs.utc( endDate, 'YYYY-MM-DD hh:mm A' ).format();
+          if ( endDate >= dayjs( date ).format() ) {
+            resultchecklist.push( element1._id );
+          }
+        }
+
+        console.log( resultchecklist );
+
+
+        if ( resultchecklist.length ) {
+          for ( let [ index2, element2 ] of resultchecklist.entries() ) {
+            let getCLconfig = await taskService.findOne( { _id: element2 } );
+            if ( getCLconfig ) {
+              if ( dayjs( getCLconfig?.scheduleDate ).format( 'YYYY-MM-DD' ) != dayjs( date ).format( 'YYYY-MM-DD' ) ) {
+                getCLconfig.scheduleEndTime = '11:59 PM';
+              }
+              console.log( getCLconfig.scheduleEndTime );
+
+              let startTimeIso; let endTimeIso;
+              startTimeIso = dayjs.utc( `${currentdate} 12:00 AM`, 'YYYY-MM-DD hh:mm A' );
+              endTimeIso = dayjs.utc( `${currentdate} ${getCLconfig.scheduleEndTime}`, 'YYYY-MM-DD hh:mm A' );
+              console.log( endTimeIso );
+
+              let insertdata = {};
+              insertdata.date_iso = startTimeIso.format();
+              insertdata.date_string = currentdate;
+              insertdata.sourceCheckList_id = getCLconfig._id;
+              insertdata.checkListName = getCLconfig.checkListName;
+              insertdata.publish = getCLconfig.publish;
+              insertdata.scheduleStartTime = startTimeIso.format();
+              insertdata.scheduleStartTime_iso = startTimeIso.format();
+              insertdata.scheduleEndTime = getCLconfig.scheduleEndTime;
+              insertdata.scheduleEndTime_iso = endTimeIso.format();
+              insertdata.allowedOverTime = false;
+              insertdata.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+              insertdata.client_id = getCLconfig.client_id;
+              insertdata.createdBy = new ObjectId( getCLconfig.createdBy );
+              insertdata.createdByName = getCLconfig.createdByName;
+              insertdata.checkListType = getCLconfig.checkListType;
+              insertdata.storeCount = getCLconfig.storeCount;
+              insertdata.questionCount = getCLconfig.questionCount;
+              insertdata.publishDate = getCLconfig.publishDate;
+              insertdata.locationCount = getCLconfig.locationCount;
+              insertdata.scheduleRepeatedType = 'daily';
+              insertdata.allowedMultiSubmit = false;
+              insertdata.approver = getCLconfig.approver;
+              let collectSections = [];
+              let sectionQuery = [];
+              sectionQuery.push( {
+                $match: {
+                  checkListId: element2,
+                  isdeleted: false,
+                },
+              } );
+              let getSections = await taskQuestionService.aggregate( sectionQuery );
+              if ( getSections.length ) {
+                for ( let element3 of getSections ) {
+                  let collectQuestions = {};
+                  collectQuestions.section_id = element3._id;
+                  collectQuestions.sectionName = element3.section;
+                  collectQuestions.questions = element3.question;
+                  collectSections.push( collectQuestions );
+                }
+                insertdata.questionAnswers = collectSections;
+                insertdata.updatedAt = new Date();
+                let insertdataquery = {};
+                insertdataquery.date_string = insertdata.date_string;
+                insertdataquery.date_iso = insertdata.date_iso;
+                insertdataquery.client_id = insertdata.client_id;
+                insertdataquery.sourceCheckList_id = insertdata.sourceCheckList_id;
+                insertdataquery.startTime = { $exists: true };
+                let checkchecklist = await taskProcessedConfigService.findOne( insertdataquery );
+                if ( !checkchecklist ) {
+                  delete insertdataquery.startTime;
+                  let updatedchecklist;
+                  let checklistDetails = await taskProcessedConfigService.findOne( insertdataquery );
+                  if ( !checklistDetails ) {
+                    updatedchecklist = await taskProcessedConfigService.insert( insertdata );
+                  } else {
+                    await taskProcessedConfigService.updateOne( { _id: checklistDetails._id }, insertdata );
+                    updatedchecklist = checklistDetails;
+                  }
+                  if ( updatedchecklist ) {
+                    let getquestionQuery = [];
+                    getquestionQuery.push( {
+                      $match: {
+                        checkListId: element2,
+                        checkFlag: true,
+                        isdeleted: false,
+                        ...( getCLconfig?.reinitiate ) ? { reinitiate: true } : {},
+                      },
+                    } );
+                    let allQuestion = await taskAssignService.aggregate( getquestionQuery );
+                    if ( allQuestion.length ) {
+                      let userIdList = [];
+                      for ( let element4 of allQuestion ) {
+                        let query= {
+                          sourceCheckList_id: getCLconfig._id,
+                          $or: [ {
+                            checklistStatus: { $in: [ 'submit' ] } },
+                          { submitTime: { $exists: true } },
+                          ],
+                          userId: element4.userId,
+                          store_id: element4.store_id,
+                          $and: [ {
+                            date_iso: {
+                              $lte: new Date( endTimeIso.format( 'YYYY-MM-DD' ) ) },
+                          } ],
+
+                        };
+
+                        let getsubmitDetails = await taskProcessedService.find( query );
+                        if ( getsubmitDetails.length ) {
+                          userIdList.push( element4._id );
+                          continue;
+                        }
+
+                        delete element4._id;
+                        delete element4.checkFlag;
+                        delete element4.isdeleted;
+                        delete element4.createdAt;
+                        delete element4.updatedAt;
+                        element4.checkListId = updatedchecklist._id;
+                        element4.checkListName = getCLconfig.checkListName;
+                        element4.date_iso = new Date( currentdate );
+                        element4.date_string = currentdate;
+                        element4.allowedOverTime = false;
+                        element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+                        element4.scheduleStartTime = startTimeIso.format();
+                        element4.scheduleStartTime_iso = startTimeIso.format();
+                        element4.scheduleEndTime = getCLconfig.scheduleEndTime;
+                        element4.scheduleEndTime_iso = endTimeIso.format();
+                        element4.createdBy = new ObjectId( getCLconfig.createdBy );
+                        element4.createdByName = getCLconfig.createdByName;
+                        element4.sourceCheckList_id = getCLconfig._id;
+                        element4.checkListType = getCLconfig.checkListType;
+                        element4.storeCount = getCLconfig.storeCount;
+                        element4.questionCount = getCLconfig.questionCount;
+                        element4.publishDate = getCLconfig.publishDate;
+                        element4.locationCount = getCLconfig.locationCount;
+                        element4.scheduleRepeatedType = 'daily';
+                        element4.approvalEnable = getCLconfig.approver.length ? true : false;
+                      }
+                      if ( userIdList.length ) {
+                        allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
+                      }
+                      console.log( allQuestion );
+
+                      if ( allQuestion ) {
+                        let assigndeletequery = {};
+                        assigndeletequery.date_string = insertdata.date_string;
+                        assigndeletequery.date_iso = insertdata.date_iso;
+                        assigndeletequery.client_id = insertdata.client_id;
+                        assigndeletequery.checkListId = updatedchecklist._id;
+                        assigndeletequery.checklistStatus = { $nin: [ 'submit' ] };
+                        await taskProcessedService.deleteMany( assigndeletequery );
+                        await taskProcessedService.insertMany( allQuestion );
+                        logger.info( { function: 'taskProcessedCreation', query: assigndeletequery } );
+                      }
+                    }
+                  }
+                } else {
+                  alreadyExist.push( { sourceCheckList_id: insertdata.sourceCheckList_id, checkListName: insertdata.checkListName } );
+                }
+              }
+            }
+
+            if ( resultchecklist.length - 1 == index2 && requestData.client_id.length - 1 == clientlistIndex && dateIndex == requestData.date.length - 1 ) {
+              return { success: true, error: alreadyExist };
+            }
+          }
+        } else {
+          if ( requestData.date.length == 1 ) {
+            return { success: false, error: 'no Content' };
+          } else {
+            continue;
+          }
+        }
+      }
+    }
+  }
+}