Projects Management
This package contains a backend of what would be the logic of a projects management software
Usage
const { DataAssignments } = require("./data/DataAssignment");
const { DataAttachments } = require("./data/DataAttachments");
const { DataComments } = require("./data/DataComments");
const { DataMember } = require("./data/DataMember");
const { DataMilestone } = require("./data/DataMilestone");
const { DataProject } = require("./data/DataProject");
const { DataResource } = require("./data/DataResource");
const { DataResourceAssignments } = require("./data/DataResourceAssignment");
const { DataTask } = require("./data/DataTask");
const { DTOAssignments } = require("./entity/DTOAssignment");
const { DTOAttachments } = require("./entity/DTOAttachments");
const { DTOComments } = require("./entity/DTOComments");
const { DTOMember } = require("./entity/DTOMember");
const { DTOMilestone } = require("./entity/DTOMilestone");
const { DTOProject } = require("./entity/DTOProject");
const { DTOResource } = require("./entity/DTOResource");
const { DTOResourceAssignment } = require("./entity/DTOResourceAssignment");
const { DTOTask } = require("./entity/DTOTask");
#region PROJECTS
async function registerProject() {
for (let index = 1; index < 8; index++) {
let dtoproject = new DTOProject();
dtoproject.Project_name = "Projectname" + index.toString();
dtoproject.Descriptionn = "Descriptionn" + index.toString();
dtoproject.Start_datee = `2023-07-1${index}`;
dtoproject.End_date = `2023-08-1${index}`;
dtoproject.Project_manager = "Projectmanager" + index.toString();
dtoproject.Priorityy = "Medium";
dtoproject.Client = "Client" + index.toString();
dtoproject.Budget = 444+index;
let registerProject = await DataProject.registerProject(dtoproject);
if (registerProject===-1) {
throw new
Error("The Priority must be High , Medium , Low");
}
if (registerProject===-2) {
throw new
Error("The End Date must be higher than Start Date");
}
console.log("Project registered successfully");
}
}
registerProject().then()
async function updateDescriptionNameProject() {
let idproject = 1;
let projectname = "ProjectNameUpdate";
let description = "ProjectDescriptionnUpdate";
let updateDescriptionNameProject =
await DataProject.updateDescriptionNameProject(idproject,projectname,description);
if (updateDescriptionNameProject===-1) {
throw new
Error("The Project does not exists");
}
console.log("Project updated successfully");
}
updateDescriptionNameProject().then()
async function updateEndDateProject() {
let idproject = 9;
let end_date = '2023-08-30';
let updateEndDateProject =
await DataProject.updateEndDateProject(idproject,end_date);
if (updateEndDateProject===-1) {
throw new
Error("The Project does not exists");
}
if (updateEndDateProject===-2) {
throw new
Error("The End Date must be higher than Start Date");
}
console.log("Project updated successfully");
}
updateEndDateProject().then()
async function updatePriorityProject() {
let idproject = 1;
let priority = 'High';
let updatePriorityProject =
await DataProject.updatePriorityProject(idproject,priority);
if (updatePriorityProject===-1) {
throw new
Error("The Project does not exists");
}
if (updatePriorityProject===-2) {
throw new
Error("The Priority must be High , Medium , Low");
}
console.log("Project updated successfully");
}
updatePriorityProject().then()
async function completeProject() {
let idproject = 1;
let completeProject =
await DataProject.completeProject(idproject);
if (completeProject===-1) {
throw new
Error("The Project does not exists");
}
console.log("Project updated successfully");
}
completeProject().then()
async function onholdProject() {
let idproject = 8;
let onholdProject =
await DataProject.onholdProject(idproject);
if (onholdProject===-1) {
throw new
Error("The Project does not exists");
}
console.log("Project updated successfully");
}
onholdProject().then()
async function cancelProject() {
let idproject = 8;
let cancelProject =
await DataProject.cancelProject(idproject);
if (cancelProject===-1) {
throw new
Error("The Project does not exists");
}
console.log("Project updated successfully");
}
cancelProject().then()
async function getProjectsHighPriority() {
let getProjectsHighPriority =
await DataProject.getProjectsHighPriority();
console.log(getProjectsHighPriority);
}
getProjectsHighPriority().then()
async function getProjectsMediumPriority() {
let getProjectsMediumPriority =
await DataProject.getProjectsMediumPriority();
console.log(getProjectsMediumPriority);
}
getProjectsMediumPriority().then()
async function getProjectsLowPriority() {
let getProjectsLowPriority =
await DataProject.getProjectsLowPriority();
console.log(getProjectsLowPriority);
}
getProjectsLowPriority().then()
async function getProjects() {
let getProjects =
await DataProject.getProjects();
console.log(getProjects);
}
getProjects().then()
async function getProjectById() {
let getProjectById =
await DataProject.getProjectById(1);
console.log(getProjectById);
}
getProjectById().then()
async function getProjectByStatus() {
let getProjectByStatus =
await DataProject.getProjectByStatus("Compl");
console.log(getProjectByStatus);
}
getProjectByStatus().then()
async function getProjectsByClientName() {
let getProjectsByClientName =
await DataProject.getProjectsByClientName("Client2");
console.log(getProjectsByClientName);
}
getProjectsByClientName().then()
async function getProjectsByManagerName() {
let getProjectsByManagerName =
await DataProject.getProjectsByManagerName("Projectmanager1");
console.log(getProjectsByManagerName);
}
getProjectsByManagerName().then()
async function getProjectsByDateRange() {
let startdate='2023-06-26';
let enddate='2023-08-26';
let getProjectsByDateRange =
await DataProject.getProjectsByDateRange(startdate,enddate);
console.log(getProjectsByDateRange);
}
getProjectsByDateRange().then()
async function getProjectsByBudgetRange() {
let minbudget=0;
let maxbudget=500;
let getProjectsByBudgetRange =
await DataProject.getProjectsByBudgetRange(minbudget,maxbudget);
console.log(getProjectsByBudgetRange);
}
getProjectsByBudgetRange().then()
async function getProjectsOverdue() {
let getProjectsOverdue =
await DataProject.getProjectsOverdue();
console.log(getProjectsOverdue);
}
getProjectsOverdue().then()
async function calculateProjectDuration() {
let calculateProjectDuration =
await DataProject.calculateProjectDuration(1);
console.log(calculateProjectDuration);
}
calculateProjectDuration().then()
async function getProjectsSearchNameDesc() {
let getProjectsSearchNameDesc =
await DataProject.getProjectsSearchNameDesc("1","");
console.log(getProjectsSearchNameDesc);
}
getProjectsSearchNameDesc().then()
async function getProjectWithMostTasks() {
let getProjectWithMostTasks =
await DataProject.getProjectWithMostTasks();
console.log(getProjectWithMostTasks);
}
getProjectWithMostTasks().then()
async function getProjectsByMember() {
let getProjectsByMember =
await DataProject.getProjectsByMember(6);
console.log(getProjectsByMember);
}
getProjectsByMember().then()
async function getProjectByDepartament() {
let getProjectByDepartament =
await DataProject.getProjectByDepartament('Department2');
console.log(getProjectByDepartament);
}
getProjectByDepartament().then()
async function getProjectsSumary() {
let getProjectsSumary =
await DataProject.getProjectsSumary();
console.log(getProjectsSumary);
}
getProjectsSumary().then()
async function getProjectBetweenIds() {
let getProjectBetweenIds =
await DataProject.getProjectBetweenIds(5,6);
console.log(getProjectBetweenIds);
}
getProjectBetweenIds().then()
#endregion PROJECTS
#region TASK
async function registerTask() {
for (let index = 1; index < 8; index++) {
let dtotask = new DTOTask();
dtotask.ID_project = index+1;
dtotask.Task_name = "Task_name" + index.toString();
dtotask.Descriptionn = "Descriptionn" + index.toString();
dtotask.Start_datee = `2023-07-1${index}`;
dtotask.End_date = `2023-08-1${index}`;
dtotask.Task_owner = "Task_owner" + index.toString();
dtotask.Priorityy = "Low";
dtotask.Hours_estimate = index+1;
let registerTask = await DataTask.registerTask(dtotask);
if (registerTask===-1) {
throw new
Error("The Priority must be High , Medium , Low ");
}
if (registerTask===-2) {
throw new
Error("The End Date must be higher than Start Date");
}
if (registerTask===-3) {
throw new
Error("The Project does not exists");
}
console.log("Task registered successfully");
}
}
registerTask().then()
async function updateDescriptionNameTask() {
let idtask = 1;
let taskname = "TaskNameUpdate";
let descriptiontask = "ProjectDescriptionnTaskUpdate";
let updateDescriptionNameTask =
await DataTask.updateDescriptionNameTask(idtask,taskname,descriptiontask);
if (updateDescriptionNameTask===-1) {
throw new
Error("The Task does not exists");
}
console.log("Task updated successfully");
}
updateDescriptionNameTask().then()
async function updateEndDateTask() {
let idtask = 9;
let end_date = '2023-08-30';
let updateEndDateTask =
await DataTask.updateEndDateTask(idtask,end_date);
if (updateEndDateTask===-1) {
throw new
Error("The Task does not exists");
}
if (updateEndDateTask===-2) {
throw new
Error("The End Date must be higher than Start Date");
}
console.log("Task updated successfully");
}
updateEndDateTask().then()
async function updatePriorityTask() {
let idtask = 8;
let priority = 'High';
let updatePriorityTask =
await DataTask.updatePriorityTask(idtask,priority);
if (updatePriorityTask===-1) {
throw new
Error("The Task does not exists");
}
if (updatePriorityTask===-2) {
throw new
Error("The Priority must be High , Medium , Low");
}
console.log("Task updated successfully");
}
updatePriorityTask().then()
async function updateTaskOwner() {
let idtask = 17;
let Task_owner = 'TaskOwnerNameUpdate';
let updateTaskOwner =
await DataTask.updateTaskOwner(idtask,Task_owner);
if (updateTaskOwner===-1) {
throw new
Error("The Task does not exists");
}
console.log("Task updated successfully");
}
updateTaskOwner().then()
async function completeTask() {
let idtask = 8;
let completeTask =
await DataTask.completeTask(idtask);
if (completeTask===-1) {
throw new
Error("The Task does not exists");
}
console.log("Task updated successfully");
}
completeTask().then()
async function onholdTask() {
let idtask = 9;
let onholdTask =
await DataTask.onholdTask(idtask);
if (onholdTask===-1) {
throw new
Error("The Task does not exists");
}
console.log("Task updated successfully");
}
onholdTask().then()
async function cancelTask() {
let idtask = 10;
let cancelTask =
await DataTask.cancelTask(idtask);
if (cancelTask===-1) {
throw new
Error("The Task does not exists");
}
console.log("Task updated successfully");
}
cancelTask().then()
async function getTaskById() {
let getTaskById =
await DataTask.getTaskById(1);
console.log(getTaskById);
}
getTaskById().then()
async function getTaskByStatus() {
let getTaskByStatus =
await DataTask.getTaskByStatus("On");
console.log(getTaskByStatus);
}
getTaskByStatus().then()
async function getTaskByOwnerName() {
let getTaskByOwnerName =
await DataTask.getTaskByOwnerName("Task_owner6");
console.log(getTaskByOwnerName);
}
getTaskByOwnerName().then()
async function getTasks() {
let getTasks =
await DataTask.getTasks();
console.log(getTasks);
}
getTasks().then()
async function getTasksByProject() {
let getTasksByProject =
await DataTask.getTasksByProject(8);
if (getTasksByProject===-1) {
throw new
Error("The Project does not exists");
}
console.log(getTasksByProject);
}
getTasksByProject().then()
async function getTasksHighPriority() {
let getTasksHighPriority =
await DataTask.getTasksHighPriority();
console.log(getTasksHighPriority);
}
getTasksHighPriority().then()
async function getProjectsMediumPriority() {
let getProjectsMediumPriority =
await DataTask.getProjectsMediumPriority();
console.log(getProjectsMediumPriority);
}
getProjectsMediumPriority().then()
async function getProjectsLowPriority() {
let getProjectsLowPriority =
await DataTask.getProjectsLowPriority();
console.log(getProjectsLowPriority);
}
getProjectsLowPriority().then()
async function getTasksByDateRange() {
let startdate='2023-06-26';
let enddate='2023-07-26';
let getTasksByDateRange =
await DataTask.getTasksByDateRange(startdate,enddate);
console.log(getTasksByDateRange);
}
getTasksByDateRange().then()
async function getTasksSearchNameDesc() {
let getTasksSearchNameDesc =
await DataTask.getTasksSearchNameDesc("","");
console.log(getTasksSearchNameDesc);
}
getTasksSearchNameDesc().then()
async function getTasksOverdue() {
let getTasksOverdue =
await DataTask.getTasksOverdue();
console.log(getTasksOverdue);
}
getTasksOverdue().then()
async function getAssignedTasks() {
let getAssignedTasks =
await DataTask.getAssignedTasks(6);
console.log(getAssignedTasks);
}
getAssignedTasks().then()
async function getAssignedTasks() {
let getAssignedTasks =
await DataTask.getAssignedTasks(6);
console.log(getAssignedTasks);
}
getAssignedTasks().then()
async function getTaskProgress() {
let getTaskProgress =
await DataTask.getTaskProgress(1);
console.log(getTaskProgress);
}
getTaskProgress().then()
async function getTasksByDepartment() {
let getTasksByDepartment =
await DataTask.getTasksByDepartment("Department2");
console.log(getTasksByDepartment);
}
getTasksByDepartment().then()
async function getTasksGanttChart() {
let getTasksGanttChart =
await DataTask.getTasksGanttChart(3);
console.log(getTasksGanttChart);
}
getTasksGanttChart().then()
async function getTasksUnfinished() {
let getTasksUnfinished =
await DataTask.getTasksUnfinished();
console.log(getTasksUnfinished);
}
getTasksUnfinished().then()
async function getTaskByBetweenId() {
let getTaskByBetweenId =
await DataTask.getTaskByBetweenId(5,8);
console.log(getTaskByBetweenId);
}
getTaskByBetweenId().then()
#endregion TASK
region MEMBERS
async function registerMember() {
for (let index = 1; index < 20; index++) {
let dtomember = new DTOMember();
dtomember.First_name = "First_name" + index.toString();
dtomember.Last_name = "Last_name" + index.toString();
dtomember.Department = `Department${index}`;
dtomember.Email = `email${index}@gmail.com`;
dtomember.Position = `Position${index}`;
let registerMember = await DataMember.registerMember(dtomember);
if (registerMember===-1) {
throw new
Error("Incorrect Email");
}
if (registerMember===-2) {
throw new
Error("Email already exists in the system");
}
console.log("Member registered successfully");
}
}
registerMember().then()
async function updateMemberName() {
let idmember = 12;
let memberfirstname = "FirstNameUpdate";
let memberlastname = "LastNameUpdate";
let updateMemberName =
await DataMember.updateMemberName(idmember,memberfirstname,memberlastname);
if (updateMemberName===-1) {
throw new
Error("The Memmber does not exists");
}
console.log("Memmber updated successfully");
}
updateMemberName().then()
async function updateMemberDepartament() {
let idmember = 11;
let departament = "DepartamentUpdate";
let updateMemberDepartament =
await DataMember.updateMemberDepartament(idmember,departament);
if (updateMemberDepartament===-1) {
throw new
Error("The Memmber does not exists");
}
console.log("Member updated successfully");
}
updateMemberDepartament().then()
async function updateMemberPosition() {
let idmember = 12;
let position = "PositionUpdate";
let updateMemberPosition =
await DataMember.updateMemberPosition(idmember,position);
if (updateMemberPosition===-1) {
throw new
Error("The Memmber does not exists");
}
console.log("Member updated successfully");
}
updateMemberPosition().then()
async function getMemberById() {
let getMemberById =
await DataMember.getMemberById(11);
console.log(getMemberById);
}
getMemberById().then()
async function getMemberByPosition() {
let getMemberByPosition =
await DataMember.getMemberByPosition("Position7");
console.log(getMemberByPosition);
}
getMemberByPosition().then()
async function getMemberByDepartament() {
let getMemberByDepartament =
await DataMember.getMemberByDepartament("Department19");
console.log(getMemberByDepartament);
}
getMemberByDepartament().then()
async function getMemberByName() {
let getMemberByName =
await DataMember.getMemberByName("","");
console.log(getMemberByName);
}
getMemberByName().then()
async function getMemberAll() {
let getMemberAll =
await DataMember.getMemberAll();
console.log(getMemberAll);
}
getMemberAll().then()
async function getMembersByTask() {
let getMembersByTask =
await DataMember.getMembersByTask(6);
console.log(getMembersByTask);
}
getMembersByTask().then()
async function getMembersByProject() {
let getMembersByProject =
await DataMember.getMembersByProject(6);
console.log(getMembersByProject);
}
getMembersByProject().then()
async function getMemberProductivity() {
let getMemberProductivity =
await DataMember.getMemberProductivity(2);
console.log(getMemberProductivity);
}
getMemberProductivity().then()
async function getMemberCompletedPercentage() {
let getMemberCompletedPercentage =
await DataMember.getMemberCompletedPercentage(2);
console.log(getMemberCompletedPercentage);
}
getMemberCompletedPercentage().then()
async function getMemberUnassignedInProject() {
let getMemberUnassignedInProject =
await DataMember.getMembersUnassignedInProject(1);
console.log(getMemberUnassignedInProject);
}
getMemberUnassignedInProject().then()
async function getMembersOverallocated() {
let getMembersOverallocated =
await DataMember.getMembersOverallocated(3);
console.log(getMembersOverallocated);
}
getMembersOverallocated().then()
async function getMemberBetweenId() {
let getMemberBetweenId =
await DataMember.getMemberBetweenId(3,5);
console.log(getMemberBetweenId);
}
getMemberBetweenId().then()
#endregion MEMBERS
#region ASSIGNMENTS
async function registerAssignments() {
let dtoAssignments = new DTOAssignments();
dtoAssignments.ID_member = 2;
dtoAssignments.ID_task = 2;
dtoAssignments.Worked_hours = 1;
dtoAssignments.Assignment_date = `2023-07-11`;
let registerAssignments = await DataAssignments.registerAssignments
(dtoAssignments);
if (registerAssignments===-1) {
throw new
Error("Task not Found");
}
if (registerAssignments===-2) {
throw new
Error("Member not Found");
}
if (registerAssignments===-3) {
throw new
Error("The assignment date must be greater than or equal to the current date");
}
if (registerAssignments===-4) {
throw new
Error("The hours worked for that task exceeds the estimated hours of the task ");
}
console.log("Assignment registered successfully");
}
registerAssignments().then()
async function updateAssignmentDate() {
let ID_assignment = 11;
let Assignment_date = `2023-07-07`;
let updateAssignmentDate = await DataAssignments.updateAssignmentDate
(ID_assignment,Assignment_date);
if (updateAssignmentDate===-1) {
throw new
Error("Assignment not Found");
}
if (updateAssignmentDate===-2) {
throw new
Error("The assignment date must be greater than or equal to the current date");
}
console.log("Assignment updated successfully");
}
updateAssignmentDate().then()
async function updateAssignmentWorked_hours() {
let ID_assignment = 11;
let Worked_hours = 5;
let updateAssignmentWorked_hours =
await DataAssignments.updateAssignmentWorked_hours
(ID_assignment,Worked_hours);
if (updateAssignmentWorked_hours===-1) {
throw new
Error("Assignment not Found");
}
console.log("Assignment updated successfully");
}
updateAssignmentWorked_hours().then()
async function getAssignments() {
let getAssignments =
await DataAssignments.getAssignments();
console.log(getAssignments);
}
getAssignments().then()
async function getAssignmentById() {
let getAssignmentById =
await DataAssignments.getAssignmentById(2);
console.log(getAssignmentById);
}
getAssignmentById().then()
async function getAssignmentByTask() {
let getAssignmentByTask =
await DataAssignments.getAssignmentByTask(2);
console.log(getAssignmentByTask);
}
getAssignmentByTask().then()
async function getAssignmentByMember() {
let getAssignmentByMember =
await DataAssignments.getAssignmentByMember(1);
console.log(getAssignmentByMember);
}
getAssignmentByMember().then()
async function getAssignmentByDepartment() {
let getAssignmentByDepartment =
await DataAssignments.getAssignmentByDepartment("Department1");
console.log(getAssignmentByDepartment);
}
getAssignmentByDepartment().then()
async function getAssignmentByWorkedHours() {
let getAssignmentByWorkedHours =
await DataAssignments.getAssignmentByWorkedHours(1);
console.log(getAssignmentByWorkedHours);
}
getAssignmentByWorkedHours().then()
async function getAssignmentByCountByMember() {
let getAssignmentByCountByMember =
await DataAssignments.getAssignmentByCountByMember();
console.log(getAssignmentByCountByMember);
}
getAssignmentByCountByMember().then()
async function getAssignmentByCountByTask() {
let getAssignmentByCountByTask =
await DataAssignments.getAssignmentByCountByTask();
console.log(getAssignmentByCountByTask);
}
getAssignmentByCountByTask().then()
async function getTotalWorkedHoursByTaskAndMember() {
let getTotalWorkedHoursByTaskAndMember =
await DataAssignments.getTotalWorkedHoursByTaskAndMember();
console.log(getTotalWorkedHoursByTaskAndMember);
}
getTotalWorkedHoursByTaskAndMember().then()
async function getAssignmentsBetweenDates() {
let startdate='2023-06-26';
let enddate='2023-08-26';
let getAssignmentsBetweenDates =
await DataAssignments.getAssignmentsBetweenDates(startdate,enddate);
console.log(getAssignmentsBetweenDates);
}
getAssignmentsBetweenDates().then()
async function getAssignmentsBetweenWorked_hours() {
let MinWorked_hours=0;
let MaxWorked_hours=999;
let getAssignmentsBetweenWorked_hours =
await DataAssignments.getAssignmentsBetweenWorked_hours(MinWorked_hours,MaxWorked_hours);
console.log(getAssignmentsBetweenWorked_hours);
}
getAssignmentsBetweenWorked_hours().then()
async function getAssignmentsStatistics() {
let getAssignmentsStatistics =
await DataAssignments.getAssignmentsStatistics();
console.log(getAssignmentsStatistics);
}
getAssignmentsStatistics().then()
async function getMembersOverallocated() {
let getMembersOverallocated =
await DataAssignments.getTotalWorkedHoursByMember(1);
console.log(getMembersOverallocated);
}
getMembersOverallocated().then()
#endregion ASSIGNMENTS
#region MILESTONE
async function registerMilestone() {
for (let index = 8; index < 17; index++) {
let dtoMilestone = new DTOMilestone();
dtoMilestone.ID_project = 5;
dtoMilestone.Milestone_name = "Milestone_name"+index.toString();
dtoMilestone.Descriptionn = "Description"+index.toString();
dtoMilestone.Date = `2023-07-${index}`;
let registerMilestone = await DataMilestone.registerMilestone
(dtoMilestone);
if (registerMilestone===-1) {
throw new
Error("Project not Found");
}
console.log("Milestone registered successfully");
}
}
registerMilestone().then()
async function updateNameDescriptionMilestone() {
let idmilestone = 22;
let namemilestone = "MilestoneNameUpdate";
let descriptionmilestone = "DescriptionnMilestoneUpdate";
let updateNameDescriptionMilestone =
await DataMilestone.updateNameDescriptionMilestone
(idmilestone,namemilestone,descriptionmilestone);
if (updateNameDescriptionMilestone===-1) {
throw new
Error("The Milestone does not exists");
}
console.log("Milestone updated successfully");
}
updateNameDescriptionMilestone().then()
async function updateDateMilestone() {
let idmilestone = 22;
let datemilestone = '2023-07-14';
let updateDateMilestone =
await DataMilestone.updateDateMilestone
(idmilestone,datemilestone);
if (updateDateMilestone===-1) {
throw new
Error("The Milestone does not exists");
}
console.log("Milestone updated successfully");
}
updateDateMilestone().then()
async function completeMilestone() {
let idmilestone = 23;
let completeMilestone =
await DataMilestone.completeMilestone
(idmilestone);
if (completeMilestone===-1) {
throw new
Error("The Milestone does not exists");
}
console.log("Milestone updated successfully");
}
completeMilestone().then()
async function cancelMilestone() {
let idmilestone = 22;
let cancelMilestone =
await DataMilestone.cancelMilestone
(idmilestone);
if (cancelMilestone===-1) {
throw new
Error("The Milestone does not exists");
}
console.log("Milestone updated successfully");
}
cancelMilestone().then()
async function onholdMilestone() {
let idmilestone = 22;
let onholdMilestone =
await DataMilestone.onholdMilestone
(idmilestone);
if (onholdMilestone===-1) {
throw new
Error("The Milestone does not exists");
}
console.log("Milestone updated successfully");
}
onholdMilestone().then()
async function getMilestoneById() {
let getMilestoneById =
await DataMilestone.getMilestoneById(12);
if (getMilestoneById===-1) {
throw new
Error("Milestone not Found");
}
console.log(getMilestoneById);
}
getMilestoneById().then()
async function getMilestoneByProject() {
let getMilestoneByProject =
await DataMilestone.getMilestoneByProject(7);
if (getMilestoneByProject===-1) {
throw new
Error("Milestone not Found");
}
console.log(getMilestoneByProject);
}
getMilestoneByProject().then()
async function getMilestoneByStatus() {
let getMilestoneByStatus =
await DataMilestone.getMilestoneByStatus("on Hold");
console.log(getMilestoneByStatus);
}
getMilestoneByStatus().then()
async function getMilestoneByDateRange() {
let startdate='2023-07-06';
let enddate='2023-07-16';
let getMilestoneByDateRange =
await DataMilestone.getMilestoneByDateRange(startdate,enddate);
console.log(getMilestoneByDateRange);
}
getMilestoneByDateRange().then()
async function getMilestoneSearch() {
let getMilestoneSearch =
await DataMilestone.getMilestoneSearch("10");
console.log(getMilestoneSearch);
}
getMilestoneSearch().then()
#endregion MILESTONE
#region RESOURCES
async function registerResource() {
for (let index = 10; index < 30; index++) {
let dtoresource = new DTOResource();
dtoresource.Resource_name = "Resource_name" + index.toString();
dtoresource.Descriptionn = "Descriptionn" + index.toString();
dtoresource.Unit_cost = index;
dtoresource.Available_quantity = 50+index;
let registerResource = await DataResource.registerResource(dtoresource)
if (registerResource===-1) {
throw new
Error("Unit price must be greater than 0");
}
if (registerResource===-2) {
throw new
Error("Available quantity must be greater than 0");
}
console.log("Resource registered successfully");
}
}
registerResource().then()
async function updateResourceDescriptionName() {
let idresource = 17;
let nameresource = "ResourceNameUpdate";
let descriptionresource = "DescriptionResourceUpdate";
let updateResourceDescriptionName =
await DataResource.updateResourceDescriptionName
(idresource,nameresource,descriptionresource);
if (updateResourceDescriptionName===-1) {
throw new
Error("The Resource does not exists");
}
console.log("Resource updated successfully");
}
updateResourceDescriptionName().then()
async function updateResourceUnitCost() {
let idresource = 17;
let unitcost = 20;
let updateResourceUnitCost =
await DataResource.updateResourceUnitCost
(idresource,unitcost);
if (updateResourceUnitCost===-1) {
throw new
Error("The Resource does not exists");
}
console.log("Resource updated successfully");
}
updateResourceUnitCost().then()
async function addAvaialableQuantity() {
let idresource = 17;
let quantity = 5;
let addAvaialableQuantity =
await DataResource.addAvailableQuantity
(idresource,quantity);
if (addAvaialableQuantity===-1) {
throw new
Error("The Resource does not exists");
}
console.log("Resource updated successfully");
}
addAvaialableQuantity().then()
async function substractAvailableQuantity() {
let idresource = 17;
let quantity = 7;
let substractAvailableQuantity =
await DataResource.substractAvailableQuantity
(idresource,quantity);
if (substractAvailableQuantity===-1) {
throw new
Error("The Resource does not exists");
}
if (substractAvailableQuantity===-2) {
throw new
Error("The quantity must be less than the available quantity of the resource");
}
console.log("Resource updated successfully");
}
substractAvailableQuantity().then()
async function geResourceBetweenIds() {
let geResourceBetweenIds =
await DataResource.geResourceBetweenIds(4,5);
console.log(geResourceBetweenIds);
}
geResourceBetweenIds().then()
async function getResourceSearchNameDesc() {
let getResourceSearchNameDesc =
await DataResource.getResourceSearchNameDesc("15");
console.log(getResourceSearchNameDesc);
}
getResourceSearchNameDesc().then()
async function getResourceBetweenUnitCost() {
let getResourceBetweenUnitCost =
await DataResource.getResourceBetweenUnitCost(10,15);
console.log(getResourceBetweenUnitCost);
}
getResourceBetweenUnitCost().then()
async function getResourceBetweenQuantity() {
let getResourceBetweenQuantity =
await DataResource.getResourceBetweenQuantity(61,68);
console.log(getResourceBetweenQuantity);
}
getResourceBetweenQuantity().then()
#endregion RESOURCES
#region RESOURCE ASSIGMENT
async function registerResourceAssignment() {
for (let index = 1; index < 8; index++) {
let dtoResourceAssignment = new DTOResourceAssignment();
dtoResourceAssignment.ID_task = index;
dtoResourceAssignment.ID_resource = index ;
dtoResourceAssignment.Assigned_quantity =index ;
let registerResourceAssignment =
await DataResourceAssignments.registerResourceAssignment
(dtoResourceAssignment);
if (registerResourceAssignment===-1) {
throw new
Error("Task not Found");
}
if (registerResourceAssignment===-2) {
throw new
Error("Resource not Found");
}
if (registerResourceAssignment===-3) {
throw new
Error("The quantity must be higher than 0");
}
if (registerResourceAssignment===-4) {
throw new
Error("The available quantity must be higher than the assigned quantity");
}
console.log("Resource Assignment registered successfully");
}
}
registerResourceAssignment().then()
async function getResourceAssignmentBetweenIds() {
let getResourceAssignmentBetweenIds =
await DataResourceAssignments.getResourceAssignmentBetweenIds(3,6);
console.log(getResourceAssignmentBetweenIds);
}
getResourceAssignmentBetweenIds().then()
async function getResourceAssignmentBetweenTaskIds() {
let getResourceAssignmentBetweenTaskIds =
await DataResourceAssignments.getResourceAssignmentBetweenTaskIds(3,5);
console.log(getResourceAssignmentBetweenTaskIds);
}
getResourceAssignmentBetweenTaskIds().then()
async function getResourceAssignmentBetweenResourceIds() {
let getResourceAssignmentBetweenResourceIds =
await DataResourceAssignments.getResourceAssignmentBetweenResourceIds(3,5);
console.log(getResourceAssignmentBetweenResourceIds);
}
getResourceAssignmentBetweenResourceIds().then()
async function getResourceAssignmentBetweenQuantity() {
let getResourceAssignmentBetweenQuantity =
await DataResourceAssignments.getResourceAssignmentBetweenQuantity(3,5);
console.log(getResourceAssignmentBetweenQuantity);
}
getResourceAssignmentBetweenQuantity().then()
async function getResourceAvailabilityBetweenIds() {
let getResourceAvailabilityBetweenIds =
await DataResourceAssignments.getResourceAvailabilityBetweenIds(3,5);
console.log(getResourceAvailabilityBetweenIds);
}
getResourceAvailabilityBetweenIds().then()
async function getResourceAvailabilityTotalCostByProject() {
let getResourceAvailabilityTotalCostByProject =
await DataResourceAssignments.getResourceAvailabilityTotalCostByProject(5);
console.log(getResourceAvailabilityTotalCostByProject);
}
getResourceAvailabilityTotalCostByProject().then()
#endregion RESOURCE ASSIGMENT
#region COMMENTS
async function registerComments() {
for (let index = 5; index < 8; index++) {
let dtocomment = new DTOComments();
dtocomment.ID_member = index ;
dtocomment.ID_task =index ;
dtocomment.Comment_date =`2023-11-14` ;
dtocomment.Content =`Content${index}` ;
let registerComment =
await DataComments.registerComment
(dtocomment);
if (registerComment===-1) {
throw new
Error("Task not Found");
}
if (registerComment===-2) {
throw new
Error("Member not Found");
}
console.log("Comment registered successfully");
}
}
registerComments().then()
async function updateComment() {
let idcomment = 8;
let content = "CommentUpdate";
let updateComment =
await DataComments.updateComment(idcomment,content);
if (updateComment===-1) {
throw new
Error("Comment Not Found");
}
console.log("Comment updated successfully");
}
updateComment().then()
async function deleteComment() {
let idcomment = 50;
let deleteComment =
await DataComments.deleteComment(idcomment);
if (deleteComment===-1) {
throw new
Error("Comment Not Found");
}
console.log("Comment deleted successfully");
}
deleteComment().then()
async function getCommentById() {
let getCommentById =
await DataComments.getCommentById(8);
if (getCommentById===-1) {
throw new
Error("Comment Not Found");
}
console.log(getCommentById);
}
getCommentById().then()
async function getCommentsByTask() {
let getCommentsByTask =
await DataComments.getCommentsByTask(6);
console.log(getCommentsByTask);
}
getCommentsByTask().then()
async function getCommentsLatest() {
let getCommentsLatest =
await DataComments.getCommentsLatest();
console.log(getCommentsLatest);
}
getCommentsLatest().then()
#endregion COMMENTS
#region ATTACHMENTS
async function addAttachment() {
for (let index = 5; index < 8; index++) {
let dtoattachment = new DTOAttachments();
dtoattachment.ID_task =index ;
dtoattachment.File_namee =`FileName${index}` ;
dtoattachment.File_path =`FilePath${index}` ;
dtoattachment.Upload_date =`2023-11-15` ;
let addAttachments =
await DataAttachments.addAttachments
(dtoattachment);
if (addAttachments===-1) {
throw new
Error("Task not Found");
}
console.log("Attachment registered successfully");
}
}
addAttachment().then()
async function deleteAttachment() {
let idattachment = 4;
let deleteAttachment =
await DataAttachments.deleteAttachment(idattachment);
if (deleteAttachment===-1) {
throw new
Error("Attachment Not Found");
}
console.log("Attachment deleted successfully");
}
deleteAttachment().then()
async function getAttachmentById() {
let getAttachmentById =
await DataAttachments.getAttachmentById(5);
if (getAttachmentById===-1) {
throw new
Error("Attachment Not Found");
}
console.log(getAttachmentById);
}
getAttachmentById().then()
async function getAttachmentByTask() {
let getAttachmentByTask =
await DataAttachments.getAttachmentByTask(7);
console.log(getAttachmentByTask);
}
getAttachmentByTask().then()
#endregion ATTACHMENTS