[
    {
        "$match": {
            "authorization": {
                "$ne": null
            }
        }
    },
    {
        "$match": {
            "email": {
                "$not": {
                    "$regularExpression": {
                        "pattern": "deleted",
                        "options": ""
                    }
                }
            }
        }
    },
 
    {
        "$lookup": {
            "from": "participant",
            "localField": "email",
            "foreignField": "email",
            "as": "userParticipant"
        }
    },
    {
        "$match": {}
    },
    {
        "$lookup": {
            "from": "masterSlot",
            "localField": "userParticipant._id",
            "foreignField": "navigatorId",
            "as": "slots"
        }
    },
    {
        "$lookup": {
            "from": "userCoachMapping",
            "localField": "userParticipant._id",
            "foreignField": "coachID",
            "as": "userCoachMapping"
        }
    },
    {
        "$project": {
        
            "isCoachActive": {
                "$arrayElemAt": [
                    "$userParticipant.active",
                    0
                ]
            },
        
            "email": {
                "$arrayElemAt": [
                    "$userParticipant.email",
                    0
                ]
            },
            "firstName": {
                "$arrayElemAt": [
                    "$userParticipant.firstName",
                    0
                ]
            },
            "coachProfileDescription": {
                "$arrayElemAt": [
                    "$userParticipant.coachProfileDescription",
                    0
                ]
            },
    
            "middleName": {
                "$arrayElemAt": [
                    "$userParticipant.middleName",
                    0
                ]
            },
            "lastName": {
                "$arrayElemAt": [
                    "$userParticipant.lastName",
                    0
                ]
            },
            "partnerShortCode": {
                "$arrayElemAt": [
                    "$userParticipant.partnerShortCode",
                    0
                ]
            },
    
            "role": {
                "$arrayElemAt": [
                    "$userParticipant.role",
                    0
                ]
            },
            "templateName": "$authorization.name",
            "servicePartnerShortCode": "$servicePartnerShortCode",
            "userVisibility": "$userVisibility",
    
            "Total Users": {
                "$size": {
                    "$filter": {
                        "input": "$userCoachMapping",
                        "as": "coach",
                        "cond": { "$eq": ["$$coach.userStatus", "ACTIVE"] }
                    }
                }
            }
            _id:0
        }
    },
    {
        $match:{
            "Total Users": { "$gt": 0 }
        }
    }
]

//show images
docker images

//show volumes
docker volume ls


//run docker container from image with attachd volume
//mongodb_dm - volume name
//mongo - container name
docker run -d --name mongo -v mongodb_dm:/data/db -p 27017:27017 mongo:latest

[
    {
        "$match": {
            "startDate": {
                "$gte": {
                    "$date": "2018-03-12T03:26:21.997Z"
                },
                "$lte": {
                    "$date": "2024-03-10T04:50:35Z"
                }
            }
        }
    },
    {
        "$lookup": {
            "from": "participant",
            "localField": "userId",
            "foreignField": "_id",
            "as": "participantData"
        }
    },
    {
        "$unwind": "$participantData"
    },
    {
        "$match": {
            "participantData.email": {
                "$regularExpression": {
                    "pattern": "@jiva.user",
                    "options": ""
                }
            }
        }
    },
    {
        "$match": {
            "participantData.userStatus": {
                "$ne": "TEST"
            }
        }
    },
    {
        "$match": {
            "$and": [
                {
                    "participantData.email": {
                        "$not": {
                            "$regularExpression": {
                                "pattern": "deleted",
                                "options": ""
                            }
                        }
                    }
                },
                {
                    "participantData.email": {
                        "$not": {
                            "$regularExpression": {
                                "pattern": "@smit\\.fit$",
                                "options": ""
                            }
                        }
                    }
                }
            ]
        }
    },
    {
        "$lookup": {
            "from": "participantBaselineAndFollowupData",
            "localField": "userId",
            "foreignField": "participantId",
            "as": "baselineData"
        }
    },
    {
        "$unwind": "$baselineData"
    },
    {
        "$lookup": {
            "from": "blood_glucose",
            "localField": "userId",
            "foreignField": "participantId",
            "as": "glucoseData"
        }
    },
    {
        "$unwind": "$glucoseData\", \"preserveNullAndEmptyArrays\" : true}"
    },
    {
        "$project": {
            "subscriptionId": "$_id",
            "baselineId": "$baselineData._id",
            "userId": 1,
            "startDate": 1,
            "programStartDate": "$baselineData.programStartDate",
            "planCode1": "$subscriptionPlan.programCode",
            "journeyStatus": "$journeyTrackerObject.status",
            "planCode2": "$baselineData.programCode",
            "followUps": "$baselineData.followUps",
            "glucoseData": 1
        }
    },
    {
        "$match": {
            "$and": [
                {
                    "$expr": {
                        "$and": [
                            {
                                "$eq": [
                                    "$planCode1",
                                    "$planCode2"
                                ]
                            },
                            {
                                "$eq": [
                                    "$startDate",
                                    "$programStartDate"
                                ]
                            }
                        ]
                    }
                }
            ]
        }
    },
    {
        "$group": {
            "_id": {
                "userId": "$userId",
                "startDate": "$startDate",
                "planCode1": "$planCode1"
            },
            "userId": {
                "$last": "$userId"
            },
            "baselineId": {
                "$last": "$baselineId"
            },
            "startDate": {
                "$last": "$startDate"
            },
            "programStartDate": {
                "$last": "$programStartDate"
            },
            "subscriptionId": {
                "$last": "$subscriptionId"
            },
            "journeyStatus": {
                "$last": "$journeyStatus"
            },
            "followUps": {
                "$last": "$followUps"
            },
            "glucoseData": {
                "$push": "$glucoseData"
            }
        }
    },
    {
        "$project": {
            "userId": 1,
            "baselineId": 1,
            "startDate": 1,
            "programStartDate": 1,
            "subscriptionId": 1,
            "journeyStatus": 1,
            "followUps": 1,
            "field": {
                "$add": [
                    "$_id.startDate",
                    {
                        "$multiply": [
                            14,
                            24,
                            60,
                            60,
                            1000
                        ]
                    }
                ]
            },
            "glucoseData": {
                "$filter": {
                    "input": "$glucoseData",
                    "as": "glucose",
                    "cond": {
                        "$and": [
                            {
                                "$lt": [
                                    "$$glucose.date",
                                    {
                                        "$add": [
                                            "$_id.startDate",
                                            {
                                                "$multiply": [
                                                    14,
                                                    24,
                                                    60,
                                                    60,
                                                    1000
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "$gte": [
                                    "$$glucose.date",
                                    "$_id.startDate"
                                ]
                            }
                        ]
                    }
                }
            }
        }
    },
    {
        "$project": {
            "userId": 1,
            "baselineId": 1,
            "startDate": 1,
            "programStartDate": 1,
            "subscriptionId": 1,
            "journeyStatus": 1,
            "followUps": 1,
            "glucoseData": {
                "$map": {
                    "input": "$glucoseData",
                    "as": "obj",
                    "in": {
                        "participantId": "$$obj.participantId",
                        "reading": "$$obj.reading",
                        "date": "$$obj.date"
                    }
                }
            }
        }
    }
]

[
    {
        "$match": {
            "participantId": ObjectId("6481b5f27050063532a46021")
        }
    },
    {
        "$match": {
            "date": { "$gt": { "$add": [ISODate("2023-06-01T00:00:00.000Z"), { "$multiply": [14, 24, 60, 60, 1000] }] } }
        }
    }
]

db.participantDietMealPlanDetails.updateMany({
    "mealPlan.dishVariation": "Milkshake",
	"_id":ObjectId("60d4258c4adb9a4b6fe4d99b")
},
    {
    $set: {
        "mealPlan.$[elem].dishVariation": "Milkshake",
        "mealPlan.$[elem].dishVariationId":  "660ea659e1645e032a289770",
        "mealPlan.$[elem].sizes": [{
                "calories": {
                    "value": "184",
                    "unit": "kcal"
                },
                "cookedWeight": "200",
                "name": "Medium Glass",
                "fat": {
                    "value": "5.0",
                    "unit": "gms"
                },
                "calcium": {
                    "value": "0.0",
                    "unit": "mg"
                },
                "iron": {
                    "value": "0.0",
                    "unit": "mg"
                },
                "fibre": {
                    "value": "0.0",
                    "unit": "mg"
                },
                "sodium": {
                    "value": "0.0",
                    "unit": "mg"
                },
                "sugars": {
                    "value": "0.0",
                    "unit": "mg"
                },
                "protein": {
                    "value": "4.7",
                    "unit": "gms"
                },
                "carbs": {
                    "value": "30.4",
                    "unit": "gms"
                }
            }
        ]

    }
}, {
    arrayFilters: [{
            "elem.dishVariation": "Milkshake"
        }
    ]
})

[
    {
        "$match": {
            "$expr": {
                "$ne": ["$foodStatus", "APPROVED"]
            }
        }
    },
    {
        "$lookup": {
            "from": "mastermealplan",
            "localField": "dishVariation",
            "foreignField": "mealPlan.dishVariation",
            "as": "mealData"
        }
    },
    {
        "$match": {
            "$expr": {
                "$gt": [{ "$size": "$mealData" }, 0]
            }
        }
    },
    {
        "$project": {
            "mealData": "$mealData.planName",
            "dishVariation": 1
        }
    }
]

[
    {
        "$match": {
            "partnerShortCode": {
                "$in": []
            }
        }
    },
    {
        "$group": {
            "_id": "$partnerShortCode",
            "clinics": {
                "$push": {
                    "clinicName": "$name",
                    "clinicId": "$_id"
                }
            }
        }
    },
    {
        "$project": {
            _id:0,
            "partnerShortCode": "$_id",
            "clinics": 1
        }
    }
]

[
  {
    $match: {
  $and: [
    { "age": { $type: "string" } },
    { $expr: { $gt: [{ $strLenCP: "$age" }, 5] } }
  ]
}
  },
    {
      $project: {
        email:1
      
    }
    }
  
]

[
    {
        $group: {
            _id: "$participantId",
            documents: { $push: "$$ROOT" },
            count: { $sum: 1 }
        }
    },
    {
        $match: {
            count: { $gt: 1 }
        }
    },
    {
        $unwind: "$documents"
    },
    {
        $match: {
            "documents.programCode": { $ne: "" }
        }
    },
    {
        $group: {
            _id: {
                participantId: "$_id",
                programCode: "$documents.programCode",
                programStartDate: "$documents.programStartDate"
            },
            baselineId: { $first: "$_id" },
            documentIds: { $push: "$documents._id" }, 
            documents: { $push: "$documents" },
            count: { $sum: 1 }
        }
    },
    {
        $match: {
            count: { $gt: 1 }
        }
    },
    {
        $project: {
            _id: 1,
            participantId: "$_id.participantId",
            programCode: "$_id.programCode",
            programStartDate: "$_id.programStartDate",
            baselineId: 1,
            documentIds: 1 
        }
    },
    {
        $lookup: {
            "from": "participant",
            "localField": "participantId",
            "foreignField": "_id",
            "as": "temp"
        }
    },
    {
        $match: {
            "temp.userStatus": { $ne: "TEST" },
            $and: [
                { "temp.email": { $nin: [/deleted/] } },
                { "temp": { $ne: null } }
            ]
        }
    },
    {
        $unwind:"$documentIds"
    }
    {
        $project: {
            _id:0
            "participantId": { $arrayElemAt: ["$temp._id", 0] },
            "email": { $arrayElemAt: ["$temp.email", 0] },
            "documentIds": 1 
        }
    }
]

[
    {
        $group: {
            _id: "$participantId",
            documents: { $push: "$$ROOT" },
            count: { $sum: 1 }
        }
    },
    {
        $match: {
            count: { $gt: 1 }
        }
    },
    {
        $unwind: "$documents"
    },
    {
        $match: {
            "documents.programCode": { $ne: "" }
        }
    },
    {
        $group: {
            _id: {
                participantId: "$_id",
                programCode: "$documents.programCode",
                programStartDate: "$documents.programStartDate"
            },
            documents: { $push: "$documents" },
            count: { $sum: 1 }
        }
    },
    {
        $match: {
            count: { $gt: 1 }
        }
    },
    {
        $project: {
            _id: 0,
            participantId: "$_id.participantId",
            programCode: "$_id.programCode",
            programStartDate: "$_id.programStartDate"
        }
    },
    {
        $lookup: {
            "from": "participant",
            "localField": "participantId",
            "foreignField": "_id",
            "as": "temp"
        }
    },
    {
        $match: {
            "temp.userStatus": { $ne: "TEST" }
        }
    },
    {
        $project: {
            "id":{ $arrayElemAt: ["$temp._id", 0] }
            "email": { $arrayElemAt: ["$temp.email", 0] }
        }
    }
]

[
    {
      "$lookup": {
        "from": "Assessment",
        "localField": "assessmentId",
        "foreignField": "_id",
        "as": "assessment"
      }
    },
    {
      "$unwind": {
        "path": "$assessment",
        "preserveNullAndEmptyArrays": true
      }
    },
    {
      "$match": {
        "$and": [
          {
            "assessmentId": {
              "$oid": "622072b1aaeb4e5955319304"
            },
            "endCode": {
              "$ne": ""
            }
          }
        ]
      }
    },
   {
  "$project": {
    "_id": 1,
    "name": {
      "$cond": {
        "if": { "$ifNull": ["$assessmentType", false] },
        "then": "$assessmentType",
        "else": "IDRS"
      }
    },
    "assessmentId": "$_id",
    "ok": "$assessment.type",
    "createdAt": 1
  }
}
,
   {
      "$sort": {
        "createdAt": -1
      }
    }

  ]

const query = {}; // Your query conditions go here

const [resultData, totalCount] = await Promise.all([
  User.find(query)
    .skip((page - 1) * limit)
    .limit(limit),

  User.countDocuments(query),
]);

console.log(resultData);
console.log(totalCount);

/* 
`mongoose.connect` is used to establish a connection to a MongoDB database, while `mongoose.connection` provides access to the active connection and allows you to interact with the database through events and operations.
*/
// see all the methods (https://mongoosejs.com/docs/api/connection.html)

const database = mongoose.connection;
// dbname
database.useDb("users");
// collection name
const collection = database.collection("users");

db.cities.aggregate([
  { "$project": { "id_city": { "$toString": "$_id" } } }, //combiente a string los ObjectIds
  { "$lookup": {
    "localField": "id_city",
    "from": "itineraries",
    "foreignField": "cityID",
 as: "matching_docs"
    }
  },
  {
    $match: {
      matching_docs: { $ne: [] } // Filtrar documentos que tienen coincidencias
    }
  }
])

db.cities.findOne({_id:ObjectId("64a47c1447972c5696cb0765")})
  
   db.cities.updateMany(
  {_id:ObjectId("64a47c1447972c5696cb0765")}, // Filtro vacío para actualizar todos los documentos
  {
    $pull: {
      "itineraries": "64efc056590b86b1be2cdd1e"
    }
  }
)
   db.cities.updateMany(
  {_id:ObjectId("64a47c1447972c5696cb0765")}, // Filtro vacío para actualizar todos los documentos
  {
    $push: {
      "itineraries": "64efc056590b86b1be2cdd1e"
    }
  }
)
   db.getCollection("cities").updateMany({_id:ObjectId("64a47c1447972c5696cb0765")},
{$push:{"itineraries":"64efc056590b86b1be2cdd1e"}})

use('myworlddb')

//{} empty fetches all documents
db.person.deleteMany({name:"hemanth"})

use('myworlddb')
 
//{} empty fetches all documents
db.person.deleteOne({name:"hemanth"})

use('myworlddb')

//{} empty fetches all documents
db.person.updateMany({age:{$lt:30}},{
  $set:{age: 1}
})

use('myworlddb')
 
//{} empty fetches all documents
db.person.updateOne({name:"hemanth"},{
  $set:{age: 28}
})

use('myworlddb')
 
//{} empty fetches all documents
db.person.find({name:"naveen"})

import graphql.kickstart.tools.GraphQLQueryResolver
import me.stegall.personalwebsiteapi3.models.Project
import me.stegall.personalwebsiteapi3.repositories.ProjectRepository
import org.springframework.data.mongodb.core.MongoOperations
import org.springframework.stereotype.Component

@Component
class ProjectQueryResolver(
  val projectRepository: ProjectRepository,
  private val mongoOperations: MongoOperations
) : GraphQLQueryResolver {
  fun projects(): List<Project> {
    return projectRepository.findAll()
  }
}

import me.stegall.personalwebsiteapi3.models.Project
import org.springframework.data.mongodb.repository.MongoRepository
import org.springframework.stereotype.Repository

@Repository
interface ProjectRepository : MongoRepository<Project, String>

use personal-website;

db.projects.insertMany([
  {
    "description": "This was my first major programming project that I ever saw through from start to finish. It's an emulator I wrote during the sophomore year of my undergrad. This was done so I could have a better understanding of emulation and basic hardware principles. Looking back now, it really lacks some understanding of useful C++ features and proper formatting, as well as typical C++ programming style. Regardless, I found it to be a very informative project that I learned quite a lot from.",
    "title": "SDL-CHIP8",
    "url": "https://gitlab.stegall.me/swstegall/SDL-CHIP8"
  },
  {
    "description": "Notflix was an application that I made for a class in my Master's to demonstrate my ability to create an application to consume an API using ASP.NET MVC. What it does is utilize a movie database API to give random movie suggestions over different genres. I thought my result at the end looked quite nice, given some of the constraints I dealt with in the original assignment.",
    "title": "Notflix",
    "url": "https://gitlab.stegall.me/swstegall/Notflix"
  },
  {
    "description": "This was an application I made for EarthX Hack 2020. It was inspired by the toilet paper shortage caused by the coronavirus pandemic of 2020. The idea for this app is to list goods that you have, that you wish to trade for other goods. It would allow people to accept a trade offer and a meeting location to exchange items, and cut down on over-consumption in the face of scarcity.",
    "title": "Green Trade",
    "url": "https://gitlab.stegall.me/swstegall/green-trade"
  },
  {
    "description": "Orpheus was my first attempt writing a GUI application with conventional tooling for Windows. It is a relatively lightweight C# music player application that manages its library based on a JSON file. I think the application works decently for the short amount of time I had to learn .NET beforehand, but that the theming component of the application, as well as some more advanced functionality, could be further enhanced. Perhaps I'll tackle a similar type of project in the future once Microsoft finishes their rollout of .NET MAUI.",
    "title": "Orpheus",
    "url": "https://gitlab.stegall.me/swstegall/Orpheus"
  },
  {
    "description": "This was a project I did for TAMUhack 2021 at the beginning of the year. This was my first attempt at a mobile app, and it used React Native, React Native Elements, and JavaScript for the frontend, and Node/Express/Sequelize/TypeScript on the backend, with a database managed with Docker. This was an interesting app, because it made use of barcode scanning to manage some gamification elements.",
    "title": "GOTcha",
    "url": "https://gitlab.stegall.me/swstegall/GOTcha"
  },
  {
    "description": "This project is a chat application that I made to allow for privately-hosted servers. It uses Material UI/React/Redux/TypeScript on the frontend, and Node/Express/Sequelize/TypeScript on the backend with a PostgreSQL database managed with Docker.",
    "title": "Trueno",
    "url": "https://gitlab.stegall.me/swstegall/trueno"
  },
  {
    "description": "This was a hackathon project I did with some friends for Hack-O-Lantern 2021. It's a Course Management Website that supports class creation, registration, and (some) file submission. It was a lot of fun to work on and shows some promise!",
    "title": "Class++",
    "url": "https://gitlab.stegall.me/swstegall/class-plus-plus"
  }
]);

db.timetable.updateMany(
   {},
   { $rename: { 'Train No': 'trainNo', 'Train Name': 'trainName', 'SEQ':'seq', 'Station Code':'stationCode', 'Station Name': 'stationName', 'Arrival time':'arrivalTime', 'Departure Time':'departureTime', 'Distance':'distance', 'Source Station':'sourceStation','Source Station Name':'sourceStationName', 'Destination Station':'destinationStation','Destination Station Name':'destinationStationName'  } }
)

const VoteSchema = new Schema({
  value: Boolean,
  obj: String,
  kind: String,
  user: String,
  voted: String
});

const PostSchema = new Schema({
  title: String
});

var virtual = PostSchema.virtual('voted', {
  ref: 'Vote',
  localField: '_id',
  foreignField: 'obj',
  justOne: true,
});

virtual.getters.unshift(v => !!v);

const Vote = mongoose.model('Vote', VoteSchema);
const Post = mongoose.model('Post', PostSchema);

co(function * () {
    // create post
  const post = new Post({
    title: 'post-1'
  });

  // create vote
  const vote = new Vote({
    value: true,
    obj: post.id,
    kind: Post.modelName,
    user: 'uid:1'
  });

  // store models to db
  yield [
    post.save(),
    vote.save()
  ];

  // populate related votes
  const r = yield Post.findById(post._id)
    .populate({path: 'voted', match: {user: 'uid:1', kind: Post.modelName}});

  console.log('r', r.toObject({ virtuals: true }));
  console.log(r.voted);
});

userSchema.pre('find', function (next) {
  if (this.options._recursed) {
    return next();
  }
  this.populate({ path: "followers following", options: { _recursed: true } });
  next();
});

db.Order.aggregate([
    { '$match'    : { "company_id" : ObjectId("54c0...") } },
    { '$sort'     : { 'order_number' : -1 } },
    { '$facet'    : {
        metadata: [ { $count: "total" }, { $addFields: { page: NumberInt(3) } } ],
        data: [ { $skip: 20 }, { $limit: 10 } ] // add projection here wish you re-shape the docs
    } }
] )

  const filteredData = datas[0].PostOffice.map(({ Name, State }) => {
    return { Name, State };
  });

db.customers.find({}).forEach(function (ch){db.customers.updateMany({},{$set:{"contact":ch.contact.toString()}})});

// require mongoose
const mongoose = require('mongoose');
// require config file to access mongoURI 
const config = require('config');
// make our db the mongoURI
const db = config.get('mongoURI');

const connectDB = async () => {
    try {
       await mongoose.connect(db, {
            useNewUrlParser: true,
            useCreateIndex: true,
            useUnifiedTopology: true,
            useFindAndModify: false
        })
        console.log('mongo db connected')
    } catch (err) {
        console.error(err)
        //exit with failure
        process.exit(1)
    }
}

module.exports = connectDB;

const getSourcesData = asyncHandler(async (req, res) => {
  const { dealership } = req.user;
  const month = parseInt(req.params.month);
  const customerData = await Customer.aggregate()
    .match({ dealership })
    .facet({
      fbCount: [
        {
          $match: {
            sourceOfEnquiry: "Facebook",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "fbCount" },
      ],
      googleCount: [
        {
          $match: {
            sourceOfEnquiry: "Google",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },

        { $count: "googleCount" },
      ],
      cardekhoCount: [
        {
          $match: {
            sourceOfEnquiry: "Cardekho",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "cardekhoCount" },
      ],
      carwaleCount: [
        {
          $match: {
            sourceOfEnquiry: "Carwale",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "carwaleCount" },
      ],
      instagramCount: [
        {
          $match: {
            sourceOfEnquiry: "Instagram",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "instagramCount" },
      ],
      newspaperAdsCount: [
        {
          $match: {
            sourceOfEnquiry: "Newspaper Ads",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "newspaperAdsCount" },
      ],
      websiteCount: [
        {
          $match: {
            sourceOfEnquiry: "Website",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "websiteCount" },
      ],
      hoardingsCount: [
        {
          $match: {
            sourceOfEnquiry: "Hoardings",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "hoardingsCount" },
      ],
      telephonicCount: [
        {
          $match: {
            sourceOfEnquiry: "Telephonic",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "telephonicCount" },
      ],
      referralCount: [
        {
          $match: {
            sourceOfEnquiry: "Referral",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "referralCount" },
      ],
      workshopCount: [
        {
          $match: {
            sourceOfEnquiry: "Workshop",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "workshopCount" },
      ],
      bushfireCount: [
        {
          $match: {
            sourceOfEnquiry: "Bushfire",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "bushfireCount" },
      ],
      managementCount: [
        {
          $match: {
            sourceOfEnquiry: "Management",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "managementCount" },
      ],
      walkInCount: [
        {
          $match: {
            sourceOfEnquiry: "Walk-in",
            $expr: { $eq: [{ $month: "$createdAt" }, month] },
          },
        },
        { $count: "walkInCount" },
      ],
    });
  

  return res.status(200).json({
    success: true,
    tableData: customerData,
  });
});

{
  sourceOfEnquiry:'Telephonic',
    createdAt: {
        $gte: ISODate("2021-06-01T00:00:00.000Z"),
        $lte: ISODate("2021-06-30T00:00:00.000Z")
    }
}

db.users.updateMany(
  { __t: "SE" },
  {
    $set: {
      targets: [
        {
          modelName: "rapid",
          targetCount: 15,
          bookingCount: 0,
          deliveredCount: 0,
        },
        {
          modelName: "superb",
          targetCount: 10,
          bookingCount: 0,
          deliveredCount: 0,
        },
        {
          modelName: "kushaq",
          targetCount: 5,
          bookingCount: 0,
          deliveredCount: 0,
        },
        {
          modelName: "octavia",
          targetCount: 0,
          bookingCount: 0,
          deliveredCount: 0,
        },
      ],
    },
  }
);

// create a schema
const eventSchema = new Schema({
  name: String,
  slug: {
    type: String,
    unique: true
  },
  description: String
});

// create the model
const eventModel = mongoose.model('Event', eventSchema);

// middleware -----
// make sure that the slug is created from the name
eventSchema.pre('save', function(next) {
  this.slug = slugify(this.name);
  next();
});

// function to slugify a name
function slugify(text) {
  return text.toString().toLowerCase()
    .replace(/\s+/g, '-')           // Replace spaces with -
    .replace(/[^\w\-]+/g, '')       // Remove all non-word chars
    .replace(/\-\-+/g, '-')         // Replace multiple - with single -
    .replace(/^-+/, '')             // Trim - from start of text
    .replace(/-+$/, '');            // Trim - from end of text
}

const dateFilter = asyncHandler(async (req, res) => {
  const month = 7;
  const day = 13;
  const feedbacks = await Feedback.find({
    $expr: {
      $or: [
        {
          $and: [
            { $eq: [{ $month: "$birthday" }, month] },
            { $eq: [{ $dayOfMonth: "$birthday" }, day] },
          ],
        },
        {
          $and: [
            { $eq: [{ $month: "$anniversary" }, month] },
            { $eq: [{ $dayOfMonth: "$anniversary" }, day] },
          ],
        },
      ],
    },
  });
  res.send(feedbacks);
});

const dateFilter = asyncHandler(async (req, res) => {
  const month = 6;
  const day = 10;
  const feedbacks = await Feedback.find({
    $expr: {
      $or: [
        {
          $eq: [{ $month: "$birthday" }, month],
          $eq: [{ $dayOfMonth: "$birthday" }, day],
        },
        {
          $eq: [{ $month: "$anniversary" }, month],
          $eq: [{ $dayOfMonth: "$anniversary" }, day],
        },
      ],
    },
  });
  console.log({ feedbacks });
});

const mongoose = require('mongoose');

const server = '127.0.0.1:27017'; // REPLACE WITH YOUR OWN SERVER
const database = 'test';          // REPLACE WITH YOUR OWN DB NAME

const connectDB = async () => {
    try {
        await mongoose.connect(`mongodb://${server}/${database}`, {
            useNewUrlParser: true,
            useUnifiedTopology: true,
            useFindAndModify: false,
            useCreateIndex: true
        });

        console.log('MongoDB connected!!');
    } catch (err) {
        console.log('Failed to connect to MongoDB', err);
    }
};

connectDB();

const bookingNumber = `${_.upperCase(modelName)}${_.random(1000000, 9999999)}

const updateStatus = asyncHandler(async (req, res) => {
  console.log("k");
  const { customer, stageFiveId, availableLoansId, status } = req.body;
  console.log(req.body);
  const customerData = await Customer.updateMany(
    {
      _id: customer,
    },
    // db.coll.update({}, {$set: {“a.$[i].c.$[j].d”: 2}}, {arrayFilters: [{“i.b”: 0}, {“j.d”: 0}]})
    {
      $set: { "stage5.$[i].availableLoans.$[j].status": status },
    },
    { arrayFilters: [{ "i._id": stageFiveId }, { "j._id": availableLoansId }] }
  );
  console.log(customerData);
  if (customerData)
    return res.status(200).json({
      success: true,
      message: "Status updated sucessfully!",
    });
  else
    return res.status(400).json({
      success: false,
      message: "Could not able to update Status!",
    });
});

db.customers.updateMany({}, {$unset:{"customerName":1}})

db.customers.updateMany({}, {$unset:{"customerName":1}})

db.customers.updateMany({},
  [{ $set : { n : {$arrayElemAt:[{ $split: ["$customerName", " "] },1]}} }],

);

db.customers.updateMany({},
  [{ $set : { m : {$arrayElemAt:[{ $split: ["$customerName", " "] },0]}} }],

);

   var Person = mongoose.model('Person', yourSchema);
   // find each person with a name contains 'Ghost'
   Person.findOne({ "name" : { $regex: /Ghost/, $options: 'i' } },
          function (err, person) {
                 if (err) return handleError(err);
                 console.log('%s %s is a %s.', person.name.first, person.name.last, person.occupation);

   });