Skip to content

M
mytime
Commit c63bc59d authored by Vijay Akula's avatar Vijay Akula
Browse files
Options

Refactored the code for Project Resources and Billing with their 

respective Controller Service and Repository layers
parent cf947c85
Hide whitespace changes
Inline Side-by-side
Showing with 1365 additions and 1359 deletions
src/main/java/com/nisum/mytime/controller/BillingController.java 0 → 100644
View file @ c63bc59d
package com.nisum.mytime.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Billing;
import com.nisum.mytime.service.IBillingService;
import lombok.extern.slf4j.Slf4j;
@RestController
@Slf4j
public class BillingController {
@Autowired
private IBillingService billingService;
// @RequestMapping(value = "/addEmployeeBilling"
@RequestMapping(value = "/billing", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Billing> addEmployeeBilling(@RequestBody Billing billing,
@RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
Billing billingList = billingService.addBilling(billing, loginEmpId);
return new ResponseEntity<>(billingList, HttpStatus.OK);
}
// @RequestMapping(value = "/updateEmployeeBilling",
@RequestMapping(value = "/billing", method = RequestMethod.PUT, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Billing> updateEmployeeBilling(@RequestBody Billing billing,
@RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
Billing billingList = billingService.updateBilling(billing, loginEmpId);
return new ResponseEntity<>(billingList, HttpStatus.OK);
}
// @RequestMapping(value = "/deleteEmployeeBilling"
@RequestMapping(value = "/billing", method = RequestMethod.DELETE, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Billing> deleteEmployeeBilling(@RequestBody Billing billing) throws MyTimeException {
billingService.deleteBilling(billing);
return new ResponseEntity<>(null, HttpStatus.OK);
}
// @RequestMapping(value = "/getEmployeeBillingDetailsAll"
@RequestMapping(value = "/billing", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Billing>> getAllBillingsForEmployee(@RequestParam("employeeId") String employeeId)
throws MyTimeException {
List<Billing> billingList = billingService.getBillingsForEmployee(employeeId);
return new ResponseEntity<>(billingList, HttpStatus.OK);
}
// @RequestMapping(value = "/getEmployeeBillingDetails"
@RequestMapping(value = "/billing/project/{projectId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Billing>> getBillingsForProject(@PathVariable("projectId") String projectId,
@RequestParam("employeeId") String employeeId) throws MyTimeException {
List<Billing> billingList = billingService.getBillingsForProject(employeeId, projectId);
return new ResponseEntity<>(billingList, HttpStatus.OK);
}
}
src/main/java/com/nisum/mytime/controller/EmployeeController.java
View file @ c63bc59d
package com.nisum.mytime.controller;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
......@@ -213,5 +214,19 @@ public class EmployeeController {
return new ResponseEntity<ResponseDetails>(getRespDetails, HttpStatus.OK);
}
@RequestMapping(value = "/employees/active/sortByName", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Employee>> getActiveEmployeesSortByName() throws MyTimeException {
List<Employee> employeesList = new ArrayList<>();
if (empService.getActiveEmployees() != null) {
employeesList = empService.getActiveEmployees().stream()
.sorted((o1, o2) -> o1.getEmployeeName().compareTo(o2.getEmployeeName()))
.collect(Collectors.toList());
}
return new ResponseEntity<>(employeesList, HttpStatus.OK);
}
}
\ No newline at end of file
src/main/java/com/nisum/mytime/controller/ProjectController.java
View file @ c63bc59d
......@@ -12,78 +12,75 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Account;
import com.nisum.mytime.model.Employee;
import com.nisum.mytime.model.Project;
import com.nisum.mytime.repository.AccountRepo;
import com.nisum.mytime.repository.ProjectRepo;
import com.nisum.mytime.service.IProjectService;
import com.nisum.mytime.service.IEmployeeService;
import com.nisum.mytime.service.IProjectService;
import com.nisum.mytime.utils.MyTimeUtils;
import lombok.extern.slf4j.Slf4j;
@RestController
@RequestMapping("/project")
@Slf4j
public class ProjectController {
@Autowired
private IEmployeeService userService;
private IEmployeeService employeeService;
@Autowired
private IProjectService projectService;
@Autowired
private AccountRepo accountRepo;
@Autowired
private ProjectRepo projectRepo;
@RequestMapping(value = "/employee", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Employee> getEmployeeRole(@RequestParam("emailId") String emailId)
throws MyTimeException {
Employee employeesRole = userService.getEmployeeByEmaillId(emailId);
return new ResponseEntity<>(employeesRole, HttpStatus.OK);
}
@RequestMapping(value = "/addProject", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<?> addProject(@RequestBody Project projectAdded,
@RequestMapping(value = "/projects", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<?> createProject(@RequestBody Project projectReq,
@RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
// checking project duplicateName
int projectNameCount=0;
if (projectAdded.getAccountId() != null) {
List<Project> projects = projectRepo.findByDomainId(projectAdded.getDomainId());
int projectNameCount = 0;
if (projectReq.getAccountId() != null) {
List<Project> projects=projectService.getProjectsUnderDomain(projectReq.getDomainId());
for (Project existproject : projects) {
if (projectAdded.getProjectName().equalsIgnoreCase(existproject.getProjectName()))
projectNameCount++;
}
if (projectReq.getProjectName().equalsIgnoreCase(existproject.getProjectName()))
projectNameCount++;
}
}
if (projectNameCount > MyTimeUtils.INT_ZERO){
MyTimeException myTimeException= new MyTimeException("Project name already exist !!! try with new");
if (projectNameCount > MyTimeUtils.INT_ZERO) {
MyTimeException myTimeException = new MyTimeException("Project name already exist !!! try with new");
return new ResponseEntity<>(myTimeException, HttpStatus.OK);
}else{
String accountName="";
String accountId=projectAdded.getAccountId();
// String accountName=projectAdded.getAccount();
Account account= accountRepo.findByAccountId(accountId);
if(account!=null)
accountName=account.getAccountName();
int sequenceNumber= account.getAccountProjectSequence();
account.setAccountProjectSequence(sequenceNumber+1);
//account.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
accountRepo.save(account);
String projectId= accountName+String.format("%04d", sequenceNumber+1);
projectAdded.setProjectId(projectId);
Project project = projectService.addProject(projectAdded, loginEmpId);
return new ResponseEntity<>(project, HttpStatus.OK);
} else {
String accountName = "";
String accountId = projectReq.getAccountId();
// String accountName=projectAdded.getAccount();
Account account = accountRepo.findByAccountId(accountId);
if (account != null)
accountName = account.getAccountName();
int sequenceNumber = account.getAccountProjectSequence();
account.setAccountProjectSequence(sequenceNumber + 1);
// account.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
accountRepo.save(account);
String projectId = accountName + String.format("%04d", sequenceNumber + 1);
projectReq.setProjectId(projectId);
Project project = projectService.createProject(projectReq, loginEmpId);
return new ResponseEntity<>(project, HttpStatus.OK);
}
}
@RequestMapping(value = "/updateProject", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<?> updateProject(@RequestBody Project project,
// @RequestMapping(value = "/updateProject"
@RequestMapping(value = "/projects", method = RequestMethod.PUT, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<?> updateProject(@RequestBody Project project,
@RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
// checking project duplicateName
int projectNameCount=0;
int projectNameCount = 0;
if (project.getAccountId() != null) {
List<Project> projects = projectRepo.findByDomainId(project.getDomainId());
for (Project existproject : projects) {
......@@ -93,41 +90,57 @@ public class ProjectController {
}
}
}
if (projectNameCount>0)
{
MyTimeException myTimeException= new MyTimeException("Project name already exist !!! try with new");
if (projectNameCount > 0) {
MyTimeException myTimeException = new MyTimeException("Project name already exist !!! try with new");
return new ResponseEntity<>(myTimeException, HttpStatus.OK);
}
Project updatedProject = projectService.updateProject(project, loginEmpId);
return new ResponseEntity<>(updatedProject, HttpStatus.OK);
}
@RequestMapping(value = "/deleteProject", method = RequestMethod.DELETE, produces = MediaType.TEXT_PLAIN_VALUE)
// @RequestMapping(value = "/deleteProject"
@RequestMapping(value = "/deleteProject", method = RequestMethod.DELETE, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> deleteProject(@RequestParam("projectId") String projectId) throws MyTimeException {
projectService.deleteProject(projectId);
return new ResponseEntity<>("Success", HttpStatus.OK);
}
@RequestMapping(value = "/getProjects", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<HashMap<Object, Object>>> getProjects(@RequestParam(value="empId", required = false, defaultValue = MyTimeUtils.ZERO) String empId) throws MyTimeException {
// @RequestMapping(value = "/getProjects"
@RequestMapping(value = "/projects", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<HashMap<Object, Object>>> getProjects(
@RequestParam(value = "empId", required = false, defaultValue = MyTimeUtils.ZERO) String empId)
throws MyTimeException {
List<HashMap<Object, Object>> projects = null;
if(!"undefined".equalsIgnoreCase(empId) ) {
boolean isDl = userService.verifyEmployeeRole(empId,MyTimeUtils.DL) ;
if( isDl ){
if (!"undefined".equalsIgnoreCase(empId)) {
boolean isDl = employeeService.verifyEmployeeRole(empId, MyTimeUtils.DL);
if (isDl) {
projects = projectService.deliveryLeadProjects(empId);
}
}else {
} else {
projects = projectService.getProjects();
}
return new ResponseEntity<>(projects, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeeRoleData", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Employee> getEmployeeRoleData(@RequestParam("empId") String empId)
throws MyTimeException {
Employee employeesRole = userService.getEmployeeById(empId);
return new ResponseEntity<>(employeesRole, HttpStatus.OK);
@RequestMapping(value = "/projects/{deliveryLeadId}", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Project>> getProjectsUnderDeliveryLead(
@RequestParam("deliveryLeadId") String deliveryLeadId)
throws MyTimeException {
List<Project> projects = projectService.getProjectsUnderDeliveryLead(deliveryLeadId);
return new ResponseEntity<>(projects, HttpStatus.OK);
}
@RequestMapping(value = "/getMyProjectAllocations", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<HashMap<Object, Object>>> getMyProjectAllocations(
@RequestParam("employeeId") String employeeId) throws MyTimeException {
List<HashMap<Object, Object>> empPrjtsInfo = projectService.getProjectsForEmployee(employeeId);
return new ResponseEntity<>(empPrjtsInfo, HttpStatus.OK);
}
}
\ No newline at end of file
src/main/java/com/nisum/mytime/controller/ProjectTeamController.java deleted 100644 → 0
View file @ cf947c85
package com.nisum.mytime.controller;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Billing;
import com.nisum.mytime.model.EmployeeDashboardVO;
import com.nisum.mytime.model.Employee;
import com.nisum.mytime.model.EmployeeVisa;
import com.nisum.mytime.model.Project;
import com.nisum.mytime.model.Resource;
import com.nisum.mytime.repository.EmployeeVisaRepo;
import com.nisum.mytime.service.IProjectService;
import com.nisum.mytime.service.IEmployeeService;
import com.nisum.mytime.utils.MyTimeUtils;
@RestController
@RequestMapping("/projectTeam")
public class ProjectTeamController {
@Autowired
private IEmployeeService userService;
@Autowired
private IProjectService projectService;
@Autowired
private EmployeeVisaRepo employeeVisaRepo;
@RequestMapping(value = "/employee", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Employee> getEmployeeRole(
@RequestParam("emailId") String emailId) throws MyTimeException {
Employee employeesRole = userService.getEmployeeByEmaillId(emailId);
return new ResponseEntity<>(employeesRole, HttpStatus.OK);
}
@RequestMapping(value = "/addProject", method = RequestMethod.POST,
produces = MediaType.APPLICATION_JSON_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Project> addProject(
@RequestBody Project projectObj, @RequestParam(value="loginEmpId") String loginEmpId) throws MyTimeException {
Project project = projectService.addProject(projectObj, loginEmpId);
return new ResponseEntity<>(project, HttpStatus.OK);
}
@RequestMapping(value = "/updateEmployeeRole", method = RequestMethod.POST,
produces = MediaType.APPLICATION_JSON_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Employee> updateEmployeeRole(@RequestBody Employee emp,
@RequestParam(value="empId") String loginEmpId) throws MyTimeException {
Employee employeeRole = userService.updateEmployee(emp, loginEmpId);
return new ResponseEntity<>(employeeRole, HttpStatus.OK);
}
@RequestMapping(value = "/deleteEmployee", method = RequestMethod.DELETE,
produces = MediaType.TEXT_PLAIN_VALUE)
public ResponseEntity<String> deleteEmployee(
@RequestParam("empId") String empId) throws MyTimeException {
userService.deleteEmployee(empId);
return new ResponseEntity<>("Success", HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeeRoleData", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Employee> getEmployeeRoleData(
@RequestParam("empId") String empId) throws MyTimeException {
Employee employeesRole = userService.getEmployeeById(empId);
return new ResponseEntity<>(employeesRole, HttpStatus.OK);
}
//MT-72
@RequestMapping(value = "/getEmployeeProjectInfo", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getEmployeeProjectInfo(
@RequestParam("empId") String empId) throws MyTimeException {
List<Resource> projectInfo = projectService.getProjectInfo(empId);
return new ResponseEntity<>(projectInfo, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeesToTeam", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Employee>> getManagers()
throws MyTimeException {
List<Employee> employeesRoles = new ArrayList<>();
if (userService.getActiveEmployees() != null) {
employeesRoles = userService.getActiveEmployees().stream()
.sorted((o1, o2) -> o1.getEmployeeName()
.compareTo(o2.getEmployeeName()))
.collect(Collectors.toList());
}
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/getTeamDetails", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getTeamDetails(
@RequestParam("employeeId") String employeeId)
throws MyTimeException {
List<Resource> employeesRoles = projectService
.getTeamDetails(employeeId);
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/addEmployeeToTeam", method = RequestMethod.POST,
produces = MediaType.APPLICATION_JSON_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Resource> addEmployeeToTeam(
@RequestBody Resource teamMate, @RequestParam(value="loginEmpId", required = false) String loginEmpId) throws MyTimeException {
teamMate.setActive(true);
teamMate.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
Resource teamMateDB = projectService.addProjectTeamMate(teamMate, loginEmpId);
return new ResponseEntity<>(teamMateDB, HttpStatus.OK);
}
@RequestMapping(value = "/updateTeammate", method = RequestMethod.POST,
produces = MediaType.TEXT_PLAIN_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> updateTeammate(@RequestBody Resource projectTeamMate, @RequestParam(value = "loginEmpId") String loginEmpId)
throws MyTimeException {
projectTeamMate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
String response = projectService.updateTeammate(projectTeamMate, loginEmpId);
return new ResponseEntity<>(response, HttpStatus.OK);
}
@RequestMapping(value = "/deleteTeammate", method = RequestMethod.POST,
produces = MediaType.TEXT_PLAIN_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> deleteTeammate(
@RequestBody Resource projectTeamMate, @RequestParam(value = "loginEmpId") String loginEmpId)
throws MyTimeException {
projectService.deleteTeammate(projectTeamMate.getEmployeeId(),
projectTeamMate.getProjectId(), projectTeamMate.getId(), loginEmpId);
return new ResponseEntity<>("Success", HttpStatus.OK);
}
@RequestMapping(value = "/getProjects", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Project>> getProjects(
@RequestParam("employeeId") String employeeId)
throws MyTimeException {
List<Project> projects = projectService.getProjects(employeeId);
return new ResponseEntity<>(projects, HttpStatus.OK);
}
@RequestMapping(value = "/getMyTeamDetails", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getMyTeamDetails(
@RequestParam("employeeId") String employeeId)
throws MyTimeException {
List<Resource> employeesRoles = projectService
.getMyTeamDetails(employeeId);
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/getUnAssignedEmployees",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Employee>> getUnAssignedEmployees()
throws MyTimeException {
List<Employee> employeesRoles = projectService
.getUnAssignedEmployees();
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/getShiftDetails", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getShiftDetails(
@RequestParam("shift") String shift) throws MyTimeException {
List<Resource> employeesRoles = projectService
.getShiftDetails(shift);
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/getProjectAllocations",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getProjectAllocations()
throws MyTimeException {
List<Resource> employeesRoles = projectService
.getAllProjectDetails();
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/getProjectDetails", method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getProjectDetails(
@RequestParam("projectId") String projectId,
@RequestParam(value = "status", required = false, defaultValue = MyTimeUtils.ACTIVE) String status)
throws MyTimeException {
List<Resource> employeesRoles = projectService
.getProjectDetails(projectId,status);
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/getMyProjectAllocations",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<HashMap<Object, Object>>> getMyProjectAllocations(
@RequestParam("employeeId") String employeeId)
throws MyTimeException {
// List<ProjectTeamMate> projectAllocations = projectService
// .getMyProjectAllocations(employeeId);
List<HashMap<Object, Object>> empPrjtsInfo = projectService.projectsInfoByEmpId(employeeId);
return new ResponseEntity<>(empPrjtsInfo, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeeBillingDetails",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Billing>> getEmployeeBillingDetails(
@RequestParam("employeeId") String employeeId,
@RequestParam("projectId") String projectId)
throws MyTimeException {
List<Billing> billings = projectService
.getEmployeeBillingDetails(employeeId, projectId);
return new ResponseEntity<>(billings, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeeBillingDetailsAll",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Billing>> getEmployeeBillingDetailsAll(
@RequestParam("employeeId") String employeeId)
throws MyTimeException {
List<Billing> billings = projectService
.getEmployeeBillingDetailsAll(employeeId);
return new ResponseEntity<>(billings, HttpStatus.OK);
}
@RequestMapping(value = "/addEmployeeBilling", method = RequestMethod.POST,
produces = MediaType.APPLICATION_JSON_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Billing> addEmployeeBilling(
@RequestBody Billing billingDetails, @RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
Billing billings = projectService
.addEmployeeBillingDetails(billingDetails, loginEmpId);
return new ResponseEntity<>(billings, HttpStatus.OK);
}
@RequestMapping(value = "/updateEmployeeBilling",
method = RequestMethod.POST,
produces = MediaType.APPLICATION_JSON_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Billing> updateEmployeeBilling(
@RequestBody Billing billingDetails, @RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
Billing billings = projectService
.updateEmployeeBilling(billingDetails, loginEmpId);
return new ResponseEntity<>(billings, HttpStatus.OK);
}
@RequestMapping(value = "/deleteEmployeeBilling",
method = RequestMethod.POST,
produces = MediaType.APPLICATION_JSON_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Billing> deleteEmployeeBilling(
@RequestBody Billing teamMate) throws MyTimeException {
projectService.deleteEmployeeBilling(teamMate);
return new ResponseEntity<>(null, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeesDashBoard",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<EmployeeDashboardVO>> getEmployeesDashBoard()
throws MyTimeException {
List<EmployeeDashboardVO> employeesRoles = projectService
.getEmployeesDashBoard();
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeesHavingVisa",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Employee>> getEmployeesHavingVisa(
@RequestParam("visa") String passport) throws MyTimeException {
List<Employee> employees = new ArrayList<>();
if (passport != null && !"passport".equalsIgnoreCase(passport)) {
List<EmployeeVisa> employeeVisas = employeeVisaRepo
.findByVisaName(passport);
List<String> employeeIds = null;
if (employeeVisas != null) {
employeeIds = employeeVisas.stream()
.map(EmployeeVisa::getEmployeeId)
.collect(Collectors.toList());
}
if (employeeIds != null && !employeeIds.isEmpty()) {
List<Employee> emps = userService.getActiveEmployees();
for (Employee emp : emps) {
if (employeeIds.contains(emp.getEmployeeId())) {
employees.add(emp);
}
}
}
return new ResponseEntity<>(employees, HttpStatus.OK);
} else {
//List<EmployeeRoles> employees = new ArrayList<>();
if (userService.getActiveEmployees() != null) {
employees = userService.getActiveEmployees().stream()
.sorted((o1, o2) -> o1.getEmployeeName()
.compareTo(o2.getEmployeeName()))
.collect(Collectors.toList());
}
return new ResponseEntity<>(employees, HttpStatus.OK);
}
}
@RequestMapping(value = "/addEmployeeToTeamWithCheck", method = RequestMethod.POST,
produces = MediaType.TEXT_PLAIN_VALUE,
consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> addEmployeeToTeamWithCheck(
@RequestBody Resource teamMate, @RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
String response = projectService.addProjectTeamMateWithCheck(teamMate, loginEmpId);
return new ResponseEntity<>(response, HttpStatus.OK);
}
}
\ No newline at end of file
src/main/java/com/nisum/mytime/controller/ReportsController.java
View file @ c63bc59d
......@@ -42,26 +42,24 @@ import com.nisum.mytime.model.ReportSeriesRecord;
import com.nisum.mytime.repository.EmployeeVisaRepo;
import com.nisum.mytime.repository.BillingRepo;
import com.nisum.mytime.service.IProjectService;
import com.nisum.mytime.service.IResourceService;
import com.nisum.mytime.service.IEmployeeService;
@RestController
@RequestMapping("/reports")
public class ReportsController {
@Autowired
private IEmployeeService userService;
@Autowired
private IProjectService projectService;
private MongoTemplate mongoTemplate;
@Autowired
private EmployeeVisaRepo employeeVisaRepo;
private IResourceService resourceService;
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private BillingRepo teamMatesBillingRepo;
private IEmployeeService employeeService;
@RequestMapping(value = "/getEmployeesByFunctionalGroup1",
method = RequestMethod.GET,
......@@ -148,7 +146,7 @@ public class ReportsController {
statusList.add("Non-Billable");
List<String> catagories = new ArrayList();
List<ReportSeriesRecord> seriesDetails = new ArrayList<ReportSeriesRecord>();
List<Account> accounts = userService.getAccounts();
List<Account> accounts = employeeService.getAccounts();
ColumnChartData reportData = new ColumnChartData();
for (String status : statusList) {
catagories = new ArrayList();
......@@ -319,7 +317,7 @@ public class ReportsController {
public ResponseEntity<List<Employee>> getEmployeesByFG(
@RequestParam("fGroup") String fGroup) throws MyTimeException {
List<Employee> empList = new ArrayList<>();
empList = userService.getEmployeesByFunctionalGrp(fGroup);
empList = employeeService.getEmployeesByFunctionalGrp(fGroup);
return new ResponseEntity<>(empList, HttpStatus.OK);
}
......@@ -333,7 +331,7 @@ public class ReportsController {
throws MyTimeException {
List<Resource> empList = new ArrayList<>();
if (account != null && !account.isEmpty()) {
empList = projectService.findByAccountAndActiveAndBillableStatus(
empList = resourceService.findByAccountAndActiveAndBillableStatus(
account, true, billabilityStatus);
}
return new ResponseEntity<>(empList, HttpStatus.OK);
......
src/main/java/com/nisum/mytime/controller/ResourceController.java 0 → 100644
View file @ c63bc59d
package com.nisum.mytime.controller;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Employee;
import com.nisum.mytime.model.EmployeeDashboardVO;
import com.nisum.mytime.model.EmployeeVisa;
import com.nisum.mytime.model.Resource;
import com.nisum.mytime.repository.EmployeeVisaRepo;
import com.nisum.mytime.service.IEmployeeService;
import com.nisum.mytime.service.IProjectService;
import com.nisum.mytime.service.IResourceService;
import com.nisum.mytime.utils.MyTimeUtils;
@RestController
@RequestMapping("/projectTeam")
public class ResourceController {
@Autowired
private IEmployeeService employeeService;
@Autowired
private IProjectService projectService;
@Autowired
private EmployeeVisaRepo employeeVisaRepo;
@Autowired
private IResourceService resourceService;
// @RequestMapping(value = "/addEmployeeToTeam"
@RequestMapping(value = "/resources", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Resource> addResourceToTeam(@RequestBody Resource resource,
@RequestParam(value = "loginEmpId", required = false) String loginEmpId) throws MyTimeException {
resource.setActive(true);
resource.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
Resource resourcePersisted = resourceService.addResource(resource, loginEmpId);
return new ResponseEntity<>(resourcePersisted, HttpStatus.OK);
}
// @RequestMapping(value = "/updateTeammate"
@RequestMapping(value = "/resources", method = RequestMethod.PUT, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> updateResource(@RequestBody Resource resource,
@RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
resource.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
String response = resourceService.updateResource(resource, loginEmpId);
return new ResponseEntity<>(response, HttpStatus.OK);
}
// @RequestMapping(value = "/deleteTeammate"
@RequestMapping(value = "/resources", method = RequestMethod.DELETE, produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> deleteResource(@RequestBody Resource resource,
@RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
resourceService.deleteResource(resource.getEmployeeId(), resource.getProjectId(), resource.getId(), loginEmpId);
return new ResponseEntity<>("Success", HttpStatus.OK);
}
// @RequestMapping(value = "/getEmployeeProjectInfo"
@RequestMapping(value = "/resources", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getResourcesSortByStartDate(@RequestParam("empId") String empId)
throws MyTimeException {
List<Resource> projectInfo = resourceService.getResourcesSortByStartDate(empId);
return new ResponseEntity<>(projectInfo, HttpStatus.OK);
}
//@RequestMapping(value = "/getMyTeamDetails"
@RequestMapping(value = "/resources/active", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getActiveResources(@RequestParam("employeeId") String employeeId)
throws MyTimeException {
List<Resource> employeesRoles = resourceService.getActiveResources(employeeId);
return new ResponseEntity<>(employeesRoles, HttpStatus.OK);
}
// @RequestMapping(value = "/getShiftDetails"
@RequestMapping(value = "/resources/{shift}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getResourcesForShift(@PathVariable("shift") String shift)
throws MyTimeException {
List<Resource> resourcesList = resourceService.getResourcesForShift(shift);
return new ResponseEntity<>(resourcesList, HttpStatus.OK);
}
// @RequestMapping(value = "/getProjectAllocations"
@RequestMapping(value = "/resources/projects/", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getResourcesAllocatedForAllProjects() throws MyTimeException {
List<Resource> resourcesList = resourceService.getResourcesForActiveProjects();
return new ResponseEntity<>(resourcesList, HttpStatus.OK);
}
// @RequestMapping(value = "/getProjectDetails"
@RequestMapping(value = "/resources/project/{projectId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getResourcesForProject(@PathVariable("projectId") String projectId,
@RequestParam(value = "status", required = false, defaultValue = MyTimeUtils.ACTIVE) String status)
throws MyTimeException {
List<Resource> resourcesList = resourceService.getResourcesForProject(projectId, status);
return new ResponseEntity<>(resourcesList, HttpStatus.OK);
}
//@RequestMapping(value = "/getTeamDetails"
@RequestMapping(value = "/resources/deliverylead/{deliveryLeadId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> getTeamDetails(@PathVariable("deliveryLeadId") String deliveryLeadId)
throws MyTimeException {
List<Resource> resourcesList = resourceService.getResourcesUnderDeliveryLead(deliveryLeadId);
return new ResponseEntity<>(resourcesList, HttpStatus.OK);
}
@RequestMapping(value = "/getUnAssignedEmployees", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Employee>> getUnAssignedEmployees() throws MyTimeException {
List<Employee> employeesList = projectService.getUnAssignedEmployees();
return new ResponseEntity<>(employeesList, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeesDashBoard", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<EmployeeDashboardVO>> getEmployeesDashBoard() throws MyTimeException {
List<EmployeeDashboardVO> employeeDashBoardList = projectService.getEmployeesDashBoard();
return new ResponseEntity<>(employeeDashBoardList, HttpStatus.OK);
}
@RequestMapping(value = "/getEmployeesHavingVisa", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Employee>> getEmployeesHavingVisa(@RequestParam("visa") String passport)
throws MyTimeException {
List<Employee> employees = new ArrayList<>();
if (passport != null && !"passport".equalsIgnoreCase(passport)) {
List<EmployeeVisa> employeeVisas = employeeVisaRepo.findByVisaName(passport);
List<String> employeeIds = null;
if (employeeVisas != null) {
employeeIds = employeeVisas.stream().map(EmployeeVisa::getEmployeeId).collect(Collectors.toList());
}
if (employeeIds != null && !employeeIds.isEmpty()) {
List<Employee> emps = employeeService.getActiveEmployees();
for (Employee emp : emps) {
if (employeeIds.contains(emp.getEmployeeId())) {
employees.add(emp);
}
}
}
return new ResponseEntity<>(employees, HttpStatus.OK);
} else {
// List<EmployeeRoles> employees = new ArrayList<>();
if (employeeService.getActiveEmployees() != null) {
employees = employeeService.getActiveEmployees().stream()
.sorted((o1, o2) -> o1.getEmployeeName().compareTo(o2.getEmployeeName()))
.collect(Collectors.toList());
}
return new ResponseEntity<>(employees, HttpStatus.OK);
}
}
@RequestMapping(value = "/addEmployeeToTeamWithCheck", method = RequestMethod.POST, produces = MediaType.TEXT_PLAIN_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> addEmployeeToTeamWithCheck(@RequestBody Resource resource,
@RequestParam(value = "loginEmpId") String loginEmpId) throws MyTimeException {
String response = projectService.addProjectTeamMateWithCheck(resource, loginEmpId);
return new ResponseEntity<>(response, HttpStatus.OK);
}
}
// @RequestMapping(value = "/employee", method = RequestMethod.GET,
// public ResponseEntity<Employee> getEmployee(
// @RequestMapping(value = "/updateEmployeeRole", method =
// public ResponseEntity<Employee> updateEmployeeRole(@RequestBody Employee
// @RequestMapping(value = "/deleteEmployee"
// public ResponseEntity<String> deleteEmployee
// @RequestMapping(value = "/getEmployeeRoleData",
// public ResponseEntity<Employee> getEmployeeRoleData(
// @RequestMapping(value = "/addProject"
// public ResponseEntity<Project> addProject(
// @RequestMapping(value = "/getEmployeesToTeam"
// public ResponseEntity<List<Employee>> getActiveEmployeesSortByName() throws
// MyTimeException {
src/main/java/com/nisum/mytime/model/Billing.java
View file @ c63bc59d
......@@ -23,27 +23,27 @@ import lombok.ToString;
@Document(collection = "billing")
public class Billing extends AuditFields implements Serializable {
public Date getBillingEndDate() {
return billingEndDate;
}
private static final long serialVersionUID = 1L;
@Id
private ObjectId id;
private String employeeId;
private String employeeName;
private String account;
private String projectId;
private String projectName;
private String billableStatus;
@DateTimeFormat(iso = ISO.DATE)
private Date billingStartDate;
@DateTimeFormat(iso = ISO.DATE)
private Date billingEndDate;
private String comments;
private boolean active;
//@DateTimeFormat(pattern = "dd-MM-yyyy")
// private Date createDate;
public Date getBillingEndDate() {
return billingEndDate;
}
private static final long serialVersionUID = 1L;
@Id
private ObjectId id;
private String employeeId;
private String employeeName;
private String account;
private String projectId;
private String projectName;
private String billableStatus;
@DateTimeFormat(iso = ISO.DATE)
private Date billingStartDate;
@DateTimeFormat(iso = ISO.DATE)
private Date billingEndDate;
private String comments;
private boolean active;
// @DateTimeFormat(pattern = "dd-MM-yyyy")
// private Date createDate;
}
src/main/java/com/nisum/mytime/model/EmpShiftDetails.java → src/main/java/com/nisum/mytime/model/EmployeeShift.java
View file @ c63bc59d
......@@ -15,7 +15,7 @@ import lombok.ToString;
@NoArgsConstructor
@ToString
@Document(collection = "employeeShifts")
public class EmpShiftDetails extends AuditFields {
public class EmployeeShift extends AuditFields {
@Id
private String id;
......
src/main/java/com/nisum/mytime/repository/BillingRepo.java
View file @ c63bc59d
......@@ -12,9 +12,9 @@ public interface BillingRepo extends MongoRepository<Billing, String> {
List<Billing> findByProjectId(String projectId);
List<Billing> findByEmployeeId(String employeeId);
Billing findById(ObjectId id);
List<Billing> findByEmployeeIdAndProjectId(String employeeId, String projectId);
List<Billing> findByEmployeeIdAndProjectId(String employeeId, String projectId);
}
src/main/java/com/nisum/mytime/repository/EmpShiftDetailsRepo.java → src/main/java/com/nisum/mytime/repository/EmployeeShiftRepo.java
View file @ c63bc59d
......@@ -2,8 +2,8 @@ package com.nisum.mytime.repository;
import org.springframework.data.mongodb.repository.MongoRepository;
import com.nisum.mytime.model.EmpShiftDetails;
import com.nisum.mytime.model.EmployeeShift;
public interface EmpShiftDetailsRepo extends MongoRepository<EmpShiftDetails, String> {
public interface EmployeeShiftRepo extends MongoRepository<EmployeeShift, String> {
}
\ No newline at end of file
src/main/java/com/nisum/mytime/service/IBillingService.java
View file @ c63bc59d
......@@ -10,8 +10,18 @@ import com.nisum.mytime.model.Employee;
@Service
public interface IBillingService {
public Billing addBillingtoResource(Billing billing, Employee employee, String loginEmpId);
Billing addBilling(Billing billingDetails, String loginEmpId);
public List<Billing> getEmployeeActiveBillingDetails(String empId, String projectId);
Billing updateBilling(Billing billingDetails, String loginEmpId);
void deleteBilling(Billing teamMate);
Billing addBillingtoResource(Billing billing, Employee employee, String loginEmpId);
List<Billing> getBillingsForEmployee(String empId);
List<Billing> getActiveBillings(String empId, String projectId);
List<Billing> getBillingsForProject(String empId, String projectId);
}
src/main/java/com/nisum/mytime/service/IEmployeeService.java
View file @ c63bc59d
......@@ -44,5 +44,9 @@ public interface IEmployeeService {
boolean verifyEmployeeRole(String empId, String roleName);
List<Employee> getEmployeesFromList(Set<String> empIdsSet);
List<HashMap<String, String>> getDeliveryManagerMap(List deliveryManagerIdsList);
public List<Employee> getAllEmployees();
}
src/main/java/com/nisum/mytime/service/IEmployeeShiftService.java
View file @ c63bc59d
......@@ -7,6 +7,8 @@ import com.nisum.mytime.model.Resource;
@Service
public interface IEmployeeShiftService {
void updateShiftDetails(Resource existingTeammate, String loginEmpId);
public void addEmployeeShift(Resource resource, String loginEmpId);
void updateEmployeeShift(Resource existingTeammate, String loginEmpId);
}
src/main/java/com/nisum/mytime/service/IProjectService.java
View file @ c63bc59d
......@@ -4,96 +4,46 @@ import java.util.HashMap;
import java.util.List;
import java.util.Set;
import org.bson.types.ObjectId;
import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Billing;
import com.nisum.mytime.model.EmpLoginData;
import com.nisum.mytime.model.EmployeeDashboardVO;
import com.nisum.mytime.model.Employee;
import com.nisum.mytime.model.EmployeeDashboardVO;
import com.nisum.mytime.model.Project;
import com.nisum.mytime.model.Resource;
public interface IProjectService {
public Resource addNewBeanchAllocation(Employee employee,String loginEmpId);
List<EmpLoginData> employeeLoginsBasedOnDate(long id, String fromDate,
String toDate) throws MyTimeException;
List<HashMap<Object, Object>> getProjects() throws MyTimeException;
Project addProject(Project project, String loginEmpId) throws MyTimeException;
String generatePdfReport(long id, String fromDate, String toDate)
throws MyTimeException;
Employee getEmployeesRole(String emailId);
void deleteProject(String projectId);
Project updateProject(Project project, String loginEmpId)throws MyTimeException;
Employee getEmployeesRoleData(String empId);
List<Resource> getTeamDetails(String empId);
//MT-72
List<Resource> getProjectInfo(String empId);
public Resource addProjectTeamMate(Resource projectTeamMate, String loginEmpId)
throws MyTimeException;
String updateTeammate(Resource projectTeamMate, String loginEmpId) throws MyTimeException;
void deleteTeammate(String empId, String projectId, ObjectId id, String loginEmpId);
List<Project> getProjects(String managerId) throws MyTimeException;
List<Resource> getMyTeamDetails(String empId);
List<Employee> getUnAssignedEmployees();
Project createProject(Project project, String loginEmpId) throws MyTimeException;
List<Resource> getShiftDetails(String shift);
Project updateProject(Project project, String loginEmpId) throws MyTimeException;
List<Resource> getAllProjectDetails();
void deleteProject(String projectId);
List<Resource> getProjectDetails(String projectId,String status);
List<Project> getProjectsUnderDomain(String domainId);
public List<Resource> getMyProjectAllocations(String empId);
List<HashMap<Object, Object>> getProjects() throws MyTimeException;
List<Billing> getEmployeeBillingDetails(String empId,
String projectId);
List<Project> getProjectsUnderDeliveryLead(String managerId) throws MyTimeException;
Billing addEmployeeBillingDetails(Billing billingDetails, String loginEmpId);
public Resource addNewBeanchAllocation(Employee employee, String loginEmpId);
Billing updateEmployeeBilling(Billing billingDetails, String loginEmpId);
List<EmpLoginData> employeeLoginsBasedOnDate(long id, String fromDate, String toDate) throws MyTimeException;
void deleteEmployeeBilling(Billing teamMate);
String generatePdfReport(long id, String fromDate, String toDate) throws MyTimeException;
public List<EmployeeDashboardVO> getEmployeesDashBoard();
List<Resource> getResourcesUnderProject(String empId);
List<Billing> getEmployeeActiveBillingDetails(String empId,
String projectId);
List<Employee> getUnAssignedEmployees();
List<Billing> getEmployeeActiveNisumBench(String empId);
public List<EmployeeDashboardVO> getEmployeesDashBoard();
List<Billing> getEmployeeBillingDetailsAll(String empId);
public String addProjectTeamMateWithCheck(Resource projectTeamMate, String loginEmpId) throws MyTimeException;
public void updateShiftDetails(Resource existingTeammate, String loginEmpId);
public List<HashMap<Object, Object>> getProjectsForEmployee(String empId);
public void addShiftDetails(Resource projectTeamMate, String loginEmpId);
public Set<String> accountsAssignedToDl(String empId);
List<Resource> findByAccountAndActiveAndBillableStatus(
String account, boolean status, String billableStatus);
public String addProjectTeamMateWithCheck(Resource projectTeamMate, String loginEmpId)
throws MyTimeException;
public List<HashMap<Object, Object>> deliveryLeadProjects(String empId) throws MyTimeException;
public List<HashMap<Object, Object>> projectsInfoByEmpId(String empId);
public Set<String> accountsAssignedToDl(String empId);
public List<HashMap<Object, Object>> deliveryLeadProjects(String empId) throws MyTimeException;
public List<Project> getAllProjects();
}
src/main/java/com/nisum/mytime/service/IResourceService.java
View file @ c63bc59d
......@@ -2,20 +2,45 @@ package com.nisum.mytime.service;
import java.util.List;
import org.bson.types.ObjectId;
import org.springframework.stereotype.Service;
import com.nisum.mytime.model.Billing;
import com.nisum.mytime.model.Employee;
import com.nisum.mytime.model.Resource;
import com.nisum.mytime.exception.handler.MyTimeException;
@Service
public interface IResourceService {
public Resource save(Resource resource);
Resource addResource(Resource projectTeamMate, String loginEmpId) throws MyTimeException;
String updateResource(Resource projectTeamMate, String loginEmpId) throws MyTimeException;
void deleteResource(String empId, String projectId, ObjectId id, String loginEmpId);
Resource save(Resource resource);
void addResources(Employee employee, String loginEmpId);
void inactivateResource(Employee employeeReq, Employee employeeUpdated, String loginEmpId);
public List<Resource> getResources(String empId);
List<Resource> findByAccountAndActiveAndBillableStatus(String account, boolean status, String billableStatus);
List<Resource> getResourcesSortByStartDate(String employeeId);
List<Resource> getResourcesForProject(String projectId, String status);
List<Resource> getResourcesForEmployee(String empId);
List<Resource> getResourcesForProject(String projectId);
List<Resource> getActiveResources(String empId);
List<Resource> getResourcesForActiveProjects();
List<Resource> getResourcesForShift(String shift);
public List<Resource> getResourcesUnderDeliveryLead(String empId);
}
src/main/java/com/nisum/mytime/service/impl/BillingService.java
View file @ c63bc59d
......@@ -3,6 +3,7 @@ package com.nisum.mytime.service.impl;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
......@@ -16,7 +17,6 @@ import com.nisum.mytime.utils.MyTimeUtils;
import lombok.extern.slf4j.Slf4j;
@Service
@Slf4j
public class BillingService implements IBillingService {
......@@ -28,21 +28,62 @@ public class BillingService implements IBillingService {
private MongoTemplate mongoTemplate;
@Override
public List<Billing> getEmployeeActiveBillingDetails(String empId, String projectId) {
Query query4 = new Query();
query4.addCriteria(Criteria.where("active").is(new Boolean(true)));
query4.addCriteria(Criteria.where("employeeId").is(empId));
query4.addCriteria(Criteria.where("projectId").is(projectId));
List<Billing> billings = mongoTemplate.find(query4, Billing.class);
List<Billing> billingsSorted = billings;
try {
billingsSorted = (billings == null || billings.size() == 0) ? billings
: billings.stream().sorted(Comparator.comparing(Billing::getBillingStartDate).reversed())
.collect(Collectors.toList());
} catch (Exception e) {
e.printStackTrace();
public Billing addBilling(Billing billing, String loginEmpId) {
billing.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
return billingRepo.save(billing);
}
@Override
public Billing updateBilling(Billing billing, String loginEmpId) {
billing.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
return billingRepo.save(billing);
}
@Override
public void deleteBilling(Billing billing) {
billingRepo.delete(billing);
}
@Override
public List<Billing> getBillingsForProject(String empId, String projectId) {
List<Billing> billingsList = billingRepo.findByEmployeeIdAndProjectId(empId, projectId);
if (billingsList == null || billingsList.size() == 0) {
return billingsList;
} else {
return billingsList.stream().sorted(Comparator.comparing(Billing::getCreatedOn).reversed())
.collect(Collectors.toList());
}
}
@Override
public List<Billing> getBillingsForEmployee(String empId) {
List<Billing> billingsList = billingRepo.findByEmployeeId(empId);
if (billingsList == null || billingsList.size() == 0) {
return billingsList;
} else {
return billingsList.stream().sorted(Comparator.comparing(Billing::getCreatedOn).reversed())
.collect(Collectors.toList());
}
}
@Override
public List<Billing> getActiveBillings(String empId, String projectId) {
Query query = new Query();
query.addCriteria(Criteria.where("active").is(new Boolean(true)));
query.addCriteria(Criteria.where("employeeId").is(empId));
query.addCriteria(Criteria.where("projectId").is(projectId));
List<Billing> billingList = mongoTemplate.find(query, Billing.class);
if (billingList == null || billingList.size() == 0) {
return billingList;
} else {
return billingList.stream().sorted(Comparator.comparing(Billing::getBillingStartDate).reversed())
.collect(Collectors.toList());
}
return billingsSorted;
}
public Billing addBillingtoResource(Billing billing, Employee employee, String loginEmpId) {
......@@ -51,7 +92,6 @@ public class BillingService implements IBillingService {
billing.setActive(false);
billing.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
return billingRepo.save(billing);
}
}
src/main/java/com/nisum/mytime/service/impl/EmployeeService.java
View file @ c63bc59d
......@@ -169,7 +169,7 @@ public class EmployeeService implements IEmployeeService {
Employee employeePersisted = employeeRepo.save(existingEmployee);
if (mobileNumberChanged) {
try {
List<Resource> resourcesList = resourceService.getResources(employeeReq.getEmployeeId());
List<Resource> resourcesList = resourceService.getResourcesForEmployee(employeeReq.getEmployeeId());
if (resourcesList != null && !resourcesList.isEmpty()) {
for (Resource resource : resourcesList) {
......@@ -267,23 +267,26 @@ public class EmployeeService implements IEmployeeService {
@Override
public List<HashMap<String, String>> getDeliveryLeads(String domainId) {
Domain domain = domainService.getDomainById(domainId);
return getEmployeeData(domain.getDeliveryManagers());
return getDeliveryManagerMap(domain.getDeliveryManagers());
}
public List<HashMap<String, String>> getEmployeeData(List dmIdList) {
List<HashMap<String, String>> EmployeeList = new ArrayList<>();
Query query = new Query(Criteria.where("employeeId").in(dmIdList));
List<Employee> employeeList = mongoTemplate.find(query, Employee.class);
for (Employee employee : employeeList) {
HashMap<String, String> managerMap = new HashMap<>();
managerMap.put("employeeId", employee.getEmployeeId());
managerMap.put("employeeName", employee.getEmployeeName());
EmployeeList.add(managerMap);
}
return EmployeeList;
}
@Override
public List<HashMap<String, String>> getDeliveryManagerMap(List deliveryManagerIdsList) {
List<HashMap<String, String>> employeeList = new ArrayList<>();
Query query = new Query(Criteria.where("employeeId").in(deliveryManagerIdsList));
List<Employee> employeePersistedList = mongoTemplate.find(query,Employee.class);
for (Employee employee : employeePersistedList) {
HashMap<String, String> managerMap = new HashMap<>();
managerMap.put("employeeId", employee.getEmployeeId());
managerMap.put("employeeName", employee.getEmployeeName());
employeeList.add(managerMap);
}
return employeeList;
}
@Override
public List<Employee> getEmployeesByFunctionalGrp(String functionalGrp) {
return employeeRepo.findByEmpStatusAndFunctionalGroup("Active", functionalGrp);
......@@ -311,4 +314,11 @@ public class EmployeeService implements IEmployeeService {
}
@Override
public List<Employee> getAllEmployees() {
return employeeRepo.findAll();
}
}
src/main/java/com/nisum/mytime/service/impl/EmployeeShiftService.java
View file @ c63bc59d
package com.nisum.mytime.service.impl;
import java.util.Calendar;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
import com.nisum.mytime.model.EmpShiftDetails;
import com.nisum.mytime.model.EmployeeShift;
import com.nisum.mytime.model.Resource;
import com.nisum.mytime.repository.EmployeeShiftRepo;
import com.nisum.mytime.service.IEmployeeShiftService;
import com.nisum.mytime.utils.MyTimeUtils;
import lombok.extern.slf4j.Slf4j;
@Service
@Slf4j
public class EmployeeShiftService implements IEmployeeShiftService{
public class EmployeeShiftService implements IEmployeeShiftService {
@Autowired
private EmployeeShiftRepo empShiftsRepo;
@Autowired
private MongoTemplate mongoTemplate;
public void updateShiftDetails(Resource existingTeammate, String loginEmpId) {
@Override
public void addEmployeeShift(Resource resource, String loginEmpId) {
EmployeeShift empShift = new EmployeeShift();
empShift.setEmployeeName(resource.getEmployeeName());
empShift.setEmployeeId(resource.getEmployeeId());
empShift.setShift(resource.getShift());
empShift.setActive(resource.isActive());
empShift.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
empShiftsRepo.save(empShift);
log.info("The Employee Shift has been Persisted ::" + empShift);
}
public void updateEmployeeShift(Resource resource, String loginEmpId) {
Query getQuery = new Query();
getQuery.addCriteria(new Criteria().andOperator(Criteria.where("active").is(true),
Criteria.where("employeeId").is(existingTeammate.getEmployeeId())));
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, -1);
EmpShiftDetails existingShift = mongoTemplate.findOne(getQuery, EmpShiftDetails.class);
if (existingShift != null) {
existingShift.setActive(false);
// existingShift.setUpdatedDate(new Date());// Commented as added
// common audit fields
existingShift.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
mongoTemplate.save(existingShift);
Criteria.where("employeeId").is(resource.getEmployeeId())));
EmployeeShift existingEmpShift = mongoTemplate.findOne(getQuery, EmployeeShift.class);
if (existingEmpShift != null) {
existingEmpShift.setActive(false);
existingEmpShift.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
mongoTemplate.save(existingEmpShift);
log.info("The shift has been updated::" + existingEmpShift);
}
}
}
src/main/java/com/nisum/mytime/service/impl/ProjectService.java
View file @ c63bc59d
package com.nisum.mytime.service.impl;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
......@@ -12,8 +10,6 @@ import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.commons.lang.time.DateUtils;
import org.bson.types.ObjectId;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
......@@ -23,31 +19,23 @@ import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import com.nisum.mytime.controller.DomainController;
import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Account;
import com.nisum.mytime.model.Billing;
import com.nisum.mytime.model.Domain;
import com.nisum.mytime.model.EmpLoginData;
import com.nisum.mytime.model.EmpShiftDetails;
import com.nisum.mytime.model.EmployeeDashboardVO;
import com.nisum.mytime.model.Employee;
import com.nisum.mytime.model.EmployeeDashboardVO;
import com.nisum.mytime.model.Project;
import com.nisum.mytime.model.Resource;
import com.nisum.mytime.repository.AccountRepo;
import com.nisum.mytime.repository.DomainRepo;
import com.nisum.mytime.repository.EmpShiftDetailsRepo;
import com.nisum.mytime.repository.EmployeeRepo;
import com.nisum.mytime.repository.ProjectRepo;
import com.nisum.mytime.repository.ResourceRepo;
import com.nisum.mytime.repository.BillingRepo;
import com.nisum.mytime.service.IDomainService;
import com.nisum.mytime.service.IEmployeeService;
import com.nisum.mytime.service.IProjectService;
import com.nisum.mytime.service.IRoleService;
import com.nisum.mytime.service.IEmployeeRoleService;
import com.nisum.mytime.utils.MyTeamResultDTO;
import com.nisum.mytime.utils.MyTimeUtils;
import com.nisum.mytime.utils.PdfReportGenerator;
......@@ -58,17 +46,14 @@ import lombok.extern.slf4j.Slf4j;
public class ProjectService implements IProjectService {
@Autowired
private EmployeeRepo employeeRolesRepo;
private EmployeeRepo employeeRepo;
@Autowired
private ProjectRepo projectRepo;
@Autowired
private ResourceRepo projectTeamMatesRepo;
private ResourceRepo resourceRepo;
@Autowired
private BillingRepo teamMatesBillingRepo;
@Autowired
private EmployeeDataService employeeDataBaseService;
......@@ -78,18 +63,6 @@ public class ProjectService implements IProjectService {
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private EmpShiftDetailsRepo empShiftDetailsRepo;
@Autowired
private DomainController domainController;
@Autowired
private IRoleService roleInfoService;
@Autowired
private IEmployeeRoleService roleMappingService;
@Autowired
private AccountRepo accountRepo;
......@@ -100,119 +73,47 @@ public class ProjectService implements IProjectService {
private IDomainService domainService;
public Resource addNewBeanchAllocation(Employee employee,String loginEmpId)
{
Resource resourcePersisted=null;
Resource resourceBench = new Resource();
resourceBench.setAccount(MyTimeUtils.BENCH_ACCOUNT);
resourceBench.setBillableStatus(MyTimeUtils.BENCH_BILLABILITY_STATUS);
resourceBench.setDesignation(employee.getDesignation());
resourceBench.setEmailId(employee.getEmailId());
resourceBench.setEmployeeId(employee.getEmployeeId());
resourceBench.setMobileNumber(employee.getMobileNumber());
resourceBench.setEmployeeName(employee.getEmployeeName());
resourceBench.setProjectId(MyTimeUtils.BENCH_PROJECT_ID);
resourceBench.setStartDate(employee.getDateOfJoining() != null ? employee.getDateOfJoining() : new Date());
Project project = projectRepo.findByProjectId(MyTimeUtils.BENCH_PROJECT_ID);
resourceBench.setProjectName(project.getProjectName());
resourceBench.setAccountId(project.getAccountId());
resourceBench.setDomainId(project.getDomainId());
resourceBench.setShift(employee.getShift());
resourceBench.setRole(employee.getRole());
if ( null != employee.getEmpStatus() && employee.getEmpStatus().trim().equalsIgnoreCase(MyTimeUtils.IN_ACTIVE_SPACE)) {
resourceBench.setEndDate(employee.getEndDate());
resourceBench.setActive(false);
} else {
employee.setEmpStatus(MyTimeUtils.ACTIVE);
resourceBench.setEndDate(project.getProjectEndDate());
resourceBench.setActive(true);
}
try {
resourcePersisted= addProjectTeamMate(resourceBench, loginEmpId);
} catch (MyTimeException e) {
e.printStackTrace();
}
return resourcePersisted;
@Autowired
private BillingService billingService;
@Autowired
private ResourceService resourceService;
@Autowired
private EmployeeShiftService empShiftService;
@Autowired
private IEmployeeService employeeService;
@Override
public List<Project> getProjectsUnderDomain(String domainId) {
return projectRepo.findByDomainId(domainId);
}
@Override
public List<EmpLoginData> employeeLoginsBasedOnDate(long id,
String fromDate, String toDate) throws MyTimeException {
return employeeDataBaseService.fetchEmployeeLoginsBasedOnDates(id, fromDate, toDate);
}
@Override
public String generatePdfReport(long id, String fromDate, String toDate) throws MyTimeException {
return pdfReportGenerator.generateeReport(id, fromDate, toDate);
}
@Override
public List<HashMap<Object, Object>> getProjects() throws MyTimeException {
/*
* MT-79:returns all project info. This will get implemented once
* managers are maintained as List and not attributes return
* projectRepo.findAll();
*/
List<HashMap<Object, Object>> projectList = new ArrayList<>();
List<HashMap<String, String>> EmployeeList = null;
List<HashMap<String, String>> managerList = null;
List<Project> projects = projectRepo.findAll();
for (Project p : projects) {
HashMap<Object, Object> projectMap = new HashMap<>();
projectMap.put("id", p.getId());
projectMap.put("projectId", p.getProjectId());
projectMap.put("projectName", p.getProjectName());
Account account = accountRepo.findByAccountId(p.getAccountId());
Domain domain = domainRepo.findByDomainId(p.getDomainId());
if (domain != null)
projectMap.put("domain", domain.getDomainName());
if (account != null)
projectMap.put("account", account.getAccountName());
projectMap.put("accountId", p.getAccountId());
projectMap.put("domainId", p.getDomainId());
projectMap.put("status", p.getStatus());
projectMap.put("employeeIds", p.getEmployeeIds());
projectMap.put("projectStartDate", p.getProjectStartDate());
projectMap.put("projectEndDate", p.getProjectEndDate());
// projectMap.put("deliveryLeadIds", p.getDeliveryLeadIds());
/*
* if (p.getManagerIds() == null && p.getManagerId() != null) {
* EmployeeList = getEmployeeData(Arrays.asList(p.getManagerId()));
* } else
*/ if (p.getDeliveryLeadIds() != null) {
List<String> deliverLeadsId = p.getDeliveryLeadIds();
EmployeeList = getEmployeeData(deliverLeadsId);
projectMap.put("deliveryLeadIds", EmployeeList);
}
if (p.getManagerIds() != null) {
List<String> managerid = p.getManagerIds();
managerList = getEmployeeData(managerid);
projectMap.put("managerIds", managerList);
}
projectList.add(projectMap);
}
return projectList;
}
@Override
public Project addProject(Project project, String loginEmpId) throws MyTimeException {
public Project createProject(Project project, String loginEmpId) throws MyTimeException {
if (project.getDomainId() == null) {
Domain domain = new Domain();
domain.setAccountId(project.getAccountId());
domain.setDomainName(project.getDomain());
domain.setDeliveryManagers(project.getManagerIds());
domain.setStatus(project.getStatus());
domainController.createDomain(domain,null);
// Domain domain = new Domain();
// domain.setAccountId(project.getAccountId());
// domain.setDomainName(project.getDomain());
// domain.setDeliveryManagers(project.getManagerIds());
// domain.setStatus(project.getStatus());
// domainController.createDomain(domain,null);
List<Domain> domainsList = domainRepo
.findByAccountId(project.getAccountId());
Domain savedDomain = domainsList.get(0);
......@@ -222,28 +123,14 @@ public class ProjectService implements IProjectService {
project.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
return projectRepo.save(project);
}
@Override
public Employee getEmployeesRole(String emailId) {
return employeeRolesRepo.findByEmailId(emailId);
}
@Override
public void deleteProject(String projectId) {
Project project = projectRepo.findByProjectId(projectId);
projectRepo.delete(project);
Query query = new Query(Criteria.where("projectId").is(projectId));
List<Resource> list = mongoTemplate.find(query,
Resource.class);
projectTeamMatesRepo.delete(list);
}
@Override
public Project updateProject(Project project, String loginEmpId) throws MyTimeException {
//Inactivate the Project based on endDate
Project existingProject = projectRepo.findByProjectId(project.getProjectId());
List<Resource> existingTeammates = projectTeamMatesRepo.findByProjectId(project.getProjectId());
List<Resource> existingTeammates = resourceRepo.findByProjectId(project.getProjectId());
if (project.getProjectEndDate().compareTo(new Date()) <= 0
&& project.getProjectEndDate().compareTo(existingProject.getProjectEndDate()) != 0) {
......@@ -256,18 +143,18 @@ public class ProjectService implements IProjectService {
existingTeammate.setActive(false);
existingTeammate.setEndDate(project.getProjectEndDate());
existingTeammate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
projectTeamMatesRepo.save(existingTeammate);
resourceRepo.save(existingTeammate);
Billing billingDetails = new Billing();
Resource newBenchAllocation = new Resource();
billingDetails.setBillableStatus(MyTimeUtils.BENCH_BILLABILITY_STATUS);
List<Billing> listBD = getEmployeeActiveBillingDetails(existingTeammate.getEmployeeId(),
List<Billing> listBD = billingService.getActiveBillings(existingTeammate.getEmployeeId(),
existingTeammate.getProjectId());
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetailsExisting = listBD.get(0);
billingDetailsExisting.setBillingEndDate(project.getProjectEndDate());
billingDetailsExisting.setActive(false);
updateEmployeeBilling(billingDetailsExisting, loginEmpId);
billingService.updateBilling(billingDetailsExisting, loginEmpId);
}
Project benchProject = projectRepo.findByProjectId(MyTimeUtils.BENCH_PROJECT_ID);
Date sd = project.getProjectEndDate();
......@@ -286,8 +173,9 @@ public class ProjectService implements IProjectService {
newBenchAllocation.setDomainId(benchProject.getDomainId());
newBenchAllocation.setEndDate(benchProject.getProjectEndDate());
}
addEmployeeBillingDetails(billingDetails,loginEmpId);
//addEmployeeBillingDetails(billingDetails,loginEmpId);
billingService.addBilling(billingDetails, loginEmpId);
newBenchAllocation.setRole(existingTeammate.getRole());
newBenchAllocation.setAccount(MyTimeUtils.BENCH_ACCOUNT);
newBenchAllocation.setShift(existingTeammate.getShift());
......@@ -300,8 +188,9 @@ public class ProjectService implements IProjectService {
newBenchAllocation.setProjectId(MyTimeUtils.BENCH_PROJECT_ID);
newBenchAllocation.setStartDate(sd);
newBenchAllocation.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
projectTeamMatesRepo.save(newBenchAllocation);
updateShiftDetails(existingTeammate,loginEmpId);
resourceRepo.save(newBenchAllocation);
empShiftService.updateEmployeeShift(existingTeammate,loginEmpId);
}
return existingProject;
......@@ -336,7 +225,7 @@ public class ProjectService implements IProjectService {
options.returnNew(true);
options.upsert(true);
Project projectDB = mongoTemplate.findAndModify(query, update, options, Project.class);
List<Resource> employeeDetails = projectTeamMatesRepo.findByProjectId(project.getProjectId());
List<Resource> employeeDetails = resourceRepo.findByProjectId(project.getProjectId());
if (employeeDetails != null && projectDB != null) {
for (Resource teamMate : employeeDetails) {
// emp.setManagerId(projectDB.getManagerId());
......@@ -347,633 +236,213 @@ public class ProjectService implements IProjectService {
// emp.setManagerIds(projectDB.getManagerIds());
teamMate.setEndDate(projectDB.getProjectEndDate());
teamMate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);//Setting audit fields
projectTeamMatesRepo.save(teamMate);
resourceRepo.save(teamMate);
}
}
return projectDB;
}
}
@Override
public Employee getEmployeesRoleData(String employeeId) {
return employeeRolesRepo.findByEmployeeId(employeeId);
}
@Override
public List<Resource> getTeamDetails(String empId) {
List<String> projectsId = new ArrayList<>();
List<Resource> listOfTeamMates = new ArrayList<>();
// return projectTeamMatesRepo.findById(empId);
// Query query = new Query(Criteria.where("deliveryLeadIds").("empId"));
List<Project> projects = projectRepo.findByDeliveryLeadIds(empId);// mongoTemplate.find(query, Project.class);
for (Project project : projects)
projectsId.add(project.getProjectId());
Query query1 = new Query(Criteria.where("projectId").in(projectsId));
List<Resource> projectMateList = mongoTemplate.find(query1, Resource.class);
for (Resource projectTeamMate : projectMateList) {
if (!projectTeamMate.getEmployeeId().equals(empId))
listOfTeamMates.add(projectTeamMate);
}
return listOfTeamMates;
}
// MT-72: fetching the projectteammate details.
@Override
public List<Resource> getProjectInfo(String employeeId) {
return mongoTemplate.find(getQuery(employeeId, MyTimeUtils.START_DATE),
Resource.class);
}
@Override
public Resource addProjectTeamMate(Resource projectTeamMate, String loginEmpId) throws MyTimeException {
updateProjectEndDateInProjectTeamMate(projectTeamMate, loginEmpId);
projectTeamMate.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
Resource pT = projectTeamMatesRepo.save(projectTeamMate);
List<Billing> listBD = getEmployeeActiveNisumBench(pT.getEmployeeId());
Date startDate = pT.getStartDate() != null ? pT.getStartDate() : new Date();
if (listBD != null && listBD.size() >0) {
Billing bDetails = listBD.get(0);
if (startDate.compareTo(bDetails.getBillingStartDate()) > 0) {
bDetails.setBillingEndDate(DateUtils.truncate(DateUtils.addDays(startDate, -1), Calendar.DATE));
} else {
bDetails.setBillingEndDate(startDate);
}
bDetails.setActive(false);
updateEmployeeBilling(bDetails, loginEmpId);
}
Billing billings = new Billing();
billings.setEmployeeId(pT.getEmployeeId());
billings.setEmployeeName(pT.getEmployeeName());
billings.setProjectId(pT.getProjectId());
billings.setProjectName(pT.getProjectName());
billings.setBillableStatus(pT.getBillableStatus());
billings.setAccount(pT.getAccount());
billings.setActive(pT.isActive());
if (!projectTeamMate.getProjectId().equalsIgnoreCase("Nisum0000")) {
billings.setBillingStartDate(DateUtils.truncate(pT.getNewBillingStartDate(), Calendar.DATE));
} else {
billings.setBillingStartDate(DateUtils.truncate(pT.getStartDate(), Calendar.DATE));
}
if (pT.getEndDate() != null) {
billings.setBillingEndDate(DateUtils.truncate(pT.getEndDate(), Calendar.DATE));
}
//billings.setCreateDate(new Date()); //commented as we have added audit fields
//updateProjectEndDateInBillingDetails(projectTeamMate.getNewBillingStartDate(), billings);
addEmployeeBillingDetails(billings, loginEmpId);
addShiftDetails(projectTeamMate, loginEmpId);
addOrUpdateTeamMateRole(projectTeamMate.getRole(), projectTeamMate.getProjectId(), projectTeamMate.getEmployeeId(), false, loginEmpId);
return pT;
}
private void addOrUpdateTeamMateRole(String role, String projectId, String empId, boolean isUpdate, String loginEmpId) throws MyTimeException {
Project project = projectRepo.findByProjectId(projectId);
int operationType = 0; //0 = No Operation, 1 = Added, 2 = Removed
if (role != null && role.equals("Lead")) {
if (project.getManagerIds() == null) {
project.setManagerIds(Arrays.asList(empId));
operationType = 1;
} else if (project.getManagerIds() != null && !project.getManagerIds().contains(empId)) {
project.getManagerIds().add(empId);
operationType = 1;
}
} else if (isUpdate && project.getManagerIds() != null && project.getManagerIds().contains(empId)) {// When role got changed from Lead to Employee.
project.getManagerIds().remove(empId);
operationType = 2;
}
if (operationType > 0) {
project.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);//setting audit fields
projectRepo.save(project);
Query query = new Query(Criteria.where("employeeId").is(empId).and("role").is("Lead"));
List<Resource> projectMates = mongoTemplate.find(query, Resource.class);
String roleId = roleInfoService.getRole(MyTimeUtils.LEAD);
if (operationType ==1) {
roleMappingService.addEmployeeRole(empId, roleId);
} else if (projectMates.size() == 0 || operationType == 2) {
roleMappingService.deleteRole(empId, roleId);
}
}
}
@Override
public String updateTeammate(Resource projectTeamMate, String loginEmpId) throws MyTimeException {
//String result = null;
MyTeamResultDTO myResultDto = new MyTeamResultDTO();
myResultDto.setResultCode(MyTeamResultDTO.SUCCESS_CODE);
myResultDto.setResultData("TeamMate updated successfuly");
Resource existingTeammate = projectTeamMatesRepo.findById(projectTeamMate.getId());
List<Billing> listBD = getEmployeeActiveBillingDetails(projectTeamMate.getEmployeeId(), projectTeamMate.getProjectId());
Date resEndDate = projectTeamMate.getEndDate();
//Handling past or present endDate (To "Inactive" the Resource)
if (resEndDate.compareTo(new Date()) <= 0 && resEndDate.compareTo(existingTeammate.getEndDate()) != 0) {
existingTeammate.setActive(false);
existingTeammate.setEndDate(resEndDate);
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetailsExisting = listBD.get(0);
Date actualEndDate = resEndDate;
billingDetailsExisting.setBillingEndDate(actualEndDate);
billingDetailsExisting.setActive(false);
updateEmployeeBilling(billingDetailsExisting, loginEmpId);
}
Project project = projectRepo.findByProjectId(MyTimeUtils.BENCH_PROJECT_ID);
Resource newBenchAllocation = new Resource();
Billing billingDetails = new Billing();
billingDetails.setBillableStatus(MyTimeUtils.BENCH_BILLABILITY_STATUS);
billingDetails.setBillingStartDate(resEndDate);
billingDetails.setAccount(MyTimeUtils.BENCH_ACCOUNT);
billingDetails.setActive(true);
billingDetails.setEmployeeId(existingTeammate.getEmployeeId());
billingDetails.setEmployeeName(existingTeammate.getEmployeeName());
//billingDetails.setCreateDate(new Date());// Commented as added common audit fields
billingDetails.setProjectId(MyTimeUtils.BENCH_PROJECT_ID);
billingDetails.setProjectName(MyTimeUtils.FREE_POLL);
if(project != null) {
billingDetails.setBillingEndDate(project.getProjectEndDate());
newBenchAllocation.setAccountId(project.getAccountId());
newBenchAllocation.setDomainId(project.getDomainId());
newBenchAllocation.setProjectName(project.getProjectName());
newBenchAllocation.setEndDate(project.getProjectEndDate());
}
addEmployeeBillingDetails(billingDetails, loginEmpId);
newBenchAllocation.setBillableStatus(MyTimeUtils.BENCH_BILLABILITY_STATUS);
newBenchAllocation.setDesignation(existingTeammate.getDesignation());
newBenchAllocation.setEmailId(existingTeammate.getEmailId());
newBenchAllocation.setEmployeeId(existingTeammate.getEmployeeId());
newBenchAllocation.setActive(true);
newBenchAllocation.setEmployeeName(existingTeammate.getEmployeeName());
newBenchAllocation.setProjectId(MyTimeUtils.BENCH_PROJECT_ID);
newBenchAllocation.setShift(existingTeammate.getShift());
newBenchAllocation.setRole(existingTeammate.getRole());
Calendar cal = Calendar.getInstance();
cal.setTime(resEndDate);
cal.add(Calendar.DAY_OF_MONTH, 1);
newBenchAllocation.setStartDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
newBenchAllocation.setNewBillingStartDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
newBenchAllocation.setAuditFields(loginEmpId, MyTimeUtils.CREATE);//Setting audit fields
projectTeamMatesRepo.save(newBenchAllocation);
myResultDto.setResultCode(MyTeamResultDTO.SUCCESS_CODE);
myResultDto.setResultData("Resource Successfully moved from " + projectTeamMate.getProjectName() + " project to Bench.");
} else {
//Handling Resource Project Billability Status change
if (projectTeamMate.getBillableStatus() != null && existingTeammate.getBillableStatus() != null
&& !existingTeammate.getBillableStatus().equalsIgnoreCase(projectTeamMate.getBillableStatus())) {
/*List<BillingDetails> bDetailsList = teamMatesBillingRepo.findByEmployeeId(projectTeamMate.getEmployeeId()).stream()
.filter(e -> (!e.isActive())).sorted(Comparator.comparing(BillingDetails::getBillingEndDate).reversed())
.collect(Collectors.toList());*/
String result = validateBillabilityStartDate(listBD, projectTeamMate);
if (result != null) { //Invalid Billability Start date
return result;
}
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetails = listBD.get(0);
Calendar cal = Calendar.getInstance();
cal.setTime(projectTeamMate.getNewBillingStartDate());
cal.add(Calendar.DAY_OF_MONTH, -1);
Date startDate = existingTeammate.getNewBillingStartDate() != null ?
existingTeammate.getNewBillingStartDate() : existingTeammate.getStartDate();
if (startDate.getDate() == projectTeamMate.getNewBillingStartDate().getDate()) {
billingDetails.setBillingEndDate(DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE));
} else {
billingDetails.setBillingEndDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
}
billingDetails.setActive(false);
updateEmployeeBilling(billingDetails, loginEmpId);
}
Billing billings = new Billing();
billings.setEmployeeId(projectTeamMate.getEmployeeId());
billings.setEmployeeName(projectTeamMate.getEmployeeName());
billings.setProjectId(projectTeamMate.getProjectId());
billings.setAccount(existingTeammate.getAccount());
billings.setProjectName(projectTeamMate.getProjectName());
billings.setBillableStatus(projectTeamMate.getBillableStatus());
billings.setActive(true);
billings.setBillingStartDate(DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE));
billings.setBillingEndDate(DateUtils.truncate(resEndDate, Calendar.DATE));
//billings.setCreateDate(new Date());// Commented as added common audit fields
addEmployeeBillingDetails(billings,loginEmpId);
existingTeammate.setBillableStatus(projectTeamMate.getBillableStatus());
existingTeammate.setNewBillingStartDate(DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE));
} else {//Handling Billability Start Date change
List<Billing> bDetailsList = teamMatesBillingRepo.findByEmployeeId(projectTeamMate.getEmployeeId()).stream()
.filter(e -> (!e.isActive())).sorted(Comparator.comparing(Billing::getBillingEndDate).reversed())
.collect(Collectors.toList());
String result = validateBillabilityStartDate(bDetailsList, projectTeamMate);
if (result != null) { //Invalid Billability Start date
return result;
}
if (bDetailsList != null && !bDetailsList.isEmpty()) {
Calendar cal = Calendar.getInstance();
cal.setTime(projectTeamMate.getNewBillingStartDate());
cal.add(Calendar.DAY_OF_MONTH, -1);
Billing preBillingDetails = bDetailsList.get(0);
if (preBillingDetails.getBillingStartDate().getDate() == projectTeamMate.getNewBillingStartDate().getDate()) {
preBillingDetails.setBillingEndDate(DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE));
} else {
preBillingDetails.setBillingEndDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
}
updateEmployeeBilling(preBillingDetails, loginEmpId);
}
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetails = listBD.get(0);
billingDetails.setBillingStartDate(DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE));
billingDetails.setBillingEndDate(DateUtils.truncate(resEndDate, Calendar.DATE));
addEmployeeBillingDetails(billingDetails, loginEmpId);
}
existingTeammate.setNewBillingStartDate(DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE));
}
if (resEndDate.compareTo(existingTeammate.getEndDate()) != 0) {
existingTeammate.setEndDate(resEndDate);
}
}
if (MyTeamResultDTO.SUCCESS_CODE.equals(myResultDto.getResultCode())) {
//Handling Role change
if ((existingTeammate.getRole() != null && !existingTeammate.getRole().equalsIgnoreCase(projectTeamMate.getRole()))
|| (projectTeamMate.getRole() != null) && !projectTeamMate.getRole().equalsIgnoreCase(existingTeammate.getRole())) {
existingTeammate.setRole(projectTeamMate.getRole());
addOrUpdateTeamMateRole(projectTeamMate.getRole(), projectTeamMate.getProjectId(), projectTeamMate.getEmployeeId(), true, loginEmpId);
}
//Handling Shift change
if ((existingTeammate.getShift() != null && !existingTeammate.getShift().equalsIgnoreCase(projectTeamMate.getShift()))
|| (projectTeamMate.getShift() != null) && !projectTeamMate.getShift().equalsIgnoreCase(existingTeammate.getShift())) {
updateShiftDetails(existingTeammate, loginEmpId);
existingTeammate.setShift(projectTeamMate.getShift());
Employee employeeDB = employeeRolesRepo.findByEmployeeId(projectTeamMate.getEmployeeId());
employeeDB.setShift(projectTeamMate.getShift());
employeeDB.setModifiedBy(loginEmpId);
employeeDB.setLastModifiedOn(new Date());
employeeRolesRepo.save(employeeDB);
}
existingTeammate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);//Setting audit fields
projectTeamMatesRepo.save(existingTeammate);
}
return myResultDto.getResultData()[myResultDto.getDataArrayCounter()];
}
private String validateBillabilityStartDate(List<Billing> bDetailsList, Resource projectTeamMate) {
String response = null;
if (bDetailsList != null && bDetailsList.size() > 0) {
Billing bDetails = bDetailsList.get(0);
if (projectTeamMate.getNewBillingStartDate().compareTo(bDetails.getBillingStartDate()) < 0) {
response = "Resource Billability Start Date (" + projectTeamMate.getNewBillingStartDate() +" ) for "
+ projectTeamMate.getBillableStatus() + " status should be later than previous billability ("
+ bDetails.getBillableStatus() + " status) Start Date ( " + bDetails.getBillingStartDate() + ").";
}
} else {
response = validateAgainstDOJ(projectTeamMate);
}
return response;
}
@Override
public void updateShiftDetails(Resource existingTeammate, String loginEmpId) {
Query getQuery = new Query();
getQuery.addCriteria(new Criteria().andOperator(Criteria.where("active").is(true),
Criteria.where("employeeId").is(existingTeammate.getEmployeeId())));
//Calendar cal = Calendar.getInstance();
//cal.add(Calendar.DATE, -1);
EmpShiftDetails existingShift = mongoTemplate.findOne(getQuery, EmpShiftDetails.class);
if (existingShift != null) {
existingShift.setActive(false);
//existingShift.setUpdatedDate(new Date());// Commented as added common audit fields
existingShift.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);//Setting audit fields
mongoTemplate.save(existingShift);
}
}
public void deleteProject(String projectId) {
Project project = projectRepo.findByProjectId(projectId);
projectRepo.delete(project);
Query query = new Query(Criteria.where("projectId").is(projectId));
List<Resource> list = mongoTemplate.find(query, Resource.class);
resourceRepo.delete(list);
}
@Override
public void addShiftDetails(Resource projectTeamMate, String loginEmpId) {
EmpShiftDetails empShiftDetails = new EmpShiftDetails();
//empShiftDetails.setCreateDate(new Date());// Commented as added common audit fields
//empShiftDetails.setUpdatedDate(new Date());// Commented as added common audit fields
empShiftDetails.setEmployeeName(projectTeamMate.getEmployeeName());
empShiftDetails.setEmployeeId(projectTeamMate.getEmployeeId());
empShiftDetails.setShift(projectTeamMate.getShift());
empShiftDetails.setActive(projectTeamMate.isActive());
empShiftDetails.setAuditFields(loginEmpId, MyTimeUtils.CREATE);//Setting audit fields
empShiftDetailsRepo.save(empShiftDetails);
}
@Override
public void deleteTeammate(String empId, String projectId, ObjectId id, String loginEmpId) {
Resource existingTeammate = projectTeamMatesRepo.findById(id);
existingTeammate.setActive(false);
existingTeammate.setEndDate(new Date());
Billing billingDetails = new Billing();
billingDetails.setBillableStatus("Non-Billable");
billingDetails.setBillingStartDate(new Date());
billingDetails.setAccount("Nisum");
billingDetails.setActive(true);
billingDetails.setEmployeeId(existingTeammate.getEmployeeId());
billingDetails.setEmployeeName(existingTeammate.getEmployeeName());
// billingDetails.setCreateDate(new Date());// Commented as added common audit fields
billingDetails.setProjectId("Nisum0000");
billingDetails.setProjectName(MyTimeUtils.FREE_POLL);
addEmployeeBillingDetails(billingDetails, loginEmpId);
List<Billing> listBD = getEmployeeActiveBillingDetails(empId,
projectId);
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetailsExisting = listBD.get(0);
Date d = new Date();
d.setDate(d.getDate() - 1);
billingDetailsExisting.setBillingEndDate(d);
billingDetailsExisting.setActive(false);
updateEmployeeBilling(billingDetailsExisting, loginEmpId);
}
existingTeammate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);//Setting audit fields
projectTeamMatesRepo.save(existingTeammate);
Resource newBenchAllocation = new Resource();
newBenchAllocation.setAccount("Nisum");
newBenchAllocation.setBillableStatus("Non-Billable");
newBenchAllocation.setDesignation(existingTeammate.getDesignation());
newBenchAllocation.setEmailId(existingTeammate.getEmailId());
newBenchAllocation.setEmployeeId(existingTeammate.getEmployeeId());
newBenchAllocation.setActive(true);
newBenchAllocation.setEmployeeName(existingTeammate.getEmployeeName());
newBenchAllocation.setProjectId("Nisum0000");
newBenchAllocation.setStartDate(new Date());
Project p = projectRepo.findByProjectId("Nisum0000");
newBenchAllocation.setProjectName(p.getProjectName());
// newBenchAllocation.setManagerId(p.getManagerId());
// newBenchAllocation.setManagerName(p.getManagerName());
newBenchAllocation.setAuditFields(loginEmpId, MyTimeUtils.CREATE);//Setting audit fields
projectTeamMatesRepo.save(newBenchAllocation);
updateShiftDetails(existingTeammate,loginEmpId);
}
@Override
public List<Project> getProjects(String managerId) throws MyTimeException {
public List<HashMap<Object, Object>> getProjects() throws MyTimeException {
/*
* Query query = new Query(Criteria.where("managerId").is(managerId)
* .and("status").ne("Completed")); return mongoTemplate.find(query,
* Project.class);
* MT-79:returns all project info. This will get implemented once
* managers are maintained as List and not attributes return
* projectRepo.findAll();
*/
List<Project> projectList = new ArrayList<>();
List<Project> projects = projectRepo.findByDeliveryLeadIds(managerId);
List<HashMap<Object, Object>> projectList = new ArrayList<>();
List<HashMap<String, String>> EmployeeList = null;
List<HashMap<String, String>> managerList = null;
List<Project> projects = projectRepo.findAll();
for (Project project : projects) {
if (!project.getStatus().equals("Completed")) {
projectList.add(project);
HashMap<Object, Object> projectMap = new HashMap<>();
projectMap.put("id", project.getId());
projectMap.put("projectId", project.getProjectId());
projectMap.put("projectName", project.getProjectName());
Account account = accountRepo.findByAccountId(project.getAccountId());
Domain domain = domainRepo.findByDomainId(project.getDomainId());
if (domain != null)
projectMap.put("domain", domain.getDomainName());
if (account != null)
projectMap.put("account", account.getAccountName());
projectMap.put("accountId", project.getAccountId());
projectMap.put("domainId", project.getDomainId());
projectMap.put("status", project.getStatus());
projectMap.put("employeeIds", project.getEmployeeIds());
projectMap.put("projectStartDate", project.getProjectStartDate());
projectMap.put("projectEndDate", project.getProjectEndDate());
if (project.getDeliveryLeadIds() != null) {
List<String> deliverLeadsId = project.getDeliveryLeadIds();
EmployeeList = employeeService.getDeliveryManagerMap(deliverLeadsId);
projectMap.put("deliveryLeadIds", EmployeeList);
}
if (project.getManagerIds() != null) {
List<String> managerid = project.getManagerIds();
managerList = employeeService.getDeliveryManagerMap(managerid);
projectMap.put("managerIds", managerList);
}
projectList.add(projectMap);
}
return projectList;
}
@Override
public List<Resource> getMyTeamDetails(String empId) {
List<Resource> teamMates = new ArrayList<>();
List<Resource> empRecords = projectTeamMatesRepo
.findByEmployeeId(empId);
for (Resource pt : empRecords) {
if (pt.isActive()) {
teamMates.addAll(projectTeamMatesRepo
.findByProjectId(pt.getProjectId()));
}
}
return teamMates;
}
public Resource addNewBeanchAllocation(Employee employee,String loginEmpId)
{
Resource resourcePersisted=null;
Resource resourceBench = new Resource();
resourceBench.setAccount(MyTimeUtils.BENCH_ACCOUNT);
resourceBench.setBillableStatus(MyTimeUtils.BENCH_BILLABILITY_STATUS);
resourceBench.setDesignation(employee.getDesignation());
resourceBench.setEmailId(employee.getEmailId());
resourceBench.setEmployeeId(employee.getEmployeeId());
resourceBench.setMobileNumber(employee.getMobileNumber());
resourceBench.setEmployeeName(employee.getEmployeeName());
resourceBench.setProjectId(MyTimeUtils.BENCH_PROJECT_ID);
resourceBench.setStartDate(employee.getDateOfJoining() != null ? employee.getDateOfJoining() : new Date());
Project project = projectRepo.findByProjectId(MyTimeUtils.BENCH_PROJECT_ID);
resourceBench.setProjectName(project.getProjectName());
resourceBench.setAccountId(project.getAccountId());
resourceBench.setDomainId(project.getDomainId());
resourceBench.setShift(employee.getShift());
resourceBench.setRole(employee.getRole());
@Override
public List<Employee> getUnAssignedEmployees() {
List<Employee> allEmployees = employeeRolesRepo.findAll();
List<Employee> notAssignedEmployees = new ArrayList<>();
List<String> teamMates = new ArrayList<>();
List<Resource> empRecords = projectTeamMatesRepo.findAll();
for (Resource pt : empRecords) {
Project project = projectRepo.findByProjectId(pt.getProjectId());
if (project != null && project.getStatus() != null
&& !"Completed".equalsIgnoreCase(project.getStatus())) {
teamMates.add(pt.getEmployeeId());
}
if ( null != employee.getEmpStatus() && employee.getEmpStatus().trim().equalsIgnoreCase(MyTimeUtils.IN_ACTIVE_SPACE)) {
resourceBench.setEndDate(employee.getEndDate());
resourceBench.setActive(false);
} else {
employee.setEmpStatus(MyTimeUtils.ACTIVE);
resourceBench.setEndDate(project.getProjectEndDate());
resourceBench.setActive(true);
}
for (Employee emp : allEmployees) {
if (!teamMates.contains(emp.getEmployeeId())) {
notAssignedEmployees.add(emp);
}
try {
resourcePersisted= resourceService.addResource(resourceBench, loginEmpId);
} catch (MyTimeException e) {
e.printStackTrace();
}
return notAssignedEmployees;
}
return resourcePersisted;
}
@Override
public List<Resource> getShiftDetails(String shift) {
List<Resource> employeeDetails = null;
List<Resource> shiftEmpDetails = new ArrayList<>();
List<Project> projects = projectRepo.findAll();
for (Project pt : projects) {
if ("Active".equalsIgnoreCase(pt.getStatus())) {
employeeDetails = projectTeamMatesRepo.findByProjectId(pt.getProjectId());
for (Resource emp : employeeDetails) {
if (emp.getShift() != null && emp.getShift().equalsIgnoreCase(shift) && emp.isActive()) {
shiftEmpDetails.add(emp);
} else if (emp.getShift() == null && "Shift 1(9:00 AM - 6:00 PM)".equalsIgnoreCase(shift) && emp.isActive())
shiftEmpDetails.add(emp);
}
}
}
return shiftEmpDetails;
public List<EmpLoginData> employeeLoginsBasedOnDate(long id,
String fromDate, String toDate) throws MyTimeException {
return employeeDataBaseService.fetchEmployeeLoginsBasedOnDates(id, fromDate, toDate);
}
@Override
public List<Resource> getAllProjectDetails() {
List<Project> projects = projectRepo.findAll();
List<Resource> allprojectMates = new ArrayList<>();
for (Project pt : projects) {
if (!"Completed".equalsIgnoreCase(pt.getStatus())) {
List<Resource> employeeDetails = projectTeamMatesRepo
.findByProjectId(pt.getProjectId());
allprojectMates.addAll(employeeDetails);
}
}
return allprojectMates;
public String generatePdfReport(long id, String fromDate, String toDate) throws MyTimeException {
return pdfReportGenerator.generateeReport(id, fromDate, toDate);
}
@Override
public List<Resource> getProjectDetails(String projectId,String statusFlag) {
List<Resource> teamMatesList = new ArrayList<>();
List<Resource> teamMates = projectTeamMatesRepo.findByProjectId(projectId);
for (Resource projectTeamMate : teamMates) {
Date endDate = projectTeamMate.getEndDate();
if (endDate != null) {
// Active
if (statusFlag.equals(MyTimeUtils.ACTIVE) && endDate.compareTo(new Date()) >= 0)
teamMatesList.add(projectTeamMate);
else if (statusFlag.equals(MyTimeUtils.IN_ACTIVE) && endDate.compareTo(new Date()) < 0)
teamMatesList.add(projectTeamMate);
else if (statusFlag.equals(MyTimeUtils.BOTH))
teamMatesList.add(projectTeamMate);
}
}
return teamMatesList;
}
@Override
public List<Resource> getMyProjectAllocations(String empId) {
return projectTeamMatesRepo.findByEmployeeId(empId);
}
@Override
public List<Billing> getEmployeeBillingDetails(String empId, String projectId) {
List<Billing> billings = teamMatesBillingRepo.findByEmployeeIdAndProjectId(empId, projectId);
List<Billing> billingsSorted = billings;
try {
billingsSorted = (billings == null || billings.size() == 0) ? billings : billings.stream().sorted(
Comparator.comparing(Billing::getCreatedOn).reversed()).collect(Collectors.toList());
} catch (Exception e) {
}
return billingsSorted;
}
@Override
public List<Billing> getEmployeeBillingDetailsAll(String empId) {
List<Billing> billings = teamMatesBillingRepo.findByEmployeeId(empId);
List<Billing> billingsSorted = billings;
try {
billingsSorted = (billings == null || billings.size() == 0) ? billings : billings.stream().sorted(
Comparator.comparing(Billing::getCreatedOn).reversed()).collect(Collectors.toList());
} catch (Exception e) {
}
return billingsSorted;
}
@Override
public List<Billing> getEmployeeActiveBillingDetails(String empId, String projectId) {
Query query4 = new Query();
query4.addCriteria(Criteria.where("active").is(new Boolean(true)));
query4.addCriteria(Criteria.where("employeeId").is(empId));
query4.addCriteria(Criteria.where("projectId").is(projectId));
List<Billing> billings = mongoTemplate.find(query4, Billing.class);
List<Billing> billingsSorted = billings;
try {
billingsSorted = (billings == null || billings.size() == 0) ? billings : billings.stream().sorted(
Comparator.comparing(Billing::getBillingStartDate).reversed()).collect(Collectors.toList());
} catch (Exception e) {
public List<Resource> getResourcesUnderProject(String empId) {
List<String> projectsIdsList = new ArrayList<>();
List<Resource> resourcesList = new ArrayList<>();
List<Project> projectsList = projectRepo.findByDeliveryLeadIds(empId);
for (Project project : projectsList)
projectsIdsList.add(project.getProjectId());
Query query = new Query(Criteria.where("projectId").in(projectsIdsList));
List<Resource> resourcesListPersisted = mongoTemplate.find(query, Resource.class);
for (Resource resource : resourcesListPersisted) {
if (!resource.getEmployeeId().equals(empId))
resourcesList.add(resource);
}
return billingsSorted;
}
return resourcesList;
@Override
public List<Billing> getEmployeeActiveNisumBench(String empId) {
Query query4 = new Query();
query4.addCriteria(Criteria.where("active").is(new Boolean(true)));
query4.addCriteria(Criteria.where("projectId").is("Nisum0000"));
query4.addCriteria(Criteria.where("employeeId").is(empId));
List<Billing> billings = mongoTemplate.find(query4, Billing.class);
List<Billing> billingsSorted = billings;
try {
billingsSorted = (billings == null || billings.size() == 0) ? billings : billings.stream().sorted(
Comparator.comparing(Billing::getBillingStartDate).reversed()).collect(Collectors.toList());
} catch (Exception e) {
}
return billingsSorted;
}
@Override
public Billing addEmployeeBillingDetails(Billing billingDetails, String loginEmpId) {
billingDetails.setAuditFields(loginEmpId, MyTimeUtils.CREATE);//Setting audit fields
return teamMatesBillingRepo.save(billingDetails);
}
@Override
public Billing updateEmployeeBilling(Billing billingDetails, String loginEmpId) {
billingDetails.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);//Setting audit fields
return teamMatesBillingRepo.save(billingDetails);
}
// Update ProjectEndDate column data in ProjectTeamMate.
private void updateProjectEndDateInProjectTeamMate(Resource projectTeamMate, String loginEmpId) {
List<Resource> projectTeamMateList = mongoTemplate
.find(getQuery(projectTeamMate.getEmployeeId(), MyTimeUtils.ENDDATE_COLUMN), Resource.class);
log.info("the project teamates list is::"+projectTeamMateList);
if (!CollectionUtils.isEmpty(projectTeamMateList)) {
Resource teamMate = projectTeamMateList.get(0);
if(projectTeamMate.getNewBillingStartDate()!=null)
{
Date d = projectTeamMate.getNewBillingStartDate();
Calendar cal = Calendar.getInstance();
cal.setTime(d);
cal.add(Calendar.DAY_OF_MONTH, -1);
Date oneDayLess = cal.getTime();
Date startDate = teamMate.getNewBillingStartDate() != null ? teamMate.getNewBillingStartDate() : teamMate.getStartDate();
if(startDate.getDate() == projectTeamMate.getNewBillingStartDate().getDate()){
teamMate.setEndDate(DateUtils.truncate(projectTeamMate.getEndDate(), Calendar.DATE));
}else {
teamMate.setEndDate(DateUtils.truncate(oneDayLess, Calendar.DATE));
}
}
teamMate.setActive(false);
teamMate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);//Setting audit fields
projectTeamMatesRepo.save(teamMate);
}
@Override
public List<Project> getProjectsUnderDeliveryLead(String deliveryLeadId) throws MyTimeException {
}
List<Project> projectList = new ArrayList<>();
List<Project> projectListPersisted = projectRepo.findByDeliveryLeadIds(deliveryLeadId);
for (Project project : projectListPersisted) {
if (!project.getStatus().equals("Completed")) {
projectList.add(project);
}
}
return projectList;
}
/* // Update BillingEndDate in BillingDetails.
private void updateProjectEndDateInBillingDetails(Date newBillingStartDate, BillingDetails billingDetails) {
List<BillingDetails> billingDetailsList = mongoTemplate.find(
getQuery(billingDetails.getEmployeeId(), MyTimeUtils.CREATED_DATE_COLUMN), BillingDetails.class);
if (!CollectionUtils.isEmpty(billingDetailsList)) {
BillingDetails billing = billingDetailsList.get(0);
Date d = billingDetails.getBillingStartDate();
Calendar cal = Calendar.getInstance();
cal.setTime(d);
cal.add(Calendar.DAY_OF_MONTH, -1);
Date oneDayLess = cal.getTime();
if (billing.getBillingStartDate().getDate() == billingDetails.getBillingStartDate().getDate()) {
billing.setBillingEndDate(DateUtils.truncate(billingDetails.getBillingEndDate(), Calendar.DATE));
} else {
billing.setBillingEndDate(DateUtils.truncate(oneDayLess, Calendar.DATE));
@Override
public List<Employee> getUnAssignedEmployees() {
List<Employee> employeesList = employeeService.getAllEmployees();
List<Employee> notAssignedEmployees = new ArrayList<>();
List<String> resourceIdsList = new ArrayList<>();
List<Resource> resourceListPersisted = resourceService.getAllResources();
for (Resource resource : resourceListPersisted) {
Project project = projectRepo.findByProjectId(resource.getProjectId());
if (project != null && project.getStatus() != null && !"Completed".equalsIgnoreCase(project.getStatus())) {
resourceIdsList.add(resource.getEmployeeId());
}
teamMatesBillingRepo.save(billing);
}
}
}
for (Employee employee : employeesList) {
if (!resourceIdsList.contains(employee.getEmployeeId())) {
notAssignedEmployees.add(employee);
}
}
return notAssignedEmployees;
}
// Update ProjectEndDate
private void updateProjectEndDate(Date newBillingStartDate, String employeeId, String projectName,String dateColumn,
String collectionName) {
DBCollection collection = mongoTemplate.getCollection(collectionName);
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.append(MyTimeUtils.EMPLOYEE_ID, employeeId);
searchQuery.append(MyTimeUtils.PROJECT_NAME, projectName);
BasicDBObject updateQuery = new BasicDBObject();
updateQuery.append(MyTimeUtils.SET, new BasicDBObject().append(dateColumn,DateUtils.addDays(
newBillingStartDate, MyTimeUtils.MINUS_ONE)));
collection.update(searchQuery, updateQuery);
}*/
private Query getQuery(String employeeId, String dateColumn) {
Query query = new Query();
query.addCriteria(Criteria.where(MyTimeUtils.EMPLOYEE_ID).is(employeeId));
query.limit(MyTimeUtils.ONE);
query.with(new Sort(Sort.Direction.DESC, dateColumn));
return query;
}
@Override
public void deleteEmployeeBilling(Billing teamMate) {
teamMatesBillingRepo.delete(teamMate);
}
@Override
public List<Project> getAllProjects() {
return projectRepo.findAll();
}
@Override
public List<EmployeeDashboardVO> getEmployeesDashBoard() {
List<Employee> allEmployees = employeeRolesRepo.findAll();
List<Employee> allEmployees = employeeRepo.findAll();
List<EmployeeDashboardVO> employeeDashboard = new ArrayList<>();
Map<String, Object> teamMatesMap = new HashMap();
Map<String, Object> teamMatesStatusMap = new HashMap();
// Find all active employees
List<Resource> teamMates = projectTeamMatesRepo.findAll();
List<Resource> teamMates = resourceRepo.findAll();
for (Resource teamMate : teamMates) {
if (teamMate.isActive()) {
Project project = projectRepo
......@@ -1030,36 +499,16 @@ public class ProjectService implements IProjectService {
return employeeDashboard;
}
@Override
public List<Resource> findByAccountAndActiveAndBillableStatus(
String account, boolean status, String billableStatus) {
return projectTeamMatesRepo.findByAccountAndActiveAndBillableStatus(
account, status, billableStatus);
}
public List<HashMap<String, String>> getEmployeeData(List<String> ids) {
List<HashMap<String, String>> EmployeeList = new ArrayList<>();
Query query = new Query(Criteria.where("employeeId").in(ids));
List<Employee> employeeRoles = mongoTemplate.find(query,
Employee.class);
for (Employee employeesRole : employeeRoles) {
HashMap<String, String> managerMap = new HashMap<>();
managerMap.put("employeeId", employeesRole.getEmployeeId());
managerMap.put("employeeName", employeesRole.getEmployeeName());
EmployeeList.add(managerMap);
}
return EmployeeList;
}
@Override
public String addProjectTeamMateWithCheck(Resource projectTeamMate, String loginEmpId) throws MyTimeException {
public String addProjectTeamMateWithCheck(Resource resource, String loginEmpId) throws MyTimeException {
boolean flag = false;
String projectName = null;
String fromDate = null;
String toDate = null;
String result = null;
List<Resource> teamMateList = projectTeamMatesRepo.findByEmployeeId(projectTeamMate.getEmployeeId()).stream()
List<Resource> teamMateList = resourceRepo.findByEmployeeId(resource.getEmployeeId()).stream()
.filter(e -> !("Nisum0000".equalsIgnoreCase(e.getProjectId())))
.sorted(Comparator.comparing(Resource::getEndDate).reversed())
.collect(Collectors.toList());
......@@ -1074,12 +523,12 @@ public class ProjectService implements IProjectService {
}
}
if (flag) {// If yes, error thrown to user.
result = "Resource " + projectTeamMate.getEmployeeId() + " already Assigned to the " + projectName
result = "Resource " + resource.getEmployeeId() + " already Assigned to the " + projectName
+ " Project" + " from " + fromDate + "to " + toDate;
} else {// If no, validating new project assignment start date against previous project end date.
result = validateNewProjectAssignmentStartDate(teamMateList, projectTeamMate);
result = validateNewProjectAssignmentStartDate(teamMateList, resource);
if (result == null) {
addProjectTeamMate(projectTeamMate, loginEmpId);
resourceService.addResource(resource, loginEmpId);
result = "TeamMate added successfuly";
}
}
......@@ -1103,7 +552,7 @@ public class ProjectService implements IProjectService {
private String validateAgainstDOJ(Resource projectTeamMate) {
String response = null;
Date empDoj = employeeRolesRepo.findByEmployeeId(projectTeamMate.getEmployeeId()).getDateOfJoining();
Date empDoj = employeeRepo.findByEmployeeId(projectTeamMate.getEmployeeId()).getDateOfJoining();
if(projectTeamMate.getNewBillingStartDate().compareTo(empDoj) < 0) {
response = "Resource Start Date (" + projectTeamMate.getNewBillingStartDate() +" ) in " + projectTeamMate.getProjectName()
+ " project should not be before Date of Joining ( " + empDoj + ").";
......@@ -1112,7 +561,7 @@ public class ProjectService implements IProjectService {
}
@Override
public List<HashMap<Object, Object>> projectsInfoByEmpId(String empId){
public List<HashMap<Object, Object>> getProjectsForEmployee(String empId){
HashMap<Object, Object> projectMap =null;
List<HashMap<Object, Object>> projectList = new ArrayList<>();
......@@ -1120,16 +569,16 @@ public class ProjectService implements IProjectService {
Account account = null;
Domain domain = null;
List<Resource> projectAllocations = getMyProjectAllocations(empId);
List<Resource> resourcesAllocatedList = resourceService.getResourcesForEmployee(empId);
if( null != projectAllocations && !projectAllocations.isEmpty() && MyTimeUtils.INT_ZERO < projectAllocations.size()) {
for (Resource ptm : projectAllocations) {
if( null != resourcesAllocatedList && !resourcesAllocatedList.isEmpty() && MyTimeUtils.INT_ZERO < resourcesAllocatedList.size()) {
for (Resource resource : resourcesAllocatedList) {
projectMap = new HashMap<>();
project = projectRepo.findByProjectId(ptm.getProjectId());
project = projectRepo.findByProjectId(resource.getProjectId());
account = accountRepo.findByAccountId(ptm.getAccountId());
domain = domainRepo.findByDomainId(ptm.getDomainId());
account = accountRepo.findByAccountId(resource.getAccountId());
domain = domainRepo.findByDomainId(resource.getDomainId());
projectMap.put("id", project.getId());
projectMap.put("projectId", project.getProjectId());
......@@ -1141,21 +590,21 @@ public class ProjectService implements IProjectService {
if (account != null)
projectMap.put("account", account.getAccountName());
projectMap.put("accountId", account!=null?account.getAccountId():ptm.getAccountId());
projectMap.put("domainId", domain!=null? domain.getDomainId() : ptm.getDomainId() );
projectMap.put("status", ptm.isActive());
projectMap.put("projectStartDate",ptm.getStartDate());
projectMap.put("projectEndDate",ptm.getEndDate());
projectMap.put("employeeIds", ptm.getEmployeeId());
projectMap.put("shift", ptm.getShift());
projectMap.put("billableStatus", ptm.getBillableStatus());
projectMap.put("accountId", account!=null?account.getAccountId():resource.getAccountId());
projectMap.put("domainId", domain!=null? domain.getDomainId() : resource.getDomainId() );
projectMap.put("status", resource.isActive());
projectMap.put("projectStartDate",resource.getStartDate());
projectMap.put("projectEndDate",resource.getEndDate());
projectMap.put("employeeIds", resource.getEmployeeId());
projectMap.put("shift", resource.getShift());
projectMap.put("billableStatus", resource.getBillableStatus());
if (project.getDeliveryLeadIds() != null) {
projectMap.put("deliveryLeadIds", getEmployeeData(project.getDeliveryLeadIds()));
projectMap.put("deliveryLeadIds", employeeService.getDeliveryManagerMap(project.getDeliveryLeadIds()));
}
if (project.getManagerIds() != null) {
projectMap.put("managerIds", getEmployeeData(project.getManagerIds()));
projectMap.put("managerIds", employeeService.getDeliveryManagerMap(project.getManagerIds()));
}
projectList.add(projectMap);
......@@ -1209,8 +658,8 @@ public class ProjectService implements IProjectService {
projectMap.put("status", obj.getStatus());
projectMap.put("deliveryLeadIds", null != obj.getDeliveryLeadIds() ? getEmployeeData(obj.getDeliveryLeadIds()) : "");
projectMap.put("managerIds", null != obj.getManagerIds() ? getEmployeeData(obj.getManagerIds()) : "");
projectMap.put("deliveryLeadIds", null != obj.getDeliveryLeadIds() ? employeeService.getDeliveryManagerMap(obj.getDeliveryLeadIds()) : "");
projectMap.put("managerIds", null != obj.getManagerIds() ? employeeService.getDeliveryManagerMap(obj.getManagerIds()) : "");
projectsList.add(projectMap);
}
......
src/main/java/com/nisum/mytime/service/impl/ResourceService.java
View file @ c63bc59d
package com.nisum.mytime.service.impl;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Billing;
import com.nisum.mytime.model.Employee;
import com.nisum.mytime.model.EmployeeShift;
import com.nisum.mytime.model.Project;
import com.nisum.mytime.model.Resource;
import com.nisum.mytime.repository.BillingRepo;
import com.nisum.mytime.repository.EmployeeRepo;
import com.nisum.mytime.repository.ProjectRepo;
import com.nisum.mytime.repository.ResourceRepo;
import com.nisum.mytime.service.IEmployeeRoleService;
import com.nisum.mytime.service.IResourceService;
import com.nisum.mytime.service.IRoleService;
import com.nisum.mytime.utils.MyTeamResultDTO;
import com.nisum.mytime.utils.MyTimeUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.time.DateUtils;
import org.bson.types.ObjectId;
@Service
@Slf4j
......@@ -28,10 +47,417 @@ public class ResourceService implements IResourceService {
@Autowired
private ResourceRepo resourceRepo;
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private IRoleService roleInfoService;
@Autowired
private IEmployeeRoleService roleMappingService;
@Autowired
private ProjectRepo projectRepo;
@Autowired
private BillingRepo billingRepo;
@Autowired
private ProjectService projectService;
@Autowired
private EmployeeRepo employeeRoleRepo;
public Resource save(Resource resource) {
return resourceRepo.save(resource);
}
@Override
public Resource addResource(Resource resourceReq, String loginEmpId) throws MyTimeException {
// calling a method
updateProjectEndDateForResource(resourceReq, loginEmpId);
resourceReq.setAuditFields(loginEmpId, MyTimeUtils.CREATE);
Resource resourcePersisted = resourceRepo.save(resourceReq);
// Get Active billings for Nisum Bench Project.
List<Billing> listBD = billingService.getActiveBillings(resourcePersisted.getEmployeeId(), "Nisum0000");
Date startDate = resourcePersisted.getStartDate() != null ? resourcePersisted.getStartDate() : new Date();
if (listBD != null && listBD.size() > 0) {
Billing bDetails = listBD.get(0);
if (startDate.compareTo(bDetails.getBillingStartDate()) > 0) {
bDetails.setBillingEndDate(DateUtils.truncate(DateUtils.addDays(startDate, -1), Calendar.DATE));
} else {
bDetails.setBillingEndDate(startDate);
}
bDetails.setActive(false);
billingService.updateBilling(bDetails, loginEmpId);
}
Billing billings = new Billing();
billings.setEmployeeId(resourcePersisted.getEmployeeId());
billings.setEmployeeName(resourcePersisted.getEmployeeName());
billings.setProjectId(resourcePersisted.getProjectId());
billings.setProjectName(resourcePersisted.getProjectName());
billings.setBillableStatus(resourcePersisted.getBillableStatus());
billings.setAccount(resourcePersisted.getAccount());
billings.setActive(resourcePersisted.isActive());
if (!resourceReq.getProjectId().equalsIgnoreCase("Nisum0000")) {
billings.setBillingStartDate(DateUtils.truncate(resourcePersisted.getNewBillingStartDate(), Calendar.DATE));
} else {
billings.setBillingStartDate(DateUtils.truncate(resourcePersisted.getStartDate(), Calendar.DATE));
}
if (resourcePersisted.getEndDate() != null) {
billings.setBillingEndDate(DateUtils.truncate(resourcePersisted.getEndDate(), Calendar.DATE));
}
billingService.addBilling(billings, loginEmpId);
empShiftService.addEmployeeShift(resourceReq, loginEmpId);
// calling method
addOrUpdateTeamMateRole(resourceReq.getRole(), resourceReq.getProjectId(), resourceReq.getEmployeeId(), false,
loginEmpId);
return resourcePersisted;
}
@Override
public String updateResource(Resource resource, String loginEmpId) throws MyTimeException {
// String result = null;
MyTeamResultDTO myResultDto = new MyTeamResultDTO();
myResultDto.setResultCode(MyTeamResultDTO.SUCCESS_CODE);
myResultDto.setResultData("TeamMate updated successfuly");
Resource existingTeammate = resourceRepo.findById(resource.getId());
List<Billing> listBD = billingService.getActiveBillings(resource.getEmployeeId(), resource.getProjectId());
Date resEndDate = resource.getEndDate();
// Handling past or present endDate (To "Inactive" the Resource)
if (resEndDate.compareTo(new Date()) <= 0 && resEndDate.compareTo(existingTeammate.getEndDate()) != 0) {
existingTeammate.setActive(false);
existingTeammate.setEndDate(resEndDate);
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetailsExisting = listBD.get(0);
Date actualEndDate = resEndDate;
billingDetailsExisting.setBillingEndDate(actualEndDate);
billingDetailsExisting.setActive(false);
billingService.updateBilling(billingDetailsExisting, loginEmpId);
}
Project project = projectRepo.findByProjectId(MyTimeUtils.BENCH_PROJECT_ID);
Resource newBenchAllocation = new Resource();
Billing billingDetails = new Billing();
billingDetails.setBillableStatus(MyTimeUtils.BENCH_BILLABILITY_STATUS);
billingDetails.setBillingStartDate(resEndDate);
billingDetails.setAccount(MyTimeUtils.BENCH_ACCOUNT);
billingDetails.setActive(true);
billingDetails.setEmployeeId(existingTeammate.getEmployeeId());
billingDetails.setEmployeeName(existingTeammate.getEmployeeName());
// billingDetails.setCreateDate(new Date());// Commented as added
// common audit fields
billingDetails.setProjectId(MyTimeUtils.BENCH_PROJECT_ID);
billingDetails.setProjectName(MyTimeUtils.FREE_POLL);
if (project != null) {
billingDetails.setBillingEndDate(project.getProjectEndDate());
newBenchAllocation.setAccountId(project.getAccountId());
newBenchAllocation.setDomainId(project.getDomainId());
newBenchAllocation.setProjectName(project.getProjectName());
newBenchAllocation.setEndDate(project.getProjectEndDate());
}
billingService.addBilling(billingDetails, loginEmpId);
newBenchAllocation.setBillableStatus(MyTimeUtils.BENCH_BILLABILITY_STATUS);
newBenchAllocation.setDesignation(existingTeammate.getDesignation());
newBenchAllocation.setEmailId(existingTeammate.getEmailId());
newBenchAllocation.setEmployeeId(existingTeammate.getEmployeeId());
newBenchAllocation.setActive(true);
newBenchAllocation.setEmployeeName(existingTeammate.getEmployeeName());
newBenchAllocation.setProjectId(MyTimeUtils.BENCH_PROJECT_ID);
newBenchAllocation.setShift(existingTeammate.getShift());
newBenchAllocation.setRole(existingTeammate.getRole());
Calendar cal = Calendar.getInstance();
cal.setTime(resEndDate);
cal.add(Calendar.DAY_OF_MONTH, 1);
newBenchAllocation.setStartDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
newBenchAllocation.setNewBillingStartDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
newBenchAllocation.setAuditFields(loginEmpId, MyTimeUtils.CREATE);// Setting
// audit
// fields
resourceRepo.save(newBenchAllocation);
myResultDto.setResultCode(MyTeamResultDTO.SUCCESS_CODE);
myResultDto.setResultData(
"Resource Successfully moved from " + resource.getProjectName() + " project to Bench.");
} else {
// Handling Resource Project Billability Status change
if (resource.getBillableStatus() != null && existingTeammate.getBillableStatus() != null
&& !existingTeammate.getBillableStatus().equalsIgnoreCase(resource.getBillableStatus())) {
/*
* List<BillingDetails> bDetailsList =
* teamMatesBillingRepo.findByEmployeeId(projectTeamMate.
* getEmployeeId()).stream() .filter(e ->
* (!e.isActive())).sorted(Comparator.comparing(BillingDetails::
* getBillingEndDate).reversed()) .collect(Collectors.toList());
*/
String result = validateBillabilityStartDate(listBD, resource);
if (result != null) { // Invalid Billability Start date
return result;
}
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetails = listBD.get(0);
Calendar cal = Calendar.getInstance();
cal.setTime(resource.getNewBillingStartDate());
cal.add(Calendar.DAY_OF_MONTH, -1);
Date startDate = existingTeammate.getNewBillingStartDate() != null
? existingTeammate.getNewBillingStartDate() : existingTeammate.getStartDate();
if (startDate.getDate() == resource.getNewBillingStartDate().getDate()) {
billingDetails.setBillingEndDate(
DateUtils.truncate(resource.getNewBillingStartDate(), Calendar.DATE));
} else {
billingDetails.setBillingEndDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
}
billingDetails.setActive(false);
billingService.updateBilling(billingDetails, loginEmpId);
}
Billing billings = new Billing();
billings.setEmployeeId(resource.getEmployeeId());
billings.setEmployeeName(resource.getEmployeeName());
billings.setProjectId(resource.getProjectId());
billings.setAccount(existingTeammate.getAccount());
billings.setProjectName(resource.getProjectName());
billings.setBillableStatus(resource.getBillableStatus());
billings.setActive(true);
billings.setBillingStartDate(DateUtils.truncate(resource.getNewBillingStartDate(), Calendar.DATE));
billings.setBillingEndDate(DateUtils.truncate(resEndDate, Calendar.DATE));
// billings.setCreateDate(new Date());// Commented as added
// common audit fields
billingService.addBilling(billings, loginEmpId);
existingTeammate.setBillableStatus(resource.getBillableStatus());
existingTeammate
.setNewBillingStartDate(DateUtils.truncate(resource.getNewBillingStartDate(), Calendar.DATE));
} else {// Handling Billability Start Date change
List<Billing> bDetailsList = billingRepo.findByEmployeeId(resource.getEmployeeId()).stream()
.filter(e -> (!e.isActive()))
.sorted(Comparator.comparing(Billing::getBillingEndDate).reversed())
.collect(Collectors.toList());
String result = validateBillabilityStartDate(bDetailsList, resource);
if (result != null) { // Invalid Billability Start date
return result;
}
if (bDetailsList != null && !bDetailsList.isEmpty()) {
Calendar cal = Calendar.getInstance();
cal.setTime(resource.getNewBillingStartDate());
cal.add(Calendar.DAY_OF_MONTH, -1);
Billing preBillingDetails = bDetailsList.get(0);
if (preBillingDetails.getBillingStartDate().getDate() == resource.getNewBillingStartDate()
.getDate()) {
preBillingDetails.setBillingEndDate(
DateUtils.truncate(resource.getNewBillingStartDate(), Calendar.DATE));
} else {
preBillingDetails.setBillingEndDate(DateUtils.truncate(cal.getTime(), Calendar.DATE));
}
billingService.updateBilling(preBillingDetails, loginEmpId);
}
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetails = listBD.get(0);
billingDetails
.setBillingStartDate(DateUtils.truncate(resource.getNewBillingStartDate(), Calendar.DATE));
billingDetails.setBillingEndDate(DateUtils.truncate(resEndDate, Calendar.DATE));
billingService.addBilling(billingDetails, loginEmpId);
}
existingTeammate
.setNewBillingStartDate(DateUtils.truncate(resource.getNewBillingStartDate(), Calendar.DATE));
}
if (resEndDate.compareTo(existingTeammate.getEndDate()) != 0) {
existingTeammate.setEndDate(resEndDate);
}
}
if (MyTeamResultDTO.SUCCESS_CODE.equals(myResultDto.getResultCode())) {
// Handling Role change
if ((existingTeammate.getRole() != null && !existingTeammate.getRole().equalsIgnoreCase(resource.getRole()))
|| (resource.getRole() != null)
&& !resource.getRole().equalsIgnoreCase(existingTeammate.getRole())) {
existingTeammate.setRole(resource.getRole());
addOrUpdateTeamMateRole(resource.getRole(), resource.getProjectId(), resource.getEmployeeId(), true,
loginEmpId);
}
// Handling Shift change
if ((existingTeammate.getShift() != null
&& !existingTeammate.getShift().equalsIgnoreCase(resource.getShift()))
|| (resource.getShift() != null)
&& !resource.getShift().equalsIgnoreCase(existingTeammate.getShift())) {
empShiftService.updateEmployeeShift(existingTeammate, loginEmpId);
existingTeammate.setShift(resource.getShift());
Employee employeeDB = employeeRoleRepo.findByEmployeeId(resource.getEmployeeId());
employeeDB.setShift(resource.getShift());
employeeDB.setModifiedBy(loginEmpId);
employeeDB.setLastModifiedOn(new Date());
employeeRoleRepo.save(employeeDB);
}
existingTeammate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);// Setting
// audit
// fields
resourceRepo.save(existingTeammate);
}
return myResultDto.getResultData()[myResultDto.getDataArrayCounter()];
}
private String validateBillabilityStartDate(List<Billing> billingList, Resource resource) {
String response = null;
if (billingList != null && billingList.size() > 0) {
Billing billing = billingList.get(0);
if (resource.getNewBillingStartDate().compareTo(billing.getBillingStartDate()) < 0) {
response = "Resource Billability Start Date (" + resource.getNewBillingStartDate() + " ) for "
+ resource.getBillableStatus() + " status should be later than previous billability ("
+ billing.getBillableStatus() + " status) Start Date ( " + billing.getBillingStartDate() + ").";
}
} else {
response = validateAgainstDOJ(resource);
}
return response;
}
private String validateAgainstDOJ(Resource resource) {
String response = null;
Date empDoj = employeeRoleRepo.findByEmployeeId(resource.getEmployeeId()).getDateOfJoining();
if (resource.getNewBillingStartDate().compareTo(empDoj) < 0) {
response = "Resource Start Date (" + resource.getNewBillingStartDate() + " ) in "
+ resource.getProjectName() + " project should not be before Date of Joining ( " + empDoj + ").";
}
return response;
}
@Override
public void deleteResource(String empId, String projectId, ObjectId id, String loginEmpId) {
Resource existingResource = resourceRepo.findById(id);
existingResource.setActive(false);
existingResource.setEndDate(new Date());
Billing billingDetails = new Billing();
billingDetails.setBillableStatus("Non-Billable");
billingDetails.setBillingStartDate(new Date());
billingDetails.setAccount("Nisum");
billingDetails.setActive(true);
billingDetails.setEmployeeId(existingResource.getEmployeeId());
billingDetails.setEmployeeName(existingResource.getEmployeeName());
// billingDetails.setCreateDate(new Date());// Commented as added common
// audit fields
billingDetails.setProjectId("Nisum0000");
billingDetails.setProjectName(MyTimeUtils.FREE_POLL);
billingService.addBilling(billingDetails, loginEmpId);
List<Billing> listBD = billingService.getActiveBillings(empId, projectId);
if (listBD != null && !listBD.isEmpty()) {
Billing billingDetailsExisting = listBD.get(0);
Date d = new Date();
d.setDate(d.getDate() - 1);
billingDetailsExisting.setBillingEndDate(d);
billingDetailsExisting.setActive(false);
billingService.updateBilling(billingDetailsExisting, loginEmpId);
}
existingResource.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);// Setting
// audit
// fields
resourceRepo.save(existingResource);
Resource resourceBench = new Resource();
resourceBench.setAccount("Nisum");
resourceBench.setBillableStatus("Non-Billable");
resourceBench.setDesignation(existingResource.getDesignation());
resourceBench.setEmailId(existingResource.getEmailId());
resourceBench.setEmployeeId(existingResource.getEmployeeId());
resourceBench.setActive(true);
resourceBench.setEmployeeName(existingResource.getEmployeeName());
resourceBench.setProjectId("Nisum0000");
resourceBench.setStartDate(new Date());
Project p = projectRepo.findByProjectId("Nisum0000");
resourceBench.setProjectName(p.getProjectName());
// newBenchAllocation.setManagerId(p.getManagerId());
// newBenchAllocation.setManagerName(p.getManagerName());
resourceBench.setAuditFields(loginEmpId, MyTimeUtils.CREATE);// Setting
// audit
// fields
resourceRepo.save(resourceBench);
empShiftService.updateEmployeeShift(existingResource, loginEmpId);
}
// Update ProjectEndDate column data in ProjectTeamMate.
private void updateProjectEndDateForResource(Resource resource, String loginEmpId) {
List<Resource> projectTeamMateList = mongoTemplate
.find(prepareQuery(resource.getEmployeeId(), MyTimeUtils.ENDDATE_COLUMN), Resource.class);
log.info("the project teamates list is::" + projectTeamMateList);
if (!CollectionUtils.isEmpty(projectTeamMateList)) {
Resource teamMate = projectTeamMateList.get(0);
if (resource.getNewBillingStartDate() != null) {
Date d = resource.getNewBillingStartDate();
Calendar cal = Calendar.getInstance();
cal.setTime(d);
cal.add(Calendar.DAY_OF_MONTH, -1);
Date oneDayLess = cal.getTime();
Date startDate = teamMate.getNewBillingStartDate() != null ? teamMate.getNewBillingStartDate()
: teamMate.getStartDate();
if (startDate.getDate() == resource.getNewBillingStartDate().getDate()) {
teamMate.setEndDate(DateUtils.truncate(resource.getEndDate(), Calendar.DATE));
} else {
teamMate.setEndDate(DateUtils.truncate(oneDayLess, Calendar.DATE));
}
}
teamMate.setActive(false);
teamMate.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);// Setting
// audit
// fields
resourceRepo.save(teamMate);
}
}
private Query prepareQuery(String employeeId, String dateColumn) {
Query query = new Query();
query.addCriteria(Criteria.where(MyTimeUtils.EMPLOYEE_ID).is(employeeId));
query.limit(MyTimeUtils.ONE);
query.with(new Sort(Sort.Direction.DESC, dateColumn));
return query;
}
private void addOrUpdateTeamMateRole(String role, String projectId, String empId, boolean isUpdate,
String loginEmpId) throws MyTimeException {
Project project = projectRepo.findByProjectId(projectId);
int operationType = 0; // 0 = No Operation, 1 = Added, 2 = Removed
if (role != null && role.equals("Lead")) {
if (project.getManagerIds() == null) {
project.setManagerIds(Arrays.asList(empId));
operationType = 1;
} else if (project.getManagerIds() != null && !project.getManagerIds().contains(empId)) {
project.getManagerIds().add(empId);
operationType = 1;
}
} else if (isUpdate && project.getManagerIds() != null && project.getManagerIds().contains(empId)) {
project.getManagerIds().remove(empId);
operationType = 2;
}
if (operationType > 0) {
project.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
projectRepo.save(project);
Query query = new Query(Criteria.where("employeeId").is(empId).and("role").is("Lead"));
List<Resource> projectMates = mongoTemplate.find(query, Resource.class);
String roleId = roleInfoService.getRole(MyTimeUtils.LEAD);
if (operationType == 1) {
roleMappingService.addEmployeeRole(empId, roleId);
} else if (projectMates.size() == 0 || operationType == 2) {
roleMappingService.deleteRole(empId, roleId);
}
}
}
public void addResources(Employee employee, String loginEmpId) {
List<Resource> resourceList = resourceRepo.findByEmployeeId(employee.getEmployeeId());
if (resourceList != null && !resourceList.isEmpty()) {
......@@ -56,20 +482,132 @@ public class ResourceService implements IResourceService {
resource.setActive(false);
resource.setEndDate(employeeReq.getEndDate());
List<Billing> billingList = billingService.getEmployeeActiveBillingDetails(resource.getEmployeeId(),
List<Billing> billingList = billingService.getActiveBillings(resource.getEmployeeId(),
resource.getProjectId());
if (billingList != null && !billingList.isEmpty()) {
billingService.addBillingtoResource(billingList.get(0), employeeUpdated, loginEmpId);
}
resource.setAuditFields(loginEmpId, MyTimeUtils.UPDATE);
resourceRepo.save(resource);
empShiftService.updateShiftDetails(resource, loginEmpId);
empShiftService.updateEmployeeShift(resource, loginEmpId);
}
}
}
public List<Resource> getResources(String empId) {
@Override
public List<Resource> findByAccountAndActiveAndBillableStatus(String account, boolean status,
String billableStatus) {
return resourceRepo.findByAccountAndActiveAndBillableStatus(account, status, billableStatus);
}
@Override
public List<Resource> getResourcesSortByStartDate(String employeeId) {
Query query = prepareQuery(employeeId, MyTimeUtils.START_DATE);
return mongoTemplate.find(query, Resource.class);
}
@Override
public List<Resource> getResourcesForProject(String projectId, String statusFlag) {
List<Resource> resourcesList = new ArrayList<>();
List<Resource> resourceListPersisted = resourceRepo.findByProjectId(projectId);
for (Resource resource : resourceListPersisted) {
Date endDate = resource.getEndDate();
if (endDate != null) {
// Active
if (statusFlag.equals(MyTimeUtils.ACTIVE) && endDate.compareTo(new Date()) >= 0)
resourcesList.add(resource);
else if (statusFlag.equals(MyTimeUtils.IN_ACTIVE) && endDate.compareTo(new Date()) < 0)
resourcesList.add(resource);
else if (statusFlag.equals(MyTimeUtils.BOTH))
resourcesList.add(resource);
}
}
return resourcesList;
}
@Override
public List<Resource> getResourcesForEmployee(String empId) {
return resourceRepo.findByEmployeeId(empId);
}
public List<Resource> getResourcesForProject(String projectId) {
return resourceRepo.findByProjectId(projectId);
}
public List<Resource> getAllResources() {
return resourceRepo.findAll();
}
@Override
public List<Resource> getActiveResources(String empId) {
List<Resource> resourcesList = new ArrayList<>();
List<Resource> resourcesListPers = resourceRepo.findByEmployeeId(empId);
for (Resource resource : resourcesListPers) {
if (resource.isActive()) {
resourcesList.addAll(resourceRepo.findByProjectId(resource.getProjectId()));
}
}
return resourcesList;
}
@Override
public List<Resource> getResourcesForActiveProjects() {
List<Project> projects = projectService.getAllProjects();
List<Resource> resourceList = new ArrayList<>();
for (Project project : projects) {
if (!"Completed".equalsIgnoreCase(project.getStatus())) {
List<Resource> resourceListPersisted = getResourcesForProject(project.getProjectId());
resourceList.addAll(resourceListPersisted);
}
}
return resourceList;
}
@Override
public List<Resource> getResourcesForShift(String shift) {
List<Resource> resourcesListPers = null;
List<Resource> resourcesList = new ArrayList<>();
List<Project> projects = projectService.getAllProjects();
for (Project project : projects) {
if ("Active".equalsIgnoreCase(project.getStatus())) {
resourcesListPers = getResourcesForProject(project.getProjectId());
for (Resource resource : resourcesListPers) {
if (resource.getShift() != null && resource.getShift().equalsIgnoreCase(shift)
&& resource.isActive()) {
resourcesList.add(resource);
} else if (resource.getShift() == null && "Shift 1(9:00 AM - 6:00 PM)".equalsIgnoreCase(shift)
&& resource.isActive())
resourcesList.add(resource);
}
}
}
return resourcesList;
}
@Override
public List<Resource> getResourcesUnderDeliveryLead(String deliveryLeadId) {
List<String> projectIdsList = new ArrayList<>();
List<Resource> resourcesList = new ArrayList<>();
List<Project> projectsList = projectRepo.findByDeliveryLeadIds(deliveryLeadId);
for (Project project : projectsList)
projectIdsList.add(project.getProjectId());
Query query = new Query(Criteria.where("projectId").in(projectIdsList));
List<Resource> resourcesListPersisted = mongoTemplate.find(query, Resource.class);
for (Resource resource : resourcesListPersisted) {
if (!resource.getEmployeeId().equals(deliveryLeadId))
resourcesList.add(resource);
}
return resourcesList;
}
}
src/main/java/com/nisum/mytime/service/impl/ShiftService.java
View file @ c63bc59d
......@@ -25,4 +25,8 @@ public class ShiftService implements IShiftService {
log.info("The shift list details::" + shiftsList);
return shiftsList;
}
}
src/main/resources/application.properties
View file @ c63bc59d
server.port=8080
server.context-path=/myTeam/
#Mongo DB configuration
spring.data.mongodb.host=10.3.45.11
spring.data.mongodb.port=27017
spring.data.mongodb.database=mytimedb
spring.data.mongodb.username=mytime
spring.data.mongodb.password=nisum@123
#Local configuration
#spring.data.mongodb.host=localhost
#spring.data.mongodb.port=27017
#spring.data.mongodb.database=mytime
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=mytime
quartz.enabled=true
cron.expression=0 45 10/3 1/1 * ? *
......@@ -38,9 +31,7 @@ spring.mail.properties.mail.smtp.starttls.required=true
spring.mvc.favicon.enabled = false
#MS SQL configuration
myTime.data.mssqldb.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
#myTime.data.mssqldb.url=jdbc:sqlserver://10.3.45.105:1433;databaseName=smartiSCC
myTime.data.mssqldb.url=jdbc:sqlserver://10.3.45.218:1433;databaseName=smartiSCC
myTime.data.mssqldb.username=sa
#myTime.data.mssqldb.password=nisum@123
myTime.data.mssqldb.password=admin@123
\ No newline at end of file
myTime.data.mssqldb.driver=
myTime.data.mssqldb.url=
myTime.data.mssqldb.username=
myTime.data.mssqldb.password=
\ No newline at end of file
src/main/webapp/WEB-INF/templates/index.html
View file @ c63bc59d
......@@ -53,7 +53,7 @@
<script src="js/app.js"></script>
<script src="js/date-text-filter.js"></script>
<script src="js/ui-grid-edit-datepicker.js"></script>
<script src="controllers/assignAccountsController.js"></script>
<script src="controllers/AccountsController.js"></script>
<script src="controllers/LoginController.js"></script>
<script src="controllers/HeaderController.js"></script>
<script src="controllers/LeftMenuController.js"></script>
......@@ -63,7 +63,7 @@
<script src="controllers/ReportsController.js"></script>
<script src="controllers/AssignRolesController.js"></script>
<script src="controllers/ProjectController.js"></script>
<script src="controllers/ProjectTeamController.js"></script>
<script src="controllers/ResourceController.js"></script>
<script src="controllers/ProjectMyTeamController.js"></script>
<script src="controllers/AttendanceReportController.js"></script>
<script src="controllers/ShiftDetailsController.js"></script>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment