watermanagement-backend-prod/src/routes/usersRoute.js

const fastify = require("fastify");
const userController = require("../controllers/userController");
const validationHandler = require("../handlers/userHandler");

module.exports = function (fastify, opts, next) {
  fastify.get("/api/users", {
    schema: {
      tags: ["User"],
      description: "This is for Get All Users",
      summary: "This is for to Get All Users",
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: userController.getUsers,
  });

  
  fastify.route({
    method: "POST",
    url: "/api/users/:customerId",
    schema: {
      description: "To Get user by customerId",
      tags: ["User"],
      summary: "This is for Get a Single User by customerId",
      params: {
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: userController.getSingleUser,
  });

  fastify.route({
    method: "POST",
    url: "/api/currentUser",
    schema: {
      tags: ["User"],
      description: "This is for Get Current User by customerId by Post Body",
      summary: "This is for Get a Current User.",
      body: {
        type: "object",
        required: ["customerId"],
        properties: {
          customerId: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: userController.getCurrentUser,
    // onSend: (request, reply, done) => {

    //     // fire&forget
    //     request.log.info("#########################################");
    //     request.log.info(reply);

    //   done()
    // },
  });

  fastify.route({
    method: "PUT",
    url: "/api/user/:userId",
    schema: {
      tags: ["User"],
      summary: "This is for update user",
      params: {
        type: "object",
        properties: {
          userId: {
            type: "string",
            description: "userId",
          },
        },
      },
      body: {
        type: "object",
        // required: ['phone'],
        properties: {
          phone: { type: "string" },
          firstName: { type: "string" },
          lastName: { type: "string" },
          
          address1: { type: "string" },
          address2: { type: "string" },
          city: { type: "string" },
          state: { type: "string" },
          country: { type: "string" },
          zip: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: [
      fastify.auth([fastify.operatorAuthenticate]),
      //validationHandler.validatePhoneFormat,
    ],
    // preHandler: fastify.auth([fastify.authenticate]),
    handler: userController.editUserInfo,
  });

  fastify.route({
    method: "POST",
    url: "/api/user/:installationId",
    schema: {
      tags: ["Install"],
      description: "This is for cretae New user",
      summary: "This is for Create New User.",
      params: {
        type: "object",
        properties: {
          installationId: {
            type: "string",
            description: "installationId",
          },
        },
      },
      body: {
        type: "object",
        properties: {
          phone: { type: "string" },
          password: { type: "string" },
          emails: {
            type: "array",
            maxItems: 2,
            items: {
              type: "object",
              properties: {
                email: { type: "string", default: null },
              },
            },
          },
          firstName: { type: "string", default: null },
          lastName: { type: "string", default: null },
          username: { type: "string" },
          buildingName: { type: "string", default: null },
          inchargeName: { type: "string", default: null },
          address1: { type: "string", default: null },
          address2: { type: "string", default: null },
          city: { type: "string", default: null },
          state: { type: "string", default: null },
          zip: { type: "string", default: null },
          country: { type: "string", default: null },
          notes: { type: "string", default: null },
          latitude: { type: 'number', default: 0.0 },
          longitude: { type: 'number', default: 0.0},
          fcmId: { type: "string", default: null },
          deviceId: { type: "string", default: null },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: [
      validationHandler.fieldCheck,
     // validationHandler.verifyUser,
      // validationHandler.validatePhoneFormat,
      validationHandler.validateEmailFormat,
    ],
    handler: userController.addUser,
    // onResponse: (request, reply) => {
    //   validationHandler.sendPhoneVerificationCode(request, reply);
    // },
    //onResponse: validationHandler.sendPhoneVerificationCode,
  });

  fastify.route({
    method: "POST",
    url: "/api/phone",
    schema: {
      tags: ["User"],
      description: "This is for verify User Phone",
      summary: "This is to Verify User Phone.",
      body: {
        type: "object",
        required: ["phone"],
        properties: {
          phoneVerificationCode: { type: "string" },
          phone: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: fastify.auth([fastify.authenticate]),
    handler: validationHandler.verifyPhone,
  });

  fastify.route({
    method: "POST",
    url: "/api/forgotpassword",
    schema: {
      tags: ["User"],
      description: "This is for forget password for the User.",
      summary: "This is for forget User Password.",
      body: {
        type: "object",
        required: ["phone"],
        properties: {
          phone: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: [validationHandler.],
    handler: userController.forgotPassword,
    onResponse: (request, reply) => {
      validationHandler.sendPasswordResetCode(request, reply);
    },
  });
  

  fastify.route({
    method: "POST",
    url: "/api/forgotpasswordsupplier",
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for forgot password for the Supplier.",
      summary: "This is for forgot password for the Supplier.",
      body: {
        type: "object",
        required: ["phone"],
        properties: {
          phone: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: [validationHandler.],
    handler: userController.forgotPasswordSupplier,
    onResponse: (request, reply) => {
      validationHandler.sendPasswordResetCode(request, reply);
    },
  });

  fastify.route({
    method: "POST",
    url: "/api/resetpassword",
    schema: {
      tags: ["User"],
      description: "This is for Reset User Password.",
      summary: "This is for Reset User Password.",
      body: {
        type: "object",
        required: ["phone", "resetPasswordCode", "newPassword"],
        properties: {
          phone: { type: "string" },
          resetPasswordCode: { type: "string" },
          newPassword: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    //preHandler: [validationHandler],
    handler: validationHandler.resetPassword,
    // onResponse: (request,reply) => {validationHandler.resetPassword(request,reply)}
  });

  fastify.route({
    method: "POST",
    url: "/api/resetpasswordsupplier",
    schema: {
      tags: ["Supplier-Data"],
      description: "This is for Supplier Reset Password.",
      summary: "This is for Supplier Reset  Password.",
      body: {
        type: "object",
        required: ["phone", "resetPasswordCode", "newPassword"],
        properties: {
          phone: { type: "string" },
          resetPasswordCode: { type: "string" },
          newPassword: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    //preHandler: [validationHandler],
    handler: validationHandler.resetPasswordSupplier,
    // onResponse: (request,reply) => {validationHandler.resetPassword(request,reply)}
  });


  fastify.route({
    method: "POST",
    url: "/api/resetPasswordFromAdmin",
    schema: {
      tags: ["User"],
      description: "This is for Reset Password for Admin.",
      summary: "This is for Reset  Password for Admin.",
      body: {
        type: "object",
        properties: {
          customerId: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: [validationHandler.],
    handler: validationHandler.resetPasswordFromAdmin,
    // onResponse: (request,reply) => {validationHandler.resetPassword(request,reply)}
  });

  fastify.route({
    method: "POST",
    url: "/api/resendphoneverificationcode",
    schema: {
      tags: ["User"],
      description: "This is for Reset phone Verification Code.",
      summary: "This is for Reset phone verification Code.",
      body: {
        type: "object",
        required: ["phone"],
        properties: {
          phone: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: [validationHandler.],
    handler: validationHandler.sendPhoneVerificationCode,
    // onResponse: (request,reply) => {validationHandler.sendPhoneVerificationCode(request,reply)}
  });

  fastify.route({
    method: "POST",
    url: "/api/users/send_message",
    schema: {
      tags: ["User"],
      description: "This is for Send Message.",
      summary: "This is for Send Message.",
      body: {
        type: "object",
        required: ["userId"],
        properties: {
          userId: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    handler: validationHandler.sendMessageNotification,
  });

  fastify.route({
    method: "PUT",
    url: "/api/update/currentUser/:customerId",
    schema: {
      tags: ["User"],
      summary: "This is for update current user",
      params: {
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
      body: {
        type: "object",
        properties: {
          phone: { type: "string" },
          firstName: { type: "string" },
          buildingName: { type: "string" },
          lastName: { type: "string" },
          username: { type: "string" },
          emails: {
            type: "array",
            maxItems: 2,
            items: {
              type: "object",
              properties: {
                email: { type: "string", default: null },
              },
            },
          },
          address1: { type: "string" },
          address2: { type: "string" },
          city: { type: "string" },
          state: { type: "string" },
          country: { type: "string" },
          zip: { type: "string" },
        },
      },
      security: [
        { 
          basicAuth: [],
        },
      ],
    },
    preHandler: [fastify.auth([fastify.authenticate])],
    handler: userController.editCuurentUserInfo,
  });
  // Login for a user is in the main index.js file.
  // fastify-jwt used to create the token was throwing exceptions and requierd
  // it be called before the route is loaded.
 
  

  const multer = require('multer');
  const fs = require('fs');
  
  const storage = multer.diskStorage({
    destination: function (req, file, cb) {
      if (!fs.existsSync(__dirname + '/temp')) {
        fs.mkdirSync(__dirname + '/temp');
      }
      cb(null, './temp');
    },
    filename: function (req, file, cb) {
      cb(null, file.originalname + '-' + Date.now() + '.' + file.mimetype.split('/')[1]);
    },
  });
  
  const upload = multer({ storage: storage }).single('picture');
  
  fastify.route({
    method: 'POST',
    url: '/api/users/profile-picture/:customerId',
    schema: {
      tags: ['User'],
      description: 'Upload a profile picture',
      summary: 'Upload a profile picture',
      params: {
        type: 'object',
        properties: {
          customerId: {
            type: 'string',
            description: 'Customer ID',
          },
        },
      },
      body: {
        formData: {
          picture: {
            type: 'string',
            format: 'binary',
            description: 'Profile picture file',
          },
        },
      },
      response: {
        200: {
          description: 'Profile picture uploaded successfully',
          type: 'object',
          properties: {
            message: { type: 'string' },
          },
        },
        400: {
          description: 'Failed to upload profile picture',
          type: 'object',
          properties: {
            error: { type: 'string' },
          },
        },
        500: {
          description: 'Internal server error',
          type: 'object',
          properties: {
            error: { type: 'string' },
          },
        },
      },
    },
    handler: async (req, reply) => {
      try {
        upload(req, reply, async (err) => {
          if (err) {
            reply.status(400).send({ error: 'Failed to upload profile picture' });
            return;
          }
  
          const customerId = req.params.customerId;
          const picturePath = req.file.path;
  
          let profilePicture = await ProfilePicture.findOne({ customerId });
  
          if (!profilePicture) {
            profilePicture = new ProfilePicture({
              customerId,
              picture: fs.readFileSync(picturePath),
            });
          } else {
            profilePicture.picture = fs.readFileSync(picturePath);
          }
  
          await profilePicture.save();
  
          // Delete the temporary uploaded file
          fs.unlinkSync(picturePath);
  
          reply.send({ message: 'Profile picture uploaded successfully' });
        });
      } catch (error) {
        reply.status(500).send({ error: error.message });
      }
    },
  });
  

  fastify.route({
    method: "POST",
    url: "/api/sendSms",
    schema: {
      tags: ["User"],
      description: "This is to send Sms.",
      summary: "This is to send Sms.",
      body: {
        type: "object",
        required: ["mobileNumbers"],
        properties: {
          mobileNumbers: { type: "string" },
        
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    //preHandler: [validationHandler],
    handler: userController.sendSms,
    // onResponse: (request,reply) => {validationHandler.resetPassword(request,reply)}
  });

  fastify.route({
    method: "POST",
    url: "/api/addTeammembers/:customerId",
    schema: {
      tags: ["User"],
      description: "This is for adding Team  members",
      summary: "This is for adding Team members",
      params: {
        required: ["customerId"],
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
      body: {
        type: "object",
        properties: {
          teamAdminName: { type: "string"},
          Name: { type: "string" },
          phone: { type: "string" },
        },
        
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: [
      //validationHandler.fieldCheck,
      //validationHandler.verifySupplier,
      //  validationHandler.validatePhoneFormat,
      //validationHandler.validateEmailFormat,
    ],
    handler: userController.addTeamMembers,
  });

  fastify.route({
    method: "PUT",
    url: "/api/deleteTeamMember/:customerId",
    schema: {
      tags: ["User"],
      summary: "This is for delete Team Member",
      description: "This is for delete Team Member",
      params: {
        required: ["customerId"],
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
      querystring: {
        phone: { type: "string" },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    preHandler: fastify.auth([fastify.authenticate]),
    handler: userController.deleteTeamMember, // Ensure this line points to the handler
  });
  
  fastify.route({
    method: "PUT",
    url: "/api/updateTeamMeber/:customerId",
    schema: {
      tags: ["User"],
      summary: "This is for update Team Member details",
      params: {
        required: ["customerId"],
        type: "object",
        properties: {
          customerId: {
            type: "string",
            description: "customerId",
          },
        },
      },
      querystring: {
        phone: {type: 'string'}
      },
      
      body: {
        type: "object",
        // required: ['phone'],
        properties: {

            name: { type: "string", default: null },
            phone: { type: "string", default: null },
            alternativeContactNumber: { type: "string" },
        },
      },
      security: [
        {
          basicAuth: [],
        },
      ],
    },
    // preHandler: [
    //   fastify.auth([fastify.operatorAuthenticate]),
    //   validationHandler.validatePhoneFormat,
    // ],
   // preHandler: fastify.auth([fastify.authenticate]),
    handler: userController.updateTeamMember,
  });


  fastify.route({
    method: "DELETE",
    url: "/api/logout",
    schema: {
          description: "This is for logout",
          tags: ["Logout"],
          summary: "This is for logout",
          params: {
            type: "object",
            properties: {
              customerId: {
                type: "string",
                description: "customerId",
              },
            },
          },
        },
    // preHandler: fastify.auth([fastify.authenticate]),
    handler: userController.logout,
  });


  next();
};