generated from Real-Dev-Squad/website-template
-
Notifications
You must be signed in to change notification settings - Fork 201
/
extensionRequestsv2.ts
147 lines (127 loc) · 4.68 KB
/
extensionRequestsv2.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
import { getRequestByKeyValues, updateRequest } from "../models/requests";
import {
ERROR_WHILE_CREATING_REQUEST,
ERROR_WHILE_UPDATING_REQUEST,
LOG_ACTION,
REQUEST_APPROVED_SUCCESSFULLY,
REQUEST_LOG_TYPE,
REQUEST_REJECTED_SUCCESSFULLY,
REQUEST_STATE,
REQUEST_TYPE,
} from "../constants/requests";
import { addLog } from "../models/logs";
import { createRequest } from "../models/requests";
import { fetchTask } from "../models/tasks";
import { CustomResponse } from "../typeDefinitions/global";
import { ExtensionRequest, ExtensionRequestCreateBody, ExtensionRequestRequest } from "../types/extensionRequests";
import { getUsernameElseUndefined } from "../utils/users";
export const createTaskExtensionRequest = async (req: ExtensionRequestRequest, res: CustomResponse) => {
try {
const { userData } = req;
const { id: requestedBy, roles } = userData || {};
const { body } = req;
if (!requestedBy) {
return res.boom.unauthorized();
}
const { taskId } = body;
let extensionBody: ExtensionRequestCreateBody = { ...body, requestedBy };
let assignee: string | undefined = undefined;
const { taskData: task } = await fetchTask(taskId);
if (!task) {
return res.boom.badRequest("Task Not Found");
}
const { assigneeId, endsOn } = task;
if (!assigneeId) {
return res.boom.badRequest("Assignee is not present for this task");
}
assignee = await getUsernameElseUndefined(assigneeId);
if (!assignee) {
return res.boom.badRequest("Assignee is not present for this task");
} else {
extensionBody = { ...extensionBody, assignee };
}
if (requestedBy !== assigneeId && !roles?.super_user) {
return res.boom.forbidden("Only assigned user and super user can create an extension request for this task.");
}
if (endsOn >= body.newEndsOn) {
return res.boom.badRequest("New ETA must be greater than Old ETA");
}
if (body.oldEndsOn != endsOn) {
return res.boom.badRequest("Old ETA does not match the task's ETA");
}
const latestExtensionRequest: ExtensionRequest | undefined = await getRequestByKeyValues({
taskId,
type: REQUEST_TYPE.EXTENSION,
});
if (latestExtensionRequest && latestExtensionRequest.state === REQUEST_STATE.PENDING) {
return res.boom.badRequest("An extension request for this task already exists.");
}
const requestNumber: number =
latestExtensionRequest?.requestedBy === requestedBy && latestExtensionRequest.requestNumber
? latestExtensionRequest.requestNumber + 1
: 1;
extensionBody = { ...extensionBody, requestNumber };
const extensionRequest = await createRequest(extensionBody);
if ("error" in extensionRequest) {
return res.boom.badRequest(extensionRequest.error);
}
const extensionLog = {
type: REQUEST_LOG_TYPE.REQUEST_CREATED,
meta: {
taskId,
requestId: extensionRequest.id,
action: LOG_ACTION.CREATE,
createdBy: requestedBy,
createdAt: Date.now(),
},
body: extensionBody,
};
await addLog(extensionLog.type, extensionLog.meta, extensionLog.body);
return res.status(201).json({
message: "Extension Request created successfully!",
extensionRequest: { ...extensionBody, id: extensionRequest.id },
});
} catch (err) {
logger.error(ERROR_WHILE_CREATING_REQUEST, err);
return res.boom.badImplementation(ERROR_WHILE_CREATING_REQUEST);
}
};
export const updateTaskExtensionRequest = async (req: any, res: any) => {
const requestBody = req.body;
const userId = req?.userData?.id;
const requestId = req.params.id;
if (!userId) {
return res.boom.unauthorized();
}
try {
const requestResult = await updateRequest(requestId, requestBody, userId,REQUEST_TYPE.EXTENSION)
if ("error" in requestResult) {
return res.boom.badRequest(requestResult.error);
}
const [logType, returnMessage] =
requestResult.state === REQUEST_STATE.APPROVED
? [REQUEST_LOG_TYPE.REQUEST_APPROVED, REQUEST_APPROVED_SUCCESSFULLY]
: [REQUEST_LOG_TYPE.REQUEST_REJECTED, REQUEST_REJECTED_SUCCESSFULLY];
const requestLog = {
type: logType,
meta: {
requestId: requestId,
action: LOG_ACTION.UPDATE,
createdBy: userId,
createdAt: Date.now(),
},
body: requestResult,
};
await addLog(requestLog.type, requestLog.meta, requestLog.body);
return res.status(201).json({
message: returnMessage,
data: {
id: requestResult.id,
...requestResult,
},
});
} catch (err) {
logger.error(ERROR_WHILE_UPDATING_REQUEST, err);
return res.boom.badImplementation(ERROR_WHILE_UPDATING_REQUEST);
}
};