Merge pull request #46 from Sachintechjoomla/Issue#254011

Issue#254011 Feat: Update > LC update participant address

Author: vaibhavsTekdi

controllers/v1/programUsers.js

@@ -181,4 +181,53 @@ module.exports = class ProgramUsers extends Abstract {
 			}
 		})
 	}
+
+	/**
+	 * Update entity location/profile information
+	 * Validates that logged-in user has participant assigned before updating
+	 * @method
+	 * @name updateEntityLocation
+	 * @param {Object} req - request object
+	 * @param {String} req.body.userId - participant's userId to update
+	 * @param {String} req.body.entityId - participant's entityId (optional)
+	 * @param {Object} req.body.updateData - profile data to update (province, site, address, etc.)
+	 * @returns {Object} response with status and updated user data
+	 */
+	async updateEntityLocation(req) {
+		return new Promise(async (resolve, reject) => {
+			try {
+				const { userId, entityId, updateData } = req.body
+
+				if (!userId) {
+					return reject({
+						status: HTTP_STATUS_CODE.bad_request.status,
+						message: 'userId is required',
+					})
+				}
+
+				if (!updateData) {
+					return reject({
+						status: HTTP_STATUS_CODE.bad_request.status,
+						message: 'updateData is required',
+					})
+				}
+
+				const result = await programUsersHelper.updateEntityLocation(
+					{
+						userId,
+						entityId,
+						updateData,
+					},
+					req.userDetails
+				)
+
+				return resolve(result)
+			} catch (error) {
+				return reject({
+					status: HTTP_STATUS_CODE.internal_server_error.status,
+					message: error.message || 'Internal server error',
+				})
+			}
+		})
+	}
 }

generics/services/users.js

@@ -640,8 +640,87 @@ const accountSearch = function (
 	})
 }
 
+/**
+ * Update user profile
+ * @method
+ * @name updateProfile
+ * @param {String} userId - user id to update
+ * @param {Object} updateData - user profile data to update (address, province, site, etc.)
+ * @param {String} userToken - logged in user token
+ * @param {String} tenantCode - tenant code
+ * @param {String} organizationId - organization id (required for org-admin endpoint)
+ * @returns {Promise} A promise that resolves with the updated user data or rejects with an error.
+ */
+const updateProfile = function (userId, updateData, userToken, tenantCode, organizationId) {
+	return new Promise(async (resolve, reject) => {
+		try {
+			// Use org-admin/updateUser endpoint to update participant profile
+			// This endpoint supports both role updates and profile updates (address, province, site, etc.)
+			const url = interfaceServiceUrl + process.env.USER_SERVICE_BASE_URL + '/v1/org-admin/updateUser/' + userId
+
+			// Include organization_id in the body (required by org-admin endpoint)
+			const bodyData = {
+				...updateData,
+				organization_id: organizationId,
+			}
+
+			const options = {
+				headers: {
+					'Content-Type': 'application/json',
+					internal_access_token: process.env.INTERNAL_ACCESS_TOKEN,
+					'x-auth-token': userToken,
+					tenantId: tenantCode,
+				},
+				json: bodyData,
+			}
+
+			// Use PATCH method for org-admin updateUser endpoint (as per working curl)
+			// request library supports patch method, but if not available, use method option
+			if (request.patch) {
+				request.patch(url, options, updateCallback)
+			} else {
+				// Fallback: use request with method option
+				options.method = 'PATCH'
+				request(url, options, updateCallback)
+			}
+			let result = {
+				success: true,
+			}
+
+			function updateCallback(err, data) {
+				if (err) {
+					result.success = false
+					result.error = err
+				} else {
+					let response = typeof data.body === 'string' ? JSON.parse(data.body) : data.body
+					if (response.responseCode === HTTP_STATUS_CODE['ok'].code) {
+						result['data'] = response.result
+					} else {
+						result.success = false
+						result.message = response.message
+						result.responseCode = response.responseCode
+					}
+				}
+				return resolve(result)
+			}
+			setTimeout(function () {
+				return resolve(
+					(result = {
+						success: false,
+						message: 'Request timeout',
+					})
+				)
+			}, CONSTANTS.common.SERVER_TIME_OUT)
+		} catch (error) {
+			console.log('error', error)
+			return reject(error)
+		}
+	})
+}
+
 module.exports = {
 	profile: profile,
+	updateProfile: updateProfile,
 	// locationSearch : locationSearch,
 	// getParentEntities : getParentEntities,
 	// profileReadPrivate: profileReadPrivate,

module/programUsers/helper.js

@@ -714,4 +714,172 @@ module.exports = class ProgramUsersHelper {
 			}
 		}
 	}
+
+	/**
+	 * Check if logged-in user has the participant assigned in programUsers
+	 * @method
+	 * @name checkParticipantAssigned
+	 * @param {String} loggedInUserId - logged in user's userId
+	 * @param {String} participantUserId - participant's userId to check
+	 * @param {String} participantEntityId - participant's entityId to check
+	 * @param {String} tenantId - tenant ID
+	 * @returns {Promise<Object>} result with success status and programUsers document if found
+	 */
+	static async checkParticipantAssigned(loggedInUserId, participantUserId, participantEntityId, tenantId) {
+		try {
+			// Find programUsers document where logged-in user is the userId and has the participant in entities
+			const query = {
+				userId: loggedInUserId.toString(),
+				tenantId: tenantId,
+				entities: {
+					$elemMatch: {
+						$or: [
+							{ userId: participantUserId.toString() },
+							{ userId: participantEntityId.toString() },
+							{ entityId: participantEntityId.toString() },
+							{ externalId: participantEntityId.toString() },
+						],
+					},
+				},
+			}
+
+			const programUserDoc = await programUsersQueries.programUsersDocument(query, [
+				'_id',
+				'userId',
+				'entities',
+				'programId',
+				'programExternalId',
+			])
+
+			if (!programUserDoc || programUserDoc.length === 0) {
+				return {
+					success: false,
+					message: 'Participant not assigned to logged-in user',
+				}
+			}
+
+			// Find the specific entity
+			const doc = programUserDoc[0]
+			const entity = doc.entities?.find(
+				(e) =>
+					e.userId == participantUserId ||
+					e.userId == participantEntityId ||
+					e.entityId == participantEntityId ||
+					e.externalId == participantEntityId
+			)
+
+			if (!entity) {
+				return {
+					success: false,
+					message: 'Participant entity not found in programUsers',
+				}
+			}
+
+			return {
+				success: true,
+				programUserDoc: doc,
+				entity: entity,
+			}
+		} catch (error) {
+			console.error('Error checking participant assignment:', error)
+			return {
+				success: false,
+				message: error.message || 'Error checking participant assignment',
+			}
+		}
+	}
+
+	/**
+	 * Update entity location/profile information
+	 * Similar to user/update but validates that logged-in user has participant assigned
+	 * @method
+	 * @name updateEntityLocation
+	 * @param {Object} data - request body data
+	 * @param {String} data.userId - participant's userId to update
+	 * @param {String} data.entityId - participant's entityId (optional, can use userId)
+	 * @param {Object} data.updateData - profile data to update (province, site, address, etc.)
+	 * @param {Object} userDetails - logged in user details
+	 * @returns {Object} result with status and updated user data
+	 */
+	static async updateEntityLocation(data, userDetails) {
+		try {
+			const { userId, entityId, updateData } = data
+			const loggedInUserId = userDetails.userInformation?.userId
+			const tenantId = userDetails.userInformation?.tenantId
+			const userToken = userDetails.userToken
+
+			// Validate required fields
+			if (!userId) {
+				return {
+					success: false,
+					status: HTTP_STATUS_CODE.bad_request.status,
+					message: 'userId is required',
+				}
+			}
+
+			if (!updateData || typeof updateData !== 'object' || Object.keys(updateData).length === 0) {
+				return {
+					success: false,
+					status: HTTP_STATUS_CODE.bad_request.status,
+					message: 'updateData is required and must be a non-empty object',
+				}
+			}
+
+			// Use entityId if provided, otherwise use userId
+			const participantIdentifier = entityId || userId
+
+			// Check if logged-in user has this participant assigned
+			const assignmentCheck = await this.checkParticipantAssigned(
+				loggedInUserId,
+				userId,
+				participantIdentifier,
+				tenantId
+			)
+
+			if (!assignmentCheck.success) {
+				return {
+					success: false,
+					status: HTTP_STATUS_CODE.forbidden.status,
+					message: assignmentCheck.message || 'You do not have permission to update this participant',
+				}
+			}
+
+			// Get tenant code and organization ID from userDetails
+			const tenantCode =
+				userDetails.userInformation?.tenantCode || userDetails.userInformation?.tenantId || tenantId
+			const organizationId = userDetails.userInformation?.organizationId
+
+			// Call user service to update the participant's profile using org-admin endpoint
+			const updateResult = await userService.updateProfile(
+				userId,
+				updateData,
+				userToken,
+				tenantCode,
+				organizationId
+			)
+
+			if (!updateResult.success) {
+				return {
+					success: false,
+					status: HTTP_STATUS_CODE.bad_request.status,
+					message: updateResult.message || 'Failed to update participant profile',
+					error: updateResult.error,
+				}
+			}
+
+			return {
+				success: true,
+				status: HTTP_STATUS_CODE.ok.status,
+				message: 'Participant profile updated successfully',
+				result: updateResult.data,
+			}
+		} catch (error) {
+			console.error('Error updating participant location:', error)
+			return {
+				success: false,
+				status: HTTP_STATUS_CODE.internal_server_error.status,
+				message: error.message || 'Internal server error',
+			}
+		}
+	}
 }