@robotical/appv2-warranty-service-lib
Version:
A tool that gathers data from the Apps and sends it to the Analytics server
800 lines (799 loc) • 37.3 kB
JavaScript
import Logger from '../services/Logger';
import Transport from '../transport/server';
import { ServerEndpoints } from '../types/types';
import randomHashGenerator from '../utils/randomHashGenerator';
import TicketQueue from '../utils/ServiceProgramTicketsQueue';
import ZohoAPI from '../ZohoIntegration/ZohoAPI';
const SHOW_LOGS = true;
const TAG = 'WarrantyService';
class WarrantyService {
constructor(privateKey) {
this.ticketsQueue = new TicketQueue();
if (privateKey !== 'only for instance') {
throw new Error('Use getInstance() to get the single instance of this class.');
}
}
static getInstance() {
if (!WarrantyService.instance) {
WarrantyService.instance = new WarrantyService('only for instance');
}
return WarrantyService.instance;
}
async isSerialNumberRegistered(serialNumber) {
Logger.info(SHOW_LOGS, TAG, `Checking if serial number ${serialNumber} is registered`);
const dataToPost = {
serialNumber: serialNumber
};
try {
const response = await Transport.post(ServerEndpoints.IS_SERIAL_NUMBER_REGISTERED, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.exists;
}
else {
Logger.warn(SHOW_LOGS, TAG, `Warn checking if serial number ${serialNumber} is registered: ${responseJsoned.message}`);
return false;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error checking if serial number ${serialNumber} is registered: ${error}`);
throw error;
}
}
async registerSerialNumber(serialNumber, email) {
Logger.info(SHOW_LOGS, TAG, `Registering serial number ${serialNumber} for email ${email}`);
const dataToPost = {
email: email,
serialNumber: serialNumber
};
try {
const response = await Transport.post(ServerEndpoints.REGISTER_SERIAL_NUMBER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
else {
Logger.warn(SHOW_LOGS, TAG, `Warn registering serial number ${serialNumber}: ${responseJsoned.message}`);
return false;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error registering serial number ${serialNumber}: ${error}`);
throw error;
}
}
async registerSerialNumbers(serialNumbers, email) {
Logger.info(SHOW_LOGS, TAG, `Registering serial numbers ${serialNumbers} for email ${email}`);
const lowerCaseEmail = email.toLowerCase();
const promises = serialNumbers.map((serialNumber) => this.registerSerialNumber(serialNumber, lowerCaseEmail));
try {
await Promise.all(promises);
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error registering serial numbers ${serialNumbers} for email ${email}: ${error}`);
return false;
}
return true;
}
async getSerialNumber(serialNumber) {
Logger.info(SHOW_LOGS, TAG, `Getting serial number ${serialNumber}`);
const dataToPost = {
serialNumber: serialNumber
};
try {
const response = await Transport.post(ServerEndpoints.GET_SERIAL_NUMBER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.serialNumberObj || null;
}
else {
Logger.warn(SHOW_LOGS, TAG, `Warn getting serial number ${serialNumber}: ${responseJsoned.message}`);
return null;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error getting serial number ${serialNumber}: ${error}`);
throw error;
}
}
async removeRegisteredSerialNumber(serialNumber) {
Logger.info(SHOW_LOGS, TAG, `Removing serial number ${serialNumber}`);
const dataToPost = {
serialNumber: serialNumber,
};
const response = await Transport.post(ServerEndpoints.REMOVE_SERIAL_NUMBER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
else {
Logger.warn(SHOW_LOGS, TAG, `Warn removing serial number ${serialNumber}: ${responseJsoned.message}`);
return false;
}
}
async getPrimaryEmailGivenAlternativeEmail(alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Getting primary email given alternative email ${alternativeEmail}`);
const dataToPost = {
alternativeEmail: alternativeEmail
};
const response = await Transport.post(ServerEndpoints.GET_PRIMARY_EMAIL_GIVEN_ALTERNATIVE_EMAIL, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.primaryEmail || null;
}
else {
Logger.warn(SHOW_LOGS, TAG, `warn getting primary email for alternative email ${alternativeEmail}: ${responseJsoned.message}`);
return null;
}
}
async addAlternativeToPrimaryEntry(primaryEmailToBeSet, alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Adding alternative email ${alternativeEmail} to primary email ${primaryEmailToBeSet}`);
const dataToPost = {
primaryEmail: primaryEmailToBeSet,
alternativeEmail: alternativeEmail
};
try {
const response = await Transport.post(ServerEndpoints.ADD_ALTERNATIVE_TO_PRIMARY_ENTRY, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
else {
Logger.warn(SHOW_LOGS, TAG, `Warn adding alternative email ${alternativeEmail} to primary email ${primaryEmailToBeSet}: ${responseJsoned.message}`);
return false;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error adding alternative email ${alternativeEmail} to primary email ${primaryEmailToBeSet}: ${error}`);
throw error;
}
}
async removeAlternativeToPrimaryEntry(alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Removing alternative email ${alternativeEmail}`);
const dataToPost = {
alternativeEmail: alternativeEmail
};
const response = await Transport.post(ServerEndpoints.REMOVE_ALTERNATIVE_TO_PRIMARY_ENTRY, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Warn removing alternative email ${alternativeEmail}: ${responseJsoned.message}`);
return false;
}
async getAlternativeEmailsGivenPrimaryEmail(primaryEmail) {
Logger.info(SHOW_LOGS, TAG, `Getting alternative emails given primary email ${primaryEmail}`);
const dataToPost = {
primaryEmail: primaryEmail
};
const response = await Transport.post(ServerEndpoints.GET_ALTERNATIVE_EMAILS_GIVEN_PRIMARY_EMAIL, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.alternativeEmails || [];
}
else {
Logger.warn(SHOW_LOGS, TAG, `Warn getting alternative emails for primary email ${primaryEmail}: ${responseJsoned.message}`);
return [];
}
}
async addAlternativeEmailToPrimaryEmail(primaryEmail, alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Adding alternative email ${alternativeEmail} to primary email ${primaryEmail}`);
const dataToPost = {
primaryEmail: primaryEmail,
alternativeEmail: alternativeEmail
};
try {
const response = await Transport.post(ServerEndpoints.ADD_ALTERNATIVE_EMAIL_TO_PRIMARY_EMAIL, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
else {
Logger.warn(SHOW_LOGS, TAG, `Warn adding alternative email ${alternativeEmail} to primary email ${primaryEmail}: ${responseJsoned.message}`);
return false;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error adding alternative email ${alternativeEmail} to primary email ${primaryEmail}: ${error}`);
throw error;
}
}
async removeAlternativeEmailFromPrimaryToAlternativeMap(primaryEmail, alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Removing alternative email ${alternativeEmail} from primary email ${primaryEmail}`);
const dataToPost = {
primaryEmail: primaryEmail,
alternativeEmail: alternativeEmail
};
const response = await Transport.post(ServerEndpoints.REMOVE_ALTERNATIVE_EMAIL_FROM_PRIMARY_TO_ALTERNATIVE_MAP, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Warn removing alternative email ${alternativeEmail} from primary email ${primaryEmail}: ${responseJsoned.message}`);
return false;
}
async removePrimaryToAlternativeEntry(primaryEmail) {
Logger.info(SHOW_LOGS, TAG, `Removing primary to alternative entry for primary email ${primaryEmail}`);
const dataToPost = {
primaryEmail: primaryEmail
};
const response = await Transport.post(ServerEndpoints.REMOVE_PRIMARY_TO_ALTERNATIVE_ENTRY, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Warn removing primary to alternative entry for primary email ${primaryEmail}: ${responseJsoned.message}`);
return false;
}
async getUser(email) {
{
Logger.info(SHOW_LOGS, TAG, `Getting user with email ${email}`);
const dataToPost = {
email: email
};
try {
const response = await Transport.post(ServerEndpoints.GET_USER_BY_EMAIL, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.user;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error getting user with email ${email}: ${error}`);
throw error;
}
}
{
Logger.info(SHOW_LOGS, TAG, `User with email ${email} not found. Checking alternative emails`);
const dataToPost = {
alternativeEmail: email
};
try {
const response = await Transport.post(ServerEndpoints.GET_PRIMARY_EMAIL_GIVEN_ALTERNATIVE_EMAIL, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
const primaryEmail = responseJsoned.primaryEmail;
if (primaryEmail) {
const user = await this.getUser(primaryEmail);
if (user) {
return user;
}
else {
Logger.warn(SHOW_LOGS, TAG, `User with primary email ${primaryEmail} not found`);
return null;
}
}
else {
Logger.warn(SHOW_LOGS, TAG, `No primary email found for alternative email ${email}`);
return null;
}
}
Logger.warn(SHOW_LOGS, TAG, `Could not get primary email for alternative email ${email}: ${responseJsoned.message}`);
return null;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error getting primary email for alternative email ${email}: ${error}`);
throw error;
}
}
}
async registerUser(email, establishment, serialNumbers) {
Logger.info(SHOW_LOGS, TAG, `Registering user with email ${email} and establishment ${establishment}`);
try {
Logger.info(SHOW_LOGS, TAG, `Registering serial numbers ${serialNumbers} for email ${email}`);
const didRegisterSerialNumberPromises = serialNumbers.map((serialNumber) => {
return this.registerSerialNumber(serialNumber, email);
});
const didRegisterSerialNumbers = await Promise.all(didRegisterSerialNumberPromises);
if (!didRegisterSerialNumbers.every(result => result)) {
Logger.warn(SHOW_LOGS, TAG, `Not all serial numbers were registered for email ${email}`);
return false;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error registering serial numbers for email ${email}: ${error}`);
const removeSerialNumberPromises = serialNumbers.map((serialNumber) => {
return this.removeRegisteredSerialNumber(serialNumber);
});
await Promise.all(removeSerialNumberPromises);
throw error;
}
try {
Logger.info(SHOW_LOGS, TAG, `Registering user with email ${email} and establishment ${establishment}`);
const date = new Date().toISOString();
const serialNumbersObject = {};
serialNumbers.forEach((serialNumber) => {
serialNumbersObject[serialNumber] = { serialNumber, date };
});
const dataToPost = {
email: email.toLowerCase(),
establishment: establishment,
serialNumbers: serialNumbersObject,
analyticsConsent: true,
automatedFaultReportingConsent: true,
date: date,
};
const response = await Transport.post(ServerEndpoints.REGISTER_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
Logger.info(SHOW_LOGS, TAG, `User with email ${email} registered successfully`);
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to register user with email ${email}: ${responseJsoned.message}`);
const removeSerialNumberPromises = serialNumbers.map((serialNumber) => {
return this.removeRegisteredSerialNumber(serialNumber);
});
await Promise.all(removeSerialNumberPromises);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error registering user with email ${email}: ${error}`);
const removeSerialNumberPromises = serialNumbers.map((serialNumber) => {
return this.removeRegisteredSerialNumber(serialNumber);
});
await Promise.all(removeSerialNumberPromises);
throw error;
}
}
async removeRegisteredUser(email) {
Logger.info(SHOW_LOGS, TAG, `Removing user with email ${email}`);
const user = await this.getUser(email);
if (!user) {
Logger.warn(SHOW_LOGS, TAG, `User with email ${email} not found`);
return false;
}
const serialNumbers = Object.keys(user.serialNumbers);
const promises = serialNumbers.map((serialNumber) => this.removeRegisteredSerialNumber(serialNumber));
for (const serialNumber of serialNumbers) {
const reports = Object.keys(user.serialNumbers[serialNumber].reports || {});
for (const reportId of reports) {
}
}
try {
await Promise.all(promises);
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error removing user with email ${email}: ${error}`);
return false;
}
const dataToPost = {
email: email
};
const response = await Transport.post(ServerEndpoints.REMOVE_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
Logger.info(SHOW_LOGS, TAG, `User with email ${email} removed successfully`);
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to remove user with email ${email}: ${responseJsoned.message}`);
return false;
}
async addSerialNumberToUser(email, serialNumber) {
Logger.info(SHOW_LOGS, TAG, `Adding serial number ${serialNumber} to user with email ${email}`);
const dataToPost = {
email: email,
serialNumber: serialNumber
};
try {
const response = await Transport.post(ServerEndpoints.ADD_SERIAL_NUMBER_TO_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to add serial number ${serialNumber} to user with email ${email}: ${responseJsoned.message}`);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error adding serial number ${serialNumber} to user with email ${email}: ${error}`);
return false;
}
}
async appendSerialNumbersToUser(email, serialNumbers) {
Logger.info(SHOW_LOGS, TAG, `Appending serial numbers ${serialNumbers} to user with email ${email}`);
const lowerCaseEmail = email.toLowerCase();
try {
const promises = serialNumbers.map((serialNumber) => this.addSerialNumberToUser(lowerCaseEmail, serialNumber));
const didAddSNToUser = await Promise.all(promises);
if (!didAddSNToUser.every((didAdd) => didAdd)) {
return false;
}
return this.registerSerialNumbers(serialNumbers, lowerCaseEmail);
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error appending serial numbers ${serialNumbers} to user with email ${email}: ${error}`);
return false;
}
}
async addRobotNameToSerialNumber(serialNumber, name) {
Logger.info(SHOW_LOGS, TAG, `Adding robot name ${name} to serial number ${serialNumber}`);
const userEmail = await this.getEmailGivenSerialNumber(serialNumber);
if (!userEmail) {
Logger.warn(SHOW_LOGS, TAG, `User with serial number ${serialNumber} not found`);
return false;
}
const dataToPost = {
serialNumber: serialNumber,
robotName: name,
email: userEmail
};
try {
const response = await Transport.post(ServerEndpoints.ADD_ROBOT_NAME_TO_SERIAL_NUMBER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to add robot name ${name} to serial number ${serialNumber}: ${responseJsoned.message}`);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error adding robot name ${name} to serial number ${serialNumber}: ${error}`);
return false;
}
}
async getEmailGivenSerialNumber(serialNumber) {
const serialNumberData = await this.getSerialNumber(serialNumber);
if (!serialNumberData) {
return null;
}
return serialNumberData.email;
}
async addLoginTokenToUser(email) {
Logger.info(SHOW_LOGS, TAG, `Adding login token to user with email ${email}`);
const user = await this.getUser(email);
if (!user) {
Logger.warn(SHOW_LOGS, TAG, `User with email ${email} not found`);
return false;
}
const dataToPost = {
email: email,
};
try {
const response = await Transport.post(ServerEndpoints.ADD_LOGIN_TOKEN_TO_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.loginToken;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to add login token to user with email ${email}: ${responseJsoned.message}`);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error adding login token to user with email ${email}: ${error}`);
throw error;
}
}
async getLoginToken(email) {
Logger.info(SHOW_LOGS, TAG, `Getting login token for user with email ${email}`);
const dataToPost = {
email: email,
};
try {
const response = await Transport.post(ServerEndpoints.GET_LOGIN_TOKEN, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
const loginToken = responseJsoned.loginToken;
if (!loginToken) {
Logger.warn(SHOW_LOGS, TAG, `Although the request was successful, the login token is undefined`);
return undefined;
}
return loginToken;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to get login token for user with email ${email}: ${responseJsoned.message}`);
return undefined;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error getting login token for user with email ${email}: ${error}`);
return undefined;
}
}
async setAnalyticsConsent(email, consent) {
Logger.info(SHOW_LOGS, TAG, `Setting analytics consent for user with email ${email}`);
const response = await Transport.post(ServerEndpoints.SET_ANALYTICS_CONSENT, {
email: email,
analyticsConsent: consent
});
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to set analytics consent for user with email ${email}: ${responseJsoned.message}`);
return false;
}
async setAutomatedFaultReportingConsent(email, consent) {
Logger.info(SHOW_LOGS, TAG, `Setting automated fault reporting consent for user with email ${email}`);
const response = await Transport.post(ServerEndpoints.SET_AUTOMATED_FAULT_REPORTING_CONSENT, {
email: email,
automatedFaultReportingConsent: consent
});
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to set automated fault reporting consent for user with email ${email}: ${responseJsoned.message}`);
return false;
}
async getAlternativeEmailsOfRegisteredUser(primaryEmail) {
Logger.info(SHOW_LOGS, TAG, `Getting alternative emails of registered user with primary email ${primaryEmail}`);
try {
const dataToPost = {
primaryEmail: primaryEmail
};
const response = await Transport.post(ServerEndpoints.GET_ALTERNATIVE_EMAILS_OF_REGISTERED_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.alternativeEmails || [];
}
Logger.warn(SHOW_LOGS, TAG, `Failed to get alternative emails for registered user with primary email ${primaryEmail}: ${responseJsoned.message}`);
return [];
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error getting alternative emails for registered user with primary email ${primaryEmail}: ${error}`);
return [];
}
}
async addAlternativeEmailToRegisteredUser(primaryEmail, alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Adding alternative email ${alternativeEmail} to registered user with primary email ${primaryEmail}`);
try {
const dataToPost = {
primaryEmail: primaryEmail,
alternativeEmail: alternativeEmail
};
const response = await Transport.post(ServerEndpoints.ADD_ALTERNATIVE_EMAIL_TO_REGISTERED_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to add alternative email ${alternativeEmail} to registered user with primary email ${primaryEmail}: ${responseJsoned.message}`);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error adding alternative email ${alternativeEmail} to registered user with primary email ${primaryEmail}: ${error}`);
return false;
}
}
async removeAlternativeEmailFromRegisteredUser(primaryEmail, alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Removing alternative email ${alternativeEmail} from registered user with primary email ${primaryEmail}`);
try {
const dataToPost = {
primaryEmail: primaryEmail,
alternativeEmail: alternativeEmail
};
const response = await Transport.post(ServerEndpoints.REMOVE_ALTERNATIVE_EMAIL_FROM_REGISTERED_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to remove alternative email ${alternativeEmail} from registered user with primary email ${primaryEmail}: ${responseJsoned.message}`);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error removing alternative email ${alternativeEmail} from registered user with primary email ${primaryEmail}: ${error}`);
return false;
}
}
async getReport(reportId, email, serialNumber) {
Logger.info(SHOW_LOGS, TAG, `Getting report with id ${reportId} for user with email ${email} and serial number ${serialNumber}`);
const dataToPost = {
reportId: reportId,
email: email,
serialNumber: serialNumber
};
const response = await Transport.post(ServerEndpoints.GET_REPORT_FROM_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return responseJsoned.report;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to get report with id ${reportId} for user with email ${email} and serial number ${serialNumber}: ${responseJsoned.message}`);
return null;
}
async registerReport(email, serialNumber, reportTitle, reportDescription, robotName, robotType) {
const reportId = randomHashGenerator();
Logger.info(SHOW_LOGS, TAG, `Registering report with id ${reportId} for user with email ${email} and serial number ${serialNumber}`);
Logger.info(SHOW_LOGS, TAG, `Checking for ticket existence in zoho for serial number ${serialNumber}`);
const ticket = await ZohoAPI.getTicketBySerialNumber(serialNumber);
Logger.debug(SHOW_LOGS, TAG, `Fecthed Ticket: ${JSON.stringify(ticket)}`);
let ticketId;
if (ticket) {
Logger.info(SHOW_LOGS, TAG, `Ticket found in zoho for serial number ${serialNumber}`);
ticketId = ticket.id;
}
else {
Logger.warn(SHOW_LOGS, TAG, `No ticket found for serial number ${serialNumber}. Creating a new one`);
ticketId = await ZohoAPI.createTicket(reportDescription, reportId, email, serialNumber, robotName, robotType);
if (!ticketId) {
Logger.warn(SHOW_LOGS, TAG, `Failed to create ticket for serial number ${serialNumber}`);
return false;
}
Logger.info(SHOW_LOGS, TAG, `Ticket created in zoho with id ${ticketId}`);
}
Logger.info(SHOW_LOGS, TAG, `Adding comment to ticket ${ticketId} for user with email ${email} and serial number ${serialNumber}`);
const commentId = await ZohoAPI.createComment(reportTitle, ticketId, reportId, reportDescription, email, serialNumber);
if (!commentId) {
Logger.warn(SHOW_LOGS, TAG, `Failed to add comment to ticket ${ticketId} for user with email ${email} and serial number ${serialNumber}`);
return false;
}
Logger.info(SHOW_LOGS, TAG, `Comment added to ticket ${ticketId} with id ${commentId}`);
const report = {
id: reportId,
title: reportTitle,
description: reportDescription,
serialNumber: serialNumber,
email: email,
robotName: robotName,
robotType: robotType,
zohoTicketId: ticketId,
zohoCommentId: commentId,
date: new Date().toISOString()
};
const wasReportAddedToUser = await this.addReportToUser(email, serialNumber, report);
if (!wasReportAddedToUser) {
Logger.warn(SHOW_LOGS, TAG, `Report wasn't added to user with email ${email} and serial number ${serialNumber}`);
return false;
}
Logger.info(SHOW_LOGS, TAG, `Report with id ${reportId} added to user with email ${email} and serial number ${serialNumber}`);
return reportId;
}
async addReportToUser(email, serialNumber, report) {
Logger.info(SHOW_LOGS, TAG, `Adding report ${report.id} to user with email ${email}`);
try {
const dataToPost = {
email: email,
serialNumber: serialNumber,
report: report
};
const response = await Transport.post(ServerEndpoints.ADD_REPORT_TO_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to add report ${report.id} to user with email ${email}: ${responseJsoned.message}`);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error adding report ${report.id} to user with email ${email}: ${error}`);
return false;
}
}
async removeReportFromUser(email, serialNumber, reportId) {
Logger.info(SHOW_LOGS, TAG, `Removing report ${reportId} from user with email ${email}`);
try {
const dataToPost = {
email: email,
serialNumber: serialNumber,
reportId: reportId
};
const response = await Transport.post(ServerEndpoints.REMOVE_REPORT_FROM_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
return true;
}
Logger.warn(SHOW_LOGS, TAG, `Failed to remove report ${reportId} from user with email ${email}: ${responseJsoned.message}`);
return false;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error removing report ${reportId} from user with email ${email}: ${error}`);
return false;
}
}
async swapPrimaryAndAlternativeEmailsFromMaps(primaryEmail, alternativeEmail) {
Logger.info(SHOW_LOGS, TAG, `Swapping primary and alternative emails from maps: ${primaryEmail} <-> ${alternativeEmail}`);
const alternativeEmails = await this.getAlternativeEmailsGivenPrimaryEmail(primaryEmail);
const promises = [];
alternativeEmails.forEach((email) => {
if (email === alternativeEmail) {
return;
}
this.addAlternativeToPrimaryEntry(alternativeEmail, email);
});
promises.push(this.removeAlternativeToPrimaryEntry(alternativeEmail));
promises.push(this.addAlternativeToPrimaryEntry(alternativeEmail, primaryEmail));
const updatedAlternativeEmails = alternativeEmails.filter((email) => email !== alternativeEmail);
updatedAlternativeEmails.push(primaryEmail);
await this.addAlternativeEmailToPrimaryEmail(alternativeEmail, primaryEmail);
await this.removePrimaryToAlternativeEntry(primaryEmail);
try {
await Promise.all(promises);
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error swapping primary and alternative emails from maps: ${error}`);
return false;
}
return true;
}
async changePrimaryEmailOfRegisteredUser(oldEmail, newEmail) {
Logger.info(SHOW_LOGS, TAG, `Changing primary email of registered user from ${oldEmail} to ${newEmail}`);
const wasAdded = await this.addAlternativeEmailToRegisteredUser(oldEmail, oldEmail);
if (!wasAdded) {
Logger.warn(SHOW_LOGS, TAG, "Could not add old email to alternative emails");
}
const wasRemoved = await this.removeAlternativeEmailFromRegisteredUser(oldEmail, newEmail);
if (!wasRemoved) {
Logger.warn(SHOW_LOGS, TAG, "Could not remove new email from alternative emails");
}
const lowerCaseOldEmail = oldEmail.toLowerCase();
const lowerCaseNewEmail = newEmail.toLowerCase();
const user = await this.getUser(lowerCaseOldEmail);
if (!user) {
Logger.warn(SHOW_LOGS, TAG, "Could not get user with email:", lowerCaseOldEmail);
return false;
}
user.email = lowerCaseNewEmail;
const dataToPost = {
user: user,
};
try {
const response = await Transport.post(ServerEndpoints.ADD_USER_OBJECT, dataToPost);
const responseJsoned = await response.json();
const wasSet = responseJsoned.success;
if (!wasSet) {
Logger.warn(SHOW_LOGS, TAG, "Could not set user with new email:", lowerCaseNewEmail);
return false;
}
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error setting user with new email ${lowerCaseNewEmail}: ${error}`);
return false;
}
const serialNumbers = Object.keys(user.serialNumbers);
const updatePromises = serialNumbers.map((sn) => {
const dataToPost = {
email: lowerCaseNewEmail,
serialNumber: sn,
};
return Transport.post(ServerEndpoints.UPDATE_EMAIL_OF_SERIAL_NUMBER, dataToPost);
});
try {
await Promise.all(updatePromises);
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error updating serial numbers for user with email ${lowerCaseNewEmail}: ${error}`);
return false;
}
{
const dataToPost = {
email: lowerCaseOldEmail,
};
const response = await Transport.post(ServerEndpoints.REMOVE_USER, dataToPost);
const responseJsoned = await response.json();
if (responseJsoned.success) {
Logger.info(SHOW_LOGS, TAG, `User with email ${lowerCaseOldEmail} removed successfully`);
return true;
}
}
Logger.warn(SHOW_LOGS, TAG, `Could not remove user with email ${lowerCaseOldEmail}`);
return false;
}
async checkExistenceOfUserAndSerial(email, serial) {
const user = await this.getUser(email);
if (!user || !user.serialNumbers[serial]) {
return null;
}
return user;
}
getReportsWithSameTitle(reports, title) {
const reportsWithSameTitle = reports.filter((report) => report.title === title);
return reportsWithSameTitle;
}
async getZohoTicketsFromReports(reports) {
const zohoTicketsPromises = [];
for (const report of Object.values(reports)) {
if (report.zohoTicketId) {
const ticketPromise = ZohoAPI.getTicketById(report.zohoTicketId);
zohoTicketsPromises.push(ticketPromise);
}
}
const zohoTickets = await Promise.all(zohoTicketsPromises);
return zohoTickets.filter((ticket) => ticket !== null && !ticket.isDeleted);
}
async updateZohoTicketStatus(ticketId, status) {
Logger.info(SHOW_LOGS, TAG, `Updating Zoho ticket ${ticketId} status to ${status}`);
try {
const didUpdateOnHs = !!await ZohoAPI.updateTicketStatus(ticketId, status);
return didUpdateOnHs;
}
catch (error) {
Logger.error(SHOW_LOGS, TAG, `Error updating Zoho ticket ${ticketId} status: ${error}`);
return false;
}
}
}
export default WarrantyService;