tango-app-api-trax 3.4.0-soplink2-0 → 3.4.1-activitylog-2

package/src/controllers/internalTrax.controller.js

@@ -18,7 +18,7 @@ import timeZone from 'dayjs/plugin/timezone.js';
 import utc from 'dayjs/plugin/utc.js';
 import { logger } from 'tango-app-api-middleware';
 import mongoose from 'mongoose';
-import { sendPushNotification } from 'tango-app-api-middleware';
+import { sendPushNotification, sendAiPushNotification } from 'tango-app-api-middleware';
 // import * as planoService from '../services/planogram.service.js';
 import * as clusterServices from '../services/cluster.service.js';
 import * as teamsServices from '../services/teams.service.js';
@@ -68,7 +68,7 @@ export async function PCLchecklistCreationValidator( req, res, next ) {
   }
 }
 
-export async function PCLconfigCreation( req, res ) {
+export async function PCLconfigCreationold( req, res ) {
   try {
     let requestData = req.body;
     let dateList = [ ...requestData.date ];
@@ -92,13 +92,570 @@ export async function PCLconfigCreation( req, res ) {
           req.body = requestData;
           PCLconfigCreation( req, res );
         }
-      } else {
-        return res.sendSuccess( { message: response.error } );
+      } else {
+        return res.sendSuccess( { message: response.error } );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { function: 'PCLconfigCreation', error: e } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export async function PCLconfigCreation( req, res ) {
+  try {
+    let requestData = req.body;
+    let getuniquechecklistquery = {
+      client_id: { $in: requestData.client_id },
+      type: 'checklist',
+      isdeleted: false,
+      publish: true,
+    };
+    let alreadyExist = [];
+    let getuniquechecklist = await CLconfig.find( getuniquechecklistquery );
+    if ( getuniquechecklist.length ) {
+      let checklistList = getuniquechecklist.map( ( ele ) => ele.checkListName );
+      logger.info( { checklistList: checklistList.toString() } );
+      for ( let [ dateIndex, date ] of requestData.date.entries() ) {
+        let currentday = dayjs( date ).format( 'dddd' );
+        let currentdate = dayjs( date ).format( 'YYYY-MM-DD' );
+        let currentdatedd = dayjs( date ).format( 'DD' );
+        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 validation;
+        validation = false;
+        let resultchecklist = [];
+        await Promise.all( getuniquechecklist.map( async ( element1 ) => {
+          validation = false;
+          let scheduledate = dayjs( element1.scheduleDate ).format( 'YYYY-MM-DD' );
+          if ( element1.schedule == 'daily' ) {
+            let newDate = dayjs.utc( element1.publishDate ).startOf( 'day' );
+            if ( element1.scheduleRepeatedDay[0] != '01' && newDate.format( 'YYYY-MM-DD' ) != currentdate ) {
+              let checkExists = await processedchecklist.findOne( { sourceCheckList_id: element1._id }, { date_string: 1 } );
+              if ( checkExists ) {
+                newDate = dayjs.utc( checkExists.date_string ).startOf( 'day' );
+              }
+              let cdate = dayjs.utc( currentdate ).startOf( 'day' );
+              let diff = parseInt( cdate.diff( newDate, 'day' ) );
+              diff = diff < 9 ? '0'+ diff : diff;
+              if ( diff == parseInt( element1.scheduleRepeatedDay[0] ) ) {
+                validation = true;
+              }
+            } else {
+              validation = true;
+            }
+          } else if ( [ 'weekly', 'weekday' ].includes( element1.schedule ) ) {
+            if ( element1.scheduleWeekDays.includes( currentday ) ) {
+              let newDate = dayjs.utc( element1.publishDate );
+              let endWeek = dayjs.utc( element1.publishDate ).endOf( 'week' );
+              if ( element1.scheduleRepeatedDay[0] != '01' && currentdate > endWeek.format( 'YYYY-MM-DD' ) ) {
+                let checkExists = await processedchecklist.findOne( { sourceCheckList_id: element1._id }, { date_string: 1 } );
+                if ( checkExists ) {
+                  newDate = dayjs.utc( checkExists.date_string );
+                }
+                let startWeek = dayjs.utc( newDate ).startOf( 'week' );
+                let endWeek = dayjs.utc( newDate ).clone().endOf( 'week' );
+                let diff = parseInt( dayjs.utc( currentdate ).diff( startWeek, 'week' ) );
+                diff = diff < 9 ? '0'+diff : diff;
+                if ( diff == element1.scheduleRepeatedDay[0] || ( startWeek.format( 'YYYY-MM-DD' ) <= currentdate && endWeek.format( 'YYYY-MM-DD' ) >= currentdate ) ) {
+                  validation = true;
+                }
+              } else {
+                validation = true;
+              }
+            }
+          } else if ( element1.schedule == 'monthly' ) {
+            if ( element1.scheduleRepeatedMonthSetup == 'day' && element1.scheduleRepeatedMonthWeek == currentdatedd ) {
+              validation = true;
+            } else if ( element1.scheduleRepeatedMonthSetup == 'date' ) {
+              let days = [];
+              let currDate = dayjs.utc( currentdate );
+              let dateDat = dayjs.utc( currDate ).startOf( 'month' );
+              while ( dateDat.month() === currDate.month() ) {
+                if ( dateDat.format( 'dddd' ) === element1.scheduleRepeatedMonthWeek.split( ' ' )[1] ) {
+                  days.push( dateDat.format( 'YYYY-MM-DD' ) );
+                }
+                dateDat = dateDat.add( 1, 'day' );
+              }
+
+              if ( element1.scheduleRepeatedMonthWeek.split( ' ' )[0] == 5 ) {
+                if ( days[days.length -1] == currentdate ) {
+                  validation = true;
+                }
+              } else {
+                if ( days[parseInt( element1.scheduleRepeatedMonthWeek.split( ' ' )[0] )-1] == currentdate ) {
+                  validation = true;
+                }
+              }
+            } else if ( element1.scheduleRepeatedMonthSetup == 'specific' ) {
+              let currentdatesingleDigit = dayjs( currentdate ).format( 'D' );
+              if ( element1.specificDate.includes( parseInt( currentdatesingleDigit ) ) ) {
+                validation = true;
+              }
+            } else {
+              validation = false;
+            }
+
+            if ( validation ) {
+              validation = false;
+              let newDate = dayjs.utc( element1.publishDate );
+              let endMonth = newDate.endOf( 'month' );
+              if ( element1.scheduleRepeatedDay[0] != '01' && currentdate > endMonth.format( 'YYYY-MM-DD' ) ) {
+                let checkExists = await processedchecklist.findOne( { sourceCheckList_id: element1._id }, { date_string: 1 } );
+                if ( checkExists ) {
+                  newDate = dayjs( checkExists.date_string );
+                }
+
+                let startMonth = newDate.startOf( 'month' );
+                let endMonth = newDate.clone().endOf( 'month' );
+
+                let diff = parseInt( dayjs.utc( currentdate ).diff( startMonth, 'month' ) );
+                diff = diff < 9 ? '0'+diff : diff;
+
+                if ( diff == parseInt( element1.scheduleRepeatedDay[0] ) || ( startMonth.format( 'YYYY-MM-DD' ) <= currentdate && endMonth.format( 'YYYY-MM-DD' ) >= currentdate ) ) {
+                  validation = true;
+                }
+              } else {
+                validation = true;
+              }
+            }
+          } else if ( element1.schedule == 'onetime' ) {
+            if ( scheduledate == currentdate ) {
+              resultchecklist.push( element1._id );
+            }
+          } else {
+            let startDate = dayjs.utc( element1.configStartDate ).format( 'YYYY-MM-DD' );
+            let endDate = dayjs.utc( element1.configEndDate ).format( 'YYYY-MM-DD' );
+
+            if ( startDate <= currentdate && endDate >= currentdate ) {
+              if ( !element1?.specificDate?.length ) {
+                resultchecklist.push( element1._id );
+              } else {
+                if ( element1?.specificDate.includes( dayjs( currentdate ).format( 'DD-MM-YYYY' ) ) ) {
+                  resultchecklist.push( element1._id );
+                }
+              }
+            }
+          }
+          if ( ![ 'onetime', 'range' ].includes( element1.schedule ) ) {
+            if ( validation ) {
+              let startDate = element1?.configStartDate ? dayjs.utc( element1?.configStartDate ).format( 'YYYY-MM-DD' ) : '';
+              let endDate = element1?.configEndDate ? dayjs.utc( element1?.configEndDate ).format( 'YYYY-MM-DD' ) : '';
+              if ( !startDate && !endDate || ( startDate && ( startDate == currentdate || startDate < currentdate ) ) && endDate == '' ) {
+                resultchecklist.push( element1._id );
+              }
+              if ( endDate != '' && startDate <= currentdate && endDate >= currentdate ) {
+                resultchecklist.push( element1._id );
+              }
+            }
+          }
+        } ) );
+        if ( resultchecklist.length ) {
+          await Promise.all( resultchecklist.map( async ( element2 ) => {
+            let getCLconfig = getuniquechecklist.find( ( checklist ) => checklist._id.toString() == element2.toString() );
+            if ( getCLconfig ) {
+              let startTimeIso; let endTimeIso;
+              startTimeIso = dayjs.utc( `${currentdate} ${getCLconfig.scheduleStartTime}`, 'YYYY-MM-DD hh:mm A' );
+              endTimeIso = dayjs.utc( `${currentdate} ${getCLconfig.scheduleEndTime}`, 'YYYY-MM-DD hh:mm A' );
+              let insertdata = {};
+              insertdata.date_iso = new Date( currentdate );
+              insertdata.date_string = currentdate;
+              insertdata.sourceCheckList_id = getCLconfig._id;
+              insertdata.checkListName = getCLconfig.checkListName;
+              insertdata.checkListDescription = getCLconfig.checkListDescription;
+              insertdata.publish = getCLconfig.publish;
+              insertdata.scheduleStartTime = getCLconfig.scheduleStartTime;
+              insertdata.scheduleStartTime_iso = startTimeIso.format();
+              insertdata.scheduleEndTime = getCLconfig.scheduleEndTime;
+              insertdata.scheduleEndTime_iso = endTimeIso.format();
+              insertdata.allowedOverTime = getCLconfig.allowedOverTime;
+              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 = getCLconfig.scheduleRepeatedType;
+              insertdata.allowedMultiSubmit = getCLconfig.allowedMultiSubmit;
+              insertdata.rawImageUpload = getCLconfig.rawImageUpload || false;
+              let collectSections = [];
+              let sectionQuery = [];
+              sectionQuery.push( {
+                $match: {
+                  checkListId: element2,
+                  isdeleted: false,
+                },
+              } );
+              let getSections = await CLquestions.aggregate( sectionQuery );
+              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection' ].includes( getCLconfig.checkListType ) ) {
+                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 PCLconfig.findOne( insertdataquery );
+                if ( !checkchecklist ) {
+                  delete insertdataquery.startTime;
+                  let updatedchecklist;
+                  let checklistDetails = await PCLconfig.findOne( insertdataquery );
+                  if ( !checklistDetails ) {
+                    updatedchecklist = await PCLconfig.insert( insertdata );
+                  } else {
+                    await PCLconfig.updateOne( { _id: checklistDetails._id }, insertdata );
+                    updatedchecklist = checklistDetails;
+                  }
+                  if ( updatedchecklist ) {
+                    let getquestionQuery = [];
+                    getquestionQuery.push( {
+                      $match: {
+                        checkListId: element2,
+                        isdeleted: false,
+                      },
+                    } );
+                    let allQuestion = await CLassign.aggregate( getquestionQuery );
+                    if ( allQuestion.length && getCLconfig.checkListType == 'custom' ) {
+                      let assignList = [];
+                      if ( getCLconfig.coverage == 'store' ) {
+                        let clusterList = allQuestion.filter( ( ele ) => ele?.clusterName ).map( ( item ) => item.assignId );
+                        if ( clusterList.length ) {
+                          let clusterDetails = await clusterServices.findcluster( { _id: { $in: clusterList } } );
+                          if ( clusterDetails.length ) {
+                            let idList = clusterDetails.flatMap( ( item ) => item.stores.map( ( ele ) => ele.store ) );
+                            let getStoreDetails = await storeService.find( { _id: { $in: idList } } );
+                            if ( getStoreDetails.length ) {
+                              assignList = await Promise.all( getStoreDetails.map( async ( store ) => {
+                                let userDetails = await userService.findOne( { email: store?.spocDetails?.[0]?.email, clientId: store.clientId } );
+                                if ( !userDetails ) {
+                                  let data = {
+                                    clientId: store.clientId,
+                                    userName: store.spocDetails?.[0]?.name,
+                                    mobileNumber: store.spocDetails?.[0]?.phone || '',
+                                    email: store.spocDetails[0].email,
+                                    password: '5dqFKAJj29PsV6P+kL+3Dw==',
+                                    role: 'user',
+                                    userType: 'client',
+                                    rolespermission: [
+                                      {
+                                        featureName: 'Global',
+                                        modules: [
+                                          {
+                                            name: 'Store',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                          {
+                                            name: 'User',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                          {
+                                            name: 'Camera',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                          {
+                                            name: 'Configuration',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                          {
+                                            name: 'Subscription',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                          {
+                                            name: 'Billing',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                        ],
+                                      },
+                                      {
+                                        featurName: 'TangoEye',
+                                        modules: [
+                                          {
+                                            name: 'ZoneTag',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                        ],
+                                      },
+                                      {
+                                        featurName: 'TangoTrax',
+                                        modules: [
+                                          {
+                                            name: 'checklist',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                          {
+                                            name: 'Task',
+                                            isAdd: false,
+                                            isEdit: false,
+
+                                          },
+                                        ],
+                                      },
+                                    ],
+                                  };
+                                  userDetails = await userService.create( data );
+                                }
+                                let data = {
+                                  store_id: store?.storeId,
+                                  storeName: store?.storeName,
+                                  userId: userDetails._id,
+                                  userName: userDetails.userName,
+                                  userEmail: userDetails.email,
+                                  userPhone: userDetails?.mobileNumber,
+                                  city: store?.storeProfile?.city,
+                                  country: store?.storeProfile?.country,
+                                  checkFlag: true,
+                                  checkListId: getCLconfig._id,
+                                  checkListName: getCLconfig.checkListName,
+                                  client_id: getCLconfig.client_id,
+                                };
+                                return data;
+                              } ) );
+                            }
+                          }
+                        }
+                        allQuestion = allQuestion.filter( ( ele ) => !clusterList.includes( ele.assignId ) );
+                      }
+                      if ( getCLconfig.coverage == 'user' ) {
+                        let teamsList = allQuestion.filter( ( ele ) => ele?.teamName ).map( ( item ) => item.assignId );
+                        if ( teamsList.length ) {
+                          let teamDetails = await teamsServices.findteams( { _id: { $in: teamsList } } );
+                          if ( teamDetails.length ) {
+                            let idList = [ ...teamDetails.flatMap( ( item ) => item.users.map( ( ele ) => ele.userId ) ), ...teamDetails.flatMap( ( item ) => item.Teamlead.map( ( ele ) => ele.userId ) ) ];
+                            let getUserDetails = await userService.find( { _id: { $in: idList } } );
+                            if ( getUserDetails.length ) {
+                              assignList = getUserDetails.map( ( user ) => {
+                                let data = {
+                                  store_id: '',
+                                  storeName: '',
+                                  userId: user._id,
+                                  userName: user.userName,
+                                  userEmail: user.email,
+                                  userPhone: user?.mobileNumber,
+                                  city: '',
+                                  country: '',
+                                  checkFlag: true,
+                                  checkListId: getCLconfig._id,
+                                  checkListName: getCLconfig.checkListName,
+                                  client_id: getCLconfig.client_id,
+                                };
+                                return data;
+                              } );
+                            }
+                          }
+                        }
+                        allQuestion = allQuestion.filter( ( ele ) => !teamsList.includes( ele.assignId ) );
+                      }
+                      allQuestion = [ ...allQuestion, ...assignList ];
+                      let userIdList = [];
+                      for ( let element4 of allQuestion ) {
+                        if ( getCLconfig.allowOnce && ![ 'onetime', 'daily' ].includes( getCLconfig.schedule ) ) {
+                          let query;
+                          if ( [ 'weekday', 'weekly', 'monthly' ].includes( getCLconfig.schedule ) ) {
+                            let startDate; let endDate;
+                            if ( [ 'weekday', 'weekly' ].includes( getCLconfig.schedule ) ) {
+                              startDate = dayjs.utc( currentdate ).clone().startOf( 'week' );
+                              endDate = dayjs.utc( currentdate ).clone().endOf( 'week' );
+                            } else {
+                              startDate = dayjs.utc( currentdate ).clone().startOf( 'month' );
+                              endDate = dayjs.utc( currentdate ).clone().endOf( 'month' );
+                            }
+                            query = {
+                              sourceCheckList_id: getCLconfig._id,
+                              $or: [ {
+                                checklistStatus: { $in: [ 'submit' ] } },
+                              { submitTime: { $exists: true } },
+                              ],
+                              userId: element4.userId,
+                              store_id: element4.store_id,
+                              $and: [ {
+                                date_iso: {
+                                  $gte: new Date( startDate.format( 'YYYY-MM-DD' ) ),
+                                  $lte: new Date( endDate.format( 'YYYY-MM-DD' ) ) },
+                              } ],
+                            };
+                          } else {
+                            query = {
+                              sourceCheckList_id: getCLconfig._id,
+                              $or: [ {
+                                checklistStatus: { $in: [ 'submit' ] } },
+                              { submitTime: { $exists: true } },
+                              ],
+                              userId: element4.userId,
+                              store_id: element4.store_id,
+                              $and: [ {
+                                date_iso: {
+                                  $gte: new Date( dayjs( getCLconfig.configStartDate ).format( 'YYYY-MM-DD' ) ),
+                                  $lte: new Date( dayjs( getCLconfig.configEndDate ).format( 'YYYY-MM-DD' ) ) },
+                              } ],
+                            };
+                          }
+                          let getsubmitDetails = await processedchecklist.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.checkListDescription = getCLconfig.checkListDescription;
+                        element4.date_iso = new Date( currentdate );
+                        element4.date_string = currentdate;
+                        element4.allowedOverTime = getCLconfig.allowedOverTime;
+                        element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+                        element4.scheduleStartTime = getCLconfig.scheduleStartTime;
+                        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 = getCLconfig.scheduleRepeatedType;
+                        element4.approvalEnable = getCLconfig.approver.length ? true : false;
+                        element4.remainder = getCLconfig?.remainder || [];
+                        // if ( getCLconfig?.isPlano ) {
+                        //   let planoDetails = await planoService.findOne( { storeId: element4.store_id, clientId: getCLconfig.client_id }, { _id: 1 } );
+                        //   element4.planoId = planoDetails?._id;
+                        //   element4.isPlano = getCLconfig?.isPlano;
+                        // }
+                        element4.rawImageUpload = getCLconfig?.rawImageUpload || false;
+                      }
+                      if ( userIdList.length ) {
+                        allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
+                      }
+                      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' ] };
+                        // if (getCLconfig.scheduleRepeatedType == 'range') {
+                        //     allQuestion.forEach(async item => {
+                        //         assigndeletequery.userId = item.userId
+                        //         await processedchecklist.deleteMany(assigndeletequery);
+                        //         await processedchecklist.insertMany(item);
+                        //         logger.info({function:"PCLconfigCreation Range",query:assigndeletequery})
+                        //     })
+                        // }
+                        // else {
+                        await processedchecklist.deleteMany( assigndeletequery );
+                        logger.info( { checklistId: getCLconfig._id, insertedCount: allQuestion.length } );
+                        await processedchecklist.insertMany( allQuestion );
+                        logger.info( { function: 'PCLconfigCreation', query: assigndeletequery } );
+                      // }
+                      }
+                    } else {
+                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection' ].includes( getCLconfig.checkListType ) ) {
+                        let storeNameList = allQuestion.map( ( item ) => item.store_id );
+                        let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active', ...( [ 'storeopenandclose', 'mobileusagedetection', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) ? { storeId: { $in: storeNameList } } : {} }, { storeId: 1 } );
+                        let storeList = storeDetails.map( ( store ) => store.storeId );
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) {
+                          allQuestion = allQuestion.filter( ( ele ) => storeList.includes( ele?.store_id ) );
+                        } else {
+                          allQuestion = storeDetails.map( ( item ) => {
+                            return {
+                              store_id: item.storeId,
+                            };
+                          } );
+                        }
+                        let data = {
+                          checkListId: updatedchecklist._id,
+                          checkListName: getCLconfig.checkListName,
+                          date_iso: new Date( currentdate ),
+                          date_string: currentdate,
+                          allowedOverTime: getCLconfig.allowedOverTime,
+                          allowedStoreLocation: getCLconfig.allowedStoreLocation,
+                          checkListDescription: getCLconfig.checkListDescription,
+                          scheduleStartTime: getCLconfig.scheduleStartTime,
+                          scheduleStartTime_iso: startTimeIso.format(),
+                          scheduleEndTime: getCLconfig.scheduleEndTime,
+                          scheduleEndTime_iso: endTimeIso.format(),
+                          createdBy: new ObjectId( getCLconfig.createdBy ),
+                          createdByName: getCLconfig.createdByName,
+                          sourceCheckList_id: getCLconfig._id,
+                          checkListType: getCLconfig.checkListType,
+                          storeCount: getCLconfig.storeCount,
+                          questionCount: getCLconfig.questionCount,
+                          publishDate: getCLconfig.publishDate,
+                          locationCount: getCLconfig.locationCount,
+                          scheduleRepeatedType: getCLconfig.scheduleRepeatedType,
+                          storeCount: storeDetails.length,
+                          client_id: getCLconfig.client_id,
+                          aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => store.store_id ) : [],
+                        };
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) {
+                          let processData = {
+                            aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => {
+                              return { storeName: store.storeName, storeId: store.store_id, events: store.events };
+                            } ) : [],
+                            aiConfig: getCLconfig?.aiConfig,
+                          };
+                          await PCLconfig.updateOne( { _id: updatedchecklist._id }, processData );
+                        }
+                        await processedchecklist.updateOne( { date_string: currentdate, checkListId: updatedchecklist._id, sourceCheckList_id: getCLconfig._id, checkListType: getCLconfig.checkListType }, data );
+                      }
+                    }
+                  }
+                } else {
+                  alreadyExist.push( { sourceCheckList_id: insertdata.sourceCheckList_id, checkListName: insertdata.checkListName } );
+                }
+              }
+            }
+          } ) );
+        }
+
+        if ( dateIndex == 0 ) {
+          res.sendSuccess( { message: 'Processed Daily Check List Created Successfully', error: alreadyExist } );
+        }
       }
     }
   } catch ( e ) {
     logger.error( { function: 'PCLconfigCreation', error: e } );
-    return res.sendError( e, 500 );
+    // return res.sendError( e, 500 );/
   }
 };
 
@@ -304,7 +861,7 @@ async function insertData( requestData ) {
                 },
               } );
               let getSections = await CLquestions.aggregate( sectionQuery );
-              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) {
+              if ( getSections.length || [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection' ].includes( getCLconfig.checkListType ) ) {
                 if ( getSections.length ) {
                   for ( let element3 of getSections ) {
                     let collectQuestions = {};
@@ -342,7 +899,7 @@ async function insertData( requestData ) {
                       },
                     } );
                     let allQuestion = await CLassign.aggregate( getquestionQuery );
-                    if ( allQuestion.length ) {
+                    if ( allQuestion.length && getCLconfig.checkListType == 'custom' ) {
                       let assignList = [];
                       if ( getCLconfig.coverage == 'store' ) {
                         let clusterList = allQuestion.filter( ( ele ) => ele?.clusterName ).map( ( item ) => item.assignId );
@@ -597,8 +1154,19 @@ async function insertData( requestData ) {
                         // }
                       }
                     } else {
-                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) {
-                        let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active' }, { storeId: 1 } );
+                      if ( [ 'storeopenandclose', 'mobileusagedetection', 'uniformdetection', 'customerunattended', 'staffleftinthemiddle', 'eyetest', 'remoteoptometrist', 'storehygienemonitoring', 'queuealert', 'cleaning', 'scrum', 'suspiciousactivity', 'boxalert', 'suspiciousfootfall', 'drinking', 'bagdetection' ].includes( getCLconfig.checkListType ) ) {
+                        let storeNameList = allQuestion.map( ( item ) => item.store_id );
+                        let storeDetails = await storeService.find( { clientId: getCLconfig.client_id, status: 'active', ...( [ 'storeopenandclose', 'mobileusagedetection', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) ? { storeId: { $in: storeNameList } } : {} }, { storeId: 1 } );
+                        let storeList = storeDetails.map( ( store ) => store.storeId );
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) {
+                          allQuestion = allQuestion.filter( ( ele ) => storeList.includes( ele?.store_id ) );
+                        } else {
+                          allQuestion = storeDetails.map( ( item ) => {
+                            return {
+                              store_id: item.storeId,
+                            };
+                          } );
+                        }
                         let data = {
                           checkListId: updatedchecklist._id,
                           checkListName: getCLconfig.checkListName,
@@ -606,6 +1174,7 @@ async function insertData( requestData ) {
                           date_string: currentdate,
                           allowedOverTime: getCLconfig.allowedOverTime,
                           allowedStoreLocation: getCLconfig.allowedStoreLocation,
+                          checkListDescription: getCLconfig.checkListDescription,
                           scheduleStartTime: getCLconfig.scheduleStartTime,
                           scheduleStartTime_iso: startTimeIso.format(),
                           scheduleEndTime: getCLconfig.scheduleEndTime,
@@ -621,8 +1190,17 @@ async function insertData( requestData ) {
                           scheduleRepeatedType: getCLconfig.scheduleRepeatedType,
                           storeCount: storeDetails.length,
                           client_id: getCLconfig.client_id,
-                          aiStoreList: storeDetails ? storeDetails.map( ( store ) => store.storeId ) : [],
+                          aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => store.store_id ) : [],
                         };
+                        if ( [ 'storeopenandclose', 'mobileusagedetection', 'cleaning', 'scrum' ].includes( getCLconfig.checkListType ) ) {
+                          let processData = {
+                            aiStoreList: allQuestion.length ? allQuestion.map( ( store ) => {
+                              return { storeName: store.storeName, storeId: store.store_id, events: store.events };
+                            } ) : [],
+                            aiConfig: getCLconfig?.aiConfig,
+                          };
+                          await PCLconfig.updateOne( { _id: updatedchecklist._id }, processData );
+                        }
                         // await processedchecklist.create( data );
                         await processedchecklist.updateOne( { date_string: currentdate, checkListId: updatedchecklist._id, sourceCheckList_id: getCLconfig._id, checkListType: getCLconfig.checkListType }, data );
                       }
@@ -1433,6 +2011,37 @@ export async function getPDFCSVChecklistDetails( req, res ) {
 }
 
 
+export async function AiPushNotificationAlert( req, res ) {
+  try {
+    console.log( req.body );
+    let findAichecklist = await PCLconfig.findOne( { checkListType: req.body.checkListType, client_id: req.body.clientId, date_string: req.body.Date }, { aiConfig: 1 } );
+    if ( findAichecklist.aiConfig&&findAichecklist.aiConfig.alerts&&findAichecklist.aiConfig.alerts.users&&findAichecklist.aiConfig.alerts.users.length>0 ) {
+      console.log( findAichecklist.aiConfig.alerts.users );
+      for ( let user of findAichecklist.aiConfig.alerts.users ) {
+        let findOneUser = await userService.findOne( { email: user }, { fcmToken: 1 } );
+        console.log( findOneUser );
+        if ( findOneUser&&findOneUser.fcmToken&&findOneUser.fcmToken!='' ) {
+          console.log( findOneUser.fcmToken );
+          try {
+            await sendPushNotification( req.body.title, req.body.description, findOneUser.fcmToken );
+          } catch ( e ) {
+            logger.error( {
+              message: 'push notification',
+              error: e,
+              details: data,
+            } );
+          }
+        } ;
+      }
+      return res.sendSuccess( 'Push notification send successfully' );
+    }
+  } catch ( e ) {
+    logger.error( { function: 'AiPushNotificationAlert', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
 export async function taskPushNotification( req, res ) {
   try {
     let query = [ {
@@ -1644,3 +2253,59 @@ async function getUserToken( clientId, userEmail ) {
     return false;
   }
 }
+
+export async function internalAISendPushNotification( req, res ) {
+  try {
+    let requestData = req.body;
+    // if ( !requestData.clientId ) {
+    //   return res.sendError( 'clientId is Required', 400 );
+    // }
+    if ( !( requestData?.email || requestData?.storeId ) ) {
+      return res.sendError( 'Email or StoreId is Required', 400 );
+    }
+
+    if ( !requestData.title ) {
+      return res.sendError( 'Title is Required', 400 );
+    }
+
+    if ( !requestData.description ) {
+      return res.sendError( 'Description is Required', 400 );
+    }
+
+    let userData;
+    if ( requestData.email && requestData.email !='' ) {
+      // fcmToken = await getUserToken( requestData.clientId, requestData.email );
+      // userData = await userService.findOne( { clientId: requestData.clientId, email: requestData.email }, { fcmToken: 1, loginFrom: 1 } );
+      userData = await userService.findOne( { email: requestData.email }, { fcmToken: 1, loginFrom: 1 } );
+    } else {
+      // let storeData = await storeService.findOne( { clientId: requestData.clientId, storeId: requestData.storeId }, { spocDetails: 1 } );
+      let storeData = await storeService.findOne( { storeId: requestData.storeId }, { spocDetails: 1 } );
+      if ( storeData && storeData.spocDetails.length > 0 && storeData.spocDetails[0].email ) {
+        // fcmToken = await getUserToken( storeData.spocDetails[0].email );
+        // userData = await userService.findOne( { clientId: requestData.clientId, email: requestData.email }, { fcmToken: 1, loginFrom: 1 } );
+        userData = await userService.findOne( { email: requestData.email }, { fcmToken: 1, loginFrom: 1 } );
+      }
+    }
+    if ( !userData ) {
+      return res.sendSuccess( 'Notification Send Successfully' );
+    }
+    let custom = {
+      title: requestData.title,
+      body: requestData.description,
+      type: req.body?.type,
+      storeId: req.body?.storeId,
+      date: req.body?.date,
+      clientId: req.body?.clientId,
+    };
+    let responseData = await sendAiPushNotification( userData.fcmToken, custom, userData.loginFrom );
+    if ( responseData ) {
+      return res.sendSuccess( 'Notification Send Successfully' );
+    } else {
+      return res.sendSuccess( 'Notification Send Successfully' );
+    }
+  } catch ( e ) {
+    logger.error( { error: e, function: 'internalAISendPushNotification' } );
+    if ( e.name === 'ValidationError' ) res.sendBadRequest( e );
+    else res.sendError( e, 500 );
+  }
+};