tuain-ecosystem-lib/config/db-queries/users.js

Servicio de gestión mensajería instantanea de la plataforma Tuain

const { ObjectId } = require('mongodb');
const { userGroups, userGroupMembers, users } = require('../collections');
const { findByName, findById, updateObj, findByAttributes } = require('./common');

function findByUserId(userId) {
  return { userId: ObjectId(userId) };
}

function removeStoreFromUser(storeId) {
  return { $pull: { stores: { storeId } } };
}

function removeStoresFromUser() {
  return { $unset: { stores: '' } };
}

function insertUserRelation(userId, thirdPartyId, storeId, storeType) {
  return {
    userId: ObjectId(userId),
    thirdPartyId: ObjectId(thirdPartyId),
    stores: [{ storeId, storeType }],
  };
}

function findGroup(owner, name, groupType = null) {
  const ownerId = ObjectId(owner);
  const queryObject = { ownerId, name };
  if (groupType) {
    queryObject.groupType = groupType;
  }
  return queryObject;
}

function saveGroup(groupData) {
  const newGroupData = {
    ...groupData,
    enabled: false,
    creation: new Date(),
    ownerId: ObjectId(groupData?.ownerId),
  };
  return newGroupData;
}

function updateGroup(groupData) {
  const newGroupData = {
    ...groupData,
    enabled: false,
    lastUpdate: new Date(),
  };
  return { $set: newGroupData };
}

function findGroupMembers(groupId) {
  return { groupId: ObjectId(groupId) };
}

function findOwnerGroups(ownerId, groupType = null) {
  const queryObject = { ownerId: ObjectId(ownerId) };
  if (groupType) {
    queryObject.groupType = groupType;
  }
  return queryObject;
}

function findUserGroups(id) {
  const userId = ObjectId(id);
  return [{
    $match: { userId },
  },
  {
    $lookup: {
      from: userGroups,
      localField: 'groupId',
      foreignField: '_id',
      as: 'groups',
    },
  },
  {
    $project: {
      groups: 1,
      _id: 0,
    },
  },
  {
    $unwind: { path: '$groups' },
  },
  {
    $project: {
      _id: '$groups._id',
      ownerId: '$groups.ownerId',
      name: '$groups.name',
      exclusive: '$groups.exclusive',
      enabled: '$groups.enabled',
      creation: '$groups.creation',
    },
  },
  ];
}

function findUserGroup(userId, groupId) {
  return {
    userId: ObjectId(userId),
    groupId: ObjectId(groupId),
  };
}

function findMembers(groupId) {
  return { groupId };
}

function findGroupIdsByOwner(ownerId, groupType) {
  const query = { ownerId: ObjectId(ownerId) };
  if (groupType) {
    query.groupType = groupType;
  }
  return query;
}

function findUserGroupsMembers(groups) {
  const aggregateQuery = [];
  const groupIds = groups.map(item => ObjectId(item));
  const queryMatch = { groupId: { $in: groupIds } };
  aggregateQuery.push({ $match: queryMatch });
  aggregateQuery.push({
    $lookup: {
      from: users,
      localField: 'userId',
      foreignField: '_id',
      as: 'user',
    },
  });
  aggregateQuery.push({ $unwind: { path: '$user' } });
  aggregateQuery.push({
    $lookup: {
      from: 'UserGroups',
      localField: 'groupId',
      foreignField: '_id',
      as: 'group',
    },
  });
  aggregateQuery.push({ $unwind: { path: '$group' } });
  aggregateQuery.push({
    $project: {
      _id: 0,
      userId: 1,
      thirdPartyId: 1,
      userIdType: '$user.identificationType',
      userIdNumber: '$user.identification',
      userName: '$user.userName',
      name: '$user.name',
      lastname: '$user.lastname',
      email: '$user.email',
      mainEmail: '$user.mainEmail',
      phoneCountry: '$user.phoneCountry',
      phoneNumber: '$user.phoneNumber',
      userType: '$user.userType',
      profileName: '$user.profileName',
      state: '$user.state',
      additionalData: '$user.additionalData',
      groupName: '$group.name',
      groupType: '$groups.groupType',
    },
  });
  return aggregateQuery;
}

function findGroupsMembersByOwner(ownerId, groupType) {
  const aggregateQuery = [];
  const queryMatch = { ownerId: ObjectId(ownerId) };
  if (groupType) {
    queryMatch.groupType = groupType;
  }
  aggregateQuery.push({
    $match: queryMatch,
  });
  aggregateQuery.push({
    $lookup: {
      from: userGroupMembers,
      localField: '_id',
      foreignField: 'groupId',
      as: 'members',
    },
  });
  aggregateQuery.push({
    $project: {
      _id: 1,
      ownerId: 1,
      name: 1,
      groupType: 1,
      members: 1,
    },
  });
  return aggregateQuery;
}

function newGroupMember(memberData) {
  const newMemberData = {
    ...memberData,
    enabled: false,
    groupId: ObjectId(memberData.groupId),
    userId: ObjectId(memberData.userId),
    creation: new Date(),
  };
  return newMemberData;
}

module.exports = {
  ObjectId,
  findByUserId,
  findByName,
  findById,
  updateObj,
  findByAttributes,
  removeStoreFromUser,
  removeStoresFromUser,
  insertUserRelation,
  findGroup,
  saveGroup,
  updateGroup,
  findOwnerGroups,
  findUserGroups,
  findUserGroup,
  findGroupMembers,
  findMembers,
  findGroupIdsByOwner,
  findUserGroupsMembers,
  findGroupsMembersByOwner,
  newGroupMember,
};