Skip to content

M
mytime
Commit 099feaf1 authored by vikram singh's avatar vikram singh
Browse files
Options

"UIReport Service implemented"

parent 6574f8fd
Hide whitespace changes
Inline Side-by-side
Showing with 1906 additions and 1803 deletions
src/main/java/com/nisum/myteam/controller/ReportsController.java
View file @ 099feaf1
package com.nisum.myteam.controller;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.exception.handler.ResponseDetails;
import com.nisum.myteam.model.ColumnChartData;
import com.nisum.myteam.model.GroupByCount;
import com.nisum.myteam.model.ReportSeriesRecord;
import com.nisum.myteam.model.dao.Account;
import com.nisum.myteam.model.dao.Employee;
import com.nisum.myteam.model.dao.Resource;
import com.nisum.myteam.model.vo.ReportVo;
import com.nisum.myteam.model.vo.ResourceVO;
import com.nisum.myteam.service.IAccountService;
import com.nisum.myteam.service.IEmployeeService;
import com.nisum.myteam.service.IResourceService;
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.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.MatchOperation;
import org.springframework.data.mongodb.core.aggregation.ProjectionOperation;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;
//import com.nisum.myteam.model.dao.Resource;
@RestController
@RequestMapping("/reports")
public class ReportsController {
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private IEmployeeService employeeService;
@Autowired
private IResourceService resourceService;
@Autowired
private IAccountService accountService;
//Ok Response
@RequestMapping(value = "/getEmployeesByFunctionalGroup1",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<GroupByCount>> getEmployeesByFunctionalGroup()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("functionalGroup").as("name").andExpression("y")
.as("y");
Aggregation agg = newAggregation(
// match(Criteria.where("employeeId").gt(10)),
group("functionalGroup").count().as("y"),
project("y").and("functionalGroup").previousOperation(),
projectToMatchModel,
sort(Sort.Direction.DESC, "y")
);
// Convert the aggregation result into a List
AggregationResults<GroupByCount> groupResults = mongoTemplate
.aggregate(agg, Employee.class, GroupByCount.class);
List<GroupByCount> result = groupResults.getMappedResults();
return new ResponseEntity<>(result, HttpStatus.OK);
}
//Ok Response
@RequestMapping(value = "/getEmployeesByFunctionalGroupForReport",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<ColumnChartData> getEmployeesByFunctionalGroupForReport()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("functionalGroup").as("name").andExpression("y")
.as("y");
MatchOperation matchStage = Aggregation
.match(new Criteria("empStatus").is("Active"));
Aggregation agg = newAggregation(
// match(Criteria.where("employeeId").gt(10)),
matchStage, group("functionalGroup").count().as("y"),
project("y").and("functionalGroup").previousOperation(),
projectToMatchModel,
sort(Sort.Direction.DESC, "y")
);
// Convert the aggregation result into a List
AggregationResults<GroupByCount> groupResults = mongoTemplate
.aggregate(agg, Employee.class, GroupByCount.class);
List<GroupByCount> result = groupResults.getMappedResults();
ColumnChartData reportData = new ColumnChartData();
reportData.setCategories("data");
reportData.setSeriesDataList(result);
return new ResponseEntity<>(reportData, HttpStatus.OK);
}
//ok response
@RequestMapping(value = "/getBillabilityDetailsByMonth",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<ColumnChartData> getBillabilityDetailsByMonth()
throws MyTeamException {
Date reportDate = new Date();
Map m = new HashMap();
ReportSeriesRecord reportSeriesRecordBillable = new ReportSeriesRecord();
reportSeriesRecordBillable.setName("Billable");
reportSeriesRecordBillable.setData(new long[12]);
m.put("Billable", reportSeriesRecordBillable);
ReportSeriesRecord reportSeriesRecordShadow = new ReportSeriesRecord();
reportSeriesRecordShadow.setName("Shadow");
reportSeriesRecordShadow.setData(new long[12]);
m.put("Shadow", reportSeriesRecordShadow);
ReportSeriesRecord reportSeriesRecordReserved = new ReportSeriesRecord();
reportSeriesRecordReserved.setName("Reserved");
reportSeriesRecordReserved.setData(new long[12]);
m.put("Reserved", reportSeriesRecordReserved);
ReportSeriesRecord reportSeriesRecordNBillable = new ReportSeriesRecord();
reportSeriesRecordNBillable.setName("Non-Billable");
reportSeriesRecordNBillable.setData(new long[12]);
m.put("Non-Billable", reportSeriesRecordNBillable);
List<String> catagories = new ArrayList();
for (int i = 0; i < 12; i++) {
reportDate = new Date();
reportDate.setDate(1);
reportDate.setMonth(i);
Calendar calendar = Calendar.getInstance();
calendar.setTime(reportDate);
int lastDate = calendar.getActualMaximum(Calendar.DATE);
reportDate.setDate(lastDate);
String pattern = "MM-dd-yyyy";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
String date = simpleDateFormat.format(reportDate);
catagories.add(date);
Criteria criteriaV1 = Criteria.where("billingStartDate")
.lt(reportDate);
Criteria criteriaV21 = Criteria.where("billingEndDate").is(null);
Criteria criteriaV22 = Criteria.where("billingEndDate")
.gt(reportDate);
Criteria criteriaV221 = criteriaV1.orOperator(criteriaV21,
criteriaV22);
/*
* MatchOperation matchStage = Aggregation.match(new Criteria()
* .andOperator(criteriaV1).andOperator(criteriaV221));
*/
MatchOperation matchStage = Aggregation.match(criteriaV221);
Aggregation agg1 = newAggregation(matchStage,
group("billableStatus").count().as("count"),
project("count").and("billableStatus").previousOperation());
// Convert the aggregation result into a List
AggregationResults<ColumnChartData> groupResults1 = mongoTemplate
.aggregate(agg1, Resource.class,
ColumnChartData.class);
List<ColumnChartData> result1 = groupResults1.getMappedResults();
List<String> statusList = new ArrayList();
statusList.add("Billable");
statusList.add("Shadow");
statusList.add("Reserved");
statusList.add("Non-Billable");
for (String status : statusList) {
for (ColumnChartData columnChartData : result1) {
if (columnChartData.getBillableStatus() != null
&& columnChartData.getBillableStatus()
.equalsIgnoreCase(status)) {
ReportSeriesRecord record = (ReportSeriesRecord) m
.get(status);
record.getData()[i] = columnChartData.getCount();
}
}
}
}
ColumnChartData reportData = new ColumnChartData();
System.out.println("catagories" + catagories);
System.out.println("m.values()" + m.values());
reportData.setCategoriesList(catagories);
reportData.setSeriesDataList(new ArrayList<String>(m.values()));
return new ResponseEntity<>(reportData, HttpStatus.OK);
}
//ok response
@RequestMapping(value = "/getEmployeesByFunctionalGroup",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Map<String, List<GroupByCount>>>> getEmployeesByFunctionalGroup1()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("functionalGroup").as("name").andExpression("y")
.as("y");
MatchOperation matchStage = Aggregation
.match(new Criteria("empStatus").is("Active"));
Aggregation agg = newAggregation(
// match(Criteria.where("employeeId").gt(10)),
matchStage, group("functionalGroup").count().as("y"),
project("y").and("functionalGroup").previousOperation(),
projectToMatchModel,
sort(Sort.Direction.DESC, "y")
);
// Convert the aggregation result into a List
AggregationResults<GroupByCount> groupResults = mongoTemplate
.aggregate(agg, Employee.class, GroupByCount.class);
List<GroupByCount> result = groupResults.getMappedResults();
Map<String, List<GroupByCount>> map = new HashMap<String, List<GroupByCount>>();
map.put("data", result);
List<Map<String, List<GroupByCount>>> list = new ArrayList<Map<String, List<GroupByCount>>>();
list.add(map);
return new ResponseEntity<>(list, HttpStatus.OK);
}
@RequestMapping(value = "/fetchEmployeeDetailsByFG",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Employee>> getEmployeesByFG(
@RequestParam("fGroup") String fGroup) throws MyTeamException {
List<Employee> empList = new ArrayList<>();
empList = employeeService.getEmployeesByFunctionalGrp(fGroup);
return new ResponseEntity<>(empList, HttpStatus.OK);
}
@RequestMapping(value = "/fetchEmployeeDetailsByAccountBillability",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<ResourceVO>> fetchEmployeeDetailsByAccountBillability(
@RequestParam("account") String account,
@RequestParam("billabilityStatus") String billabilityStatus)
throws MyTeamException {
List<ResourceVO> resourcesList = new ArrayList<>();
if (account != null && !account.isEmpty()) {
resourcesList = resourceService.getAllResourcesVO();
}
return new ResponseEntity<>(resourcesList, HttpStatus.OK);
}
@RequestMapping(value = "/fetchEmployeeDetailsByDateBillability",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> fetchEmployeeDetailsByDateBillability(
@RequestParam("billabilityStatus") String billabilityStatus,
@RequestParam("reportDate") String reportDateString)
throws MyTeamException {
List<Resource> empList = new ArrayList<>();
if (reportDateString != null && !reportDateString.isEmpty()) {
String pattern = "MM-dd-yyyy";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
Date reportDateValue = new Date();
try {
reportDateValue = simpleDateFormat.parse(reportDateString);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Criteria status = Criteria.where("billableStatus")
.is(billabilityStatus);
Criteria criteriaV1 = Criteria.where("billingStartDate")
.lt(reportDateValue);
Criteria criteriaV21 = Criteria.where("billingEndDate").is(null);
Criteria criteriaV22 = Criteria.where("billingEndDate")
.gt(reportDateValue);
Criteria criteriaV221 = status.andOperator(
criteriaV1.orOperator(criteriaV21, criteriaV22));
Query query = new Query();
query.addCriteria(criteriaV221);
empList = mongoTemplate.find(query, Resource.class);
}
return new ResponseEntity<>(empList, HttpStatus.OK);
}
@RequestMapping(value = "/billabilityByFunctionalGroup",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ReportVo billabilityReportByFunctionalGroup(){
ReportVo reportVo = new ReportVo();
Map<String,Object> billableData = new HashMap();
Map<String,Object> nonBillableData = new HashMap();
List<Object> billableCount = new ArrayList<>();
List<Object> nonBillableCount = new ArrayList<>();
billableData.put("name","Billable");
nonBillableData.put("name","Non Billable");
for(String functionalGroup:reportVo.getCategoriesList()){
Map<String,Object> billableObj = new HashMap();
Map<String,Object> nonbillableObj = new HashMap();
Integer billableC=0;
Integer nonBillableC=0;
float billper;
float nonBillPer;
List<Employee> employeeList = employeeService.getAllEmployees().stream().
filter(e -> e.getFunctionalGroup().equals(functionalGroup)).collect(Collectors.toList());
for(Employee employee:employeeList){
Resource resource = resourceService.getLatestResourceByEmpId(employee.getEmployeeId());
if(resource!=null && resource.getBillableStatus().equals("Billable")){
billableC++;
}else{
nonBillableC++;
}
}
billper = ((billableC / (float)employeeList.size())*100);
nonBillPer = nonBillableC /(float) employeeList.size()*100;
billableObj.put("percent", billper);
billableObj.put("y", billableC);
nonbillableObj.put("percent", nonBillPer);
nonbillableObj.put("y", nonBillableC);
billableCount.add(billableObj);
nonBillableCount.add(nonbillableObj);
}
billableData.put("data",billableCount);
nonBillableData.put("data",nonBillableCount);
reportVo.getSeriesDataList().add(billableData);
reportVo.getSeriesDataList().add(nonBillableData);
return reportVo;
}
//Not Ok Response
@RequestMapping(value = "/getBillabilityDetailsByAccount",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<ColumnChartData> getBillabilityDetailsByAccount()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("account").as("categories")
.andExpression("billableStatus").as("seriesName")
.andExpression("count").as("count");
MatchOperation matchStage = Aggregation
.match(new Criteria("active").is(true));
Aggregation aggregate = Aggregation.newAggregation(matchStage,
Aggregation.group("account", "billableStatus").count()
.as("count"),
projectToMatchModel);
// Convert the aggregation result into a List
AggregationResults<ColumnChartData> groupResults = mongoTemplate.aggregate(aggregate, Resource.class,
ColumnChartData.class);
List<ColumnChartData> result = groupResults.getMappedResults();
List<String> statusList = new ArrayList();
statusList.add("Billable");
statusList.add("Shadow");
statusList.add("Reserved");
statusList.add("Non-Billable");
List<String> catagories = new ArrayList();
List<ReportSeriesRecord> seriesDetails = new ArrayList<ReportSeriesRecord>();
//List<Account> accounts = employeeService.getAccounts();
List<Account> accounts = accountService.getAllAccounts();
ColumnChartData reportData = new ColumnChartData();
for (String status : statusList) {
catagories = new ArrayList();
long seriesData[] = new long[accounts.size()];
int i = 0;
for (Account acct : accounts) {
boolean seriesDataExists = false;
catagories.add(acct.getAccountName());
for (ColumnChartData columnChartData : result) {
if (columnChartData.getCategories() != null
&& columnChartData.getSeriesName() != null
& columnChartData.getCategories()
.equalsIgnoreCase(
acct.getAccountName())
&& columnChartData.getSeriesName()
.equalsIgnoreCase(status)) {
seriesDataExists = true;
seriesData[i] = columnChartData.getCount();
}
}
if (!seriesDataExists) {
// seriesData[i] = 0;
}
i++;
}
ReportSeriesRecord reportSeriesRecord = new ReportSeriesRecord();
reportSeriesRecord.setName(status);
reportSeriesRecord.setData(seriesData);
seriesDetails.add(reportSeriesRecord);
}
System.out.println(seriesDetails);
reportData.setCategoriesList(catagories);
reportData.setSeriesDataList(seriesDetails);
return new ResponseEntity<>(reportData, HttpStatus.OK);
}
}
package com.nisum.myteam.controller;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.group;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.newAggregation;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.project;
import static org.springframework.data.mongodb.core.aggregation.Aggregation.sort;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.MatchOperation;
import org.springframework.data.mongodb.core.aggregation.ProjectionOperation;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
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.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.BillableEmployee;
import com.nisum.myteam.model.ColumnChartData;
import com.nisum.myteam.model.GroupByCount;
import com.nisum.myteam.model.ReportSeriesRecord;
import com.nisum.myteam.model.dao.Account;
import com.nisum.myteam.model.dao.Employee;
import com.nisum.myteam.model.dao.Resource;
import com.nisum.myteam.model.vo.ReportVo;
import com.nisum.myteam.model.vo.ResourceVO;
import com.nisum.myteam.service.IAccountService;
import com.nisum.myteam.service.IEmployeeService;
import com.nisum.myteam.service.IResourceService;
//import com.nisum.myteam.model.dao.Resource;
@RestController
@RequestMapping("/reports")
public class ReportsController {
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private IEmployeeService employeeService;
@Autowired
private IResourceService resourceService;
@Autowired
private IAccountService accountService;
//Ok Response
@RequestMapping(value = "/getEmployeesByFunctionalGroup1",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<GroupByCount>> getEmployeesByFunctionalGroup()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("functionalGroup").as("name").andExpression("y")
.as("y");
Aggregation agg = newAggregation(
// match(Criteria.where("employeeId").gt(10)),
group("functionalGroup").count().as("y"),
project("y").and("functionalGroup").previousOperation(),
projectToMatchModel,
sort(Sort.Direction.DESC, "y")
);
// Convert the aggregation result into a List
AggregationResults<GroupByCount> groupResults = mongoTemplate
.aggregate(agg, Employee.class, GroupByCount.class);
List<GroupByCount> result = groupResults.getMappedResults();
return new ResponseEntity<>(result, HttpStatus.OK);
}
//Ok Response
@RequestMapping(value = "/getEmployeesByFunctionalGroupForReport",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<ColumnChartData> getEmployeesByFunctionalGroupForReport()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("functionalGroup").as("name").andExpression("y")
.as("y");
MatchOperation matchStage = Aggregation
.match(new Criteria("empStatus").is("Active"));
Aggregation agg = newAggregation(
// match(Criteria.where("employeeId").gt(10)),
matchStage, group("functionalGroup").count().as("y"),
project("y").and("functionalGroup").previousOperation(),
projectToMatchModel,
sort(Sort.Direction.DESC, "y")
);
// Convert the aggregation result into a List
AggregationResults<GroupByCount> groupResults = mongoTemplate
.aggregate(agg, Employee.class, GroupByCount.class);
List<GroupByCount> result = groupResults.getMappedResults();
ColumnChartData reportData = new ColumnChartData();
reportData.setCategories("data");
reportData.setSeriesDataList(result);
return new ResponseEntity<>(reportData, HttpStatus.OK);
}
//ok response
@RequestMapping(value = "/getBillabilityDetailsByMonth",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<ColumnChartData> getBillabilityDetailsByMonth()
throws MyTeamException {
Date reportDate = new Date();
Map m = new HashMap();
ReportSeriesRecord reportSeriesRecordBillable = new ReportSeriesRecord();
reportSeriesRecordBillable.setName("Billable");
reportSeriesRecordBillable.setData(new long[12]);
m.put("Billable", reportSeriesRecordBillable);
ReportSeriesRecord reportSeriesRecordShadow = new ReportSeriesRecord();
reportSeriesRecordShadow.setName("Shadow");
reportSeriesRecordShadow.setData(new long[12]);
m.put("Shadow", reportSeriesRecordShadow);
ReportSeriesRecord reportSeriesRecordReserved = new ReportSeriesRecord();
reportSeriesRecordReserved.setName("Reserved");
reportSeriesRecordReserved.setData(new long[12]);
m.put("Reserved", reportSeriesRecordReserved);
ReportSeriesRecord reportSeriesRecordNBillable = new ReportSeriesRecord();
reportSeriesRecordNBillable.setName("Non-Billable");
reportSeriesRecordNBillable.setData(new long[12]);
m.put("Non-Billable", reportSeriesRecordNBillable);
List<String> catagories = new ArrayList();
for (int i = 0; i < 12; i++) {
reportDate = new Date();
reportDate.setDate(1);
reportDate.setMonth(i);
Calendar calendar = Calendar.getInstance();
calendar.setTime(reportDate);
int lastDate = calendar.getActualMaximum(Calendar.DATE);
reportDate.setDate(lastDate);
String pattern = "MM-dd-yyyy";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
String date = simpleDateFormat.format(reportDate);
catagories.add(date);
Criteria criteriaV1 = Criteria.where("billingStartDate")
.lt(reportDate);
Criteria criteriaV21 = Criteria.where("billingEndDate").is(null);
Criteria criteriaV22 = Criteria.where("billingEndDate")
.gt(reportDate);
Criteria criteriaV221 = criteriaV1.orOperator(criteriaV21,
criteriaV22);
/*
* MatchOperation matchStage = Aggregation.match(new Criteria()
* .andOperator(criteriaV1).andOperator(criteriaV221));
*/
MatchOperation matchStage = Aggregation.match(criteriaV221);
Aggregation agg1 = newAggregation(matchStage,
group("billableStatus").count().as("count"),
project("count").and("billableStatus").previousOperation());
// Convert the aggregation result into a List
AggregationResults<ColumnChartData> groupResults1 = mongoTemplate
.aggregate(agg1, Resource.class,
ColumnChartData.class);
List<ColumnChartData> result1 = groupResults1.getMappedResults();
List<String> statusList = new ArrayList();
statusList.add("Billable");
statusList.add("Shadow");
statusList.add("Reserved");
statusList.add("Non-Billable");
for (String status : statusList) {
for (ColumnChartData columnChartData : result1) {
if (columnChartData.getBillableStatus() != null
&& columnChartData.getBillableStatus()
.equalsIgnoreCase(status)) {
ReportSeriesRecord record = (ReportSeriesRecord) m
.get(status);
record.getData()[i] = columnChartData.getCount();
}
}
}
}
ColumnChartData reportData = new ColumnChartData();
System.out.println("catagories" + catagories);
System.out.println("m.values()" + m.values());
reportData.setCategoriesList(catagories);
reportData.setSeriesDataList(new ArrayList<String>(m.values()));
return new ResponseEntity<>(reportData, HttpStatus.OK);
}
//ok response
@RequestMapping(value = "/getEmployeesByFunctionalGroup",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Map<String, List<GroupByCount>>>> getEmployeesByFunctionalGroup1()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("functionalGroup").as("name").andExpression("y")
.as("y");
MatchOperation matchStage = Aggregation
.match(new Criteria("empStatus").is("Active"));
Aggregation agg = newAggregation(
// match(Criteria.where("employeeId").gt(10)),
matchStage, group("functionalGroup").count().as("y"),
project("y").and("functionalGroup").previousOperation(),
projectToMatchModel,
sort(Sort.Direction.DESC, "y")
);
// Convert the aggregation result into a List
AggregationResults<GroupByCount> groupResults = mongoTemplate
.aggregate(agg, Employee.class, GroupByCount.class);
List<GroupByCount> result = groupResults.getMappedResults();
Map<String, List<GroupByCount>> map = new HashMap<String, List<GroupByCount>>();
map.put("data", result);
List<Map<String, List<GroupByCount>>> list = new ArrayList<Map<String, List<GroupByCount>>>();
list.add(map);
return new ResponseEntity<>(list, HttpStatus.OK);
}
@RequestMapping(value = "/fetchEmployeeDetailsByFGAndBillability",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<BillableEmployee>> getEmployeesByFGAndBillability(
@RequestParam("fGroup") String fGroup , @RequestParam("billableStatus") String billableStatus) throws MyTeamException {
List<BillableEmployee> empList = new ArrayList<>();
empList = employeeService.getEmployeeDetailsByFGAndBillability(fGroup,billableStatus);
return new ResponseEntity<>(empList, HttpStatus.OK);
}
@RequestMapping(value = "/fetchEmployeeDetailsByAccountBillability",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<ResourceVO>> fetchEmployeeDetailsByAccountBillability(
@RequestParam("account") String account,
@RequestParam("billabilityStatus") String billabilityStatus)
throws MyTeamException {
List<ResourceVO> resourcesList = new ArrayList<>();
if (account != null && !account.isEmpty()) {
resourcesList = resourceService.getAllResourcesVO();
}
return new ResponseEntity<>(resourcesList, HttpStatus.OK);
}
@RequestMapping(value = "/fetchEmployeeDetailsByDateBillability",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<List<Resource>> fetchEmployeeDetailsByDateBillability(
@RequestParam("billabilityStatus") String billabilityStatus,
@RequestParam("reportDate") String reportDateString)
throws MyTeamException {
List<Resource> empList = new ArrayList<>();
if (reportDateString != null && !reportDateString.isEmpty()) {
String pattern = "MM-dd-yyyy";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
Date reportDateValue = new Date();
try {
reportDateValue = simpleDateFormat.parse(reportDateString);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Criteria status = Criteria.where("billableStatus")
.is(billabilityStatus);
Criteria criteriaV1 = Criteria.where("billingStartDate")
.lt(reportDateValue);
Criteria criteriaV21 = Criteria.where("billingEndDate").is(null);
Criteria criteriaV22 = Criteria.where("billingEndDate")
.gt(reportDateValue);
Criteria criteriaV221 = status.andOperator(
criteriaV1.orOperator(criteriaV21, criteriaV22));
Query query = new Query();
query.addCriteria(criteriaV221);
empList = mongoTemplate.find(query, Resource.class);
}
return new ResponseEntity<>(empList, HttpStatus.OK);
}
@RequestMapping(value = "/billabilityByFunctionalGroup",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ReportVo billabilityReportByFunctionalGroup(){
ReportVo reportVo = new ReportVo();
Map<String,Object> billableData = new HashMap();
Map<String,Object> nonBillableData = new HashMap();
List<Object> billableCount = new ArrayList<>();
List<Object> nonBillableCount = new ArrayList<>();
billableData.put("name","Billable");
nonBillableData.put("name","Non Billable");
for(String functionalGroup:reportVo.getCategoriesList()){
Map<String,Object> billableObj = new HashMap();
Map<String,Object> nonbillableObj = new HashMap();
Integer billableC=0;
Integer nonBillableC=0;
float billper;
float nonBillPer;
List<Employee> employeeList = employeeService.getAllEmployees().stream().
filter(e -> e.getFunctionalGroup().equals(functionalGroup)).collect(Collectors.toList());
for(Employee employee:employeeList){
Resource resource = resourceService.getLatestResourceByEmpId(employee.getEmployeeId());
if(resource!=null && resource.getBillableStatus().equals("Billable")){
billableC++;
}else{
nonBillableC++;
}
}
billper = ((billableC / (float)employeeList.size())*100);
nonBillPer = nonBillableC /(float) employeeList.size()*100;
billableObj.put("percent", billper);
billableObj.put("y", billableC);
nonbillableObj.put("percent", nonBillPer);
nonbillableObj.put("y", nonBillableC);
billableCount.add(billableObj);
nonBillableCount.add(nonbillableObj);
}
billableData.put("data",billableCount);
nonBillableData.put("data",nonBillableCount);
reportVo.getSeriesDataList().add(billableData);
reportVo.getSeriesDataList().add(nonBillableData);
return reportVo;
}
//Not Ok Response
@RequestMapping(value = "/getBillabilityDetailsByAccount",
method = RequestMethod.GET,
produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<ColumnChartData> getBillabilityDetailsByAccount()
throws MyTeamException {
ProjectionOperation projectToMatchModel = project()
.andExpression("account").as("categories")
.andExpression("billableStatus").as("seriesName")
.andExpression("count").as("count");
MatchOperation matchStage = Aggregation
.match(new Criteria("active").is(true));
Aggregation aggregate = Aggregation.newAggregation(matchStage,
Aggregation.group("account", "billableStatus").count()
.as("count"),
projectToMatchModel);
// Convert the aggregation result into a List
AggregationResults<ColumnChartData> groupResults = mongoTemplate.aggregate(aggregate, Resource.class,
ColumnChartData.class);
List<ColumnChartData> result = groupResults.getMappedResults();
List<String> statusList = new ArrayList();
statusList.add("Billable");
statusList.add("Shadow");
statusList.add("Reserved");
statusList.add("Non-Billable");
List<String> catagories = new ArrayList();
List<ReportSeriesRecord> seriesDetails = new ArrayList<ReportSeriesRecord>();
//List<Account> accounts = employeeService.getAccounts();
List<Account> accounts = accountService.getAllAccounts();
ColumnChartData reportData = new ColumnChartData();
for (String status : statusList) {
catagories = new ArrayList();
long seriesData[] = new long[accounts.size()];
int i = 0;
for (Account acct : accounts) {
boolean seriesDataExists = false;
catagories.add(acct.getAccountName());
for (ColumnChartData columnChartData : result) {
if (columnChartData.getCategories() != null
&& columnChartData.getSeriesName() != null
& columnChartData.getCategories()
.equalsIgnoreCase(
acct.getAccountName())
&& columnChartData.getSeriesName()
.equalsIgnoreCase(status)) {
seriesDataExists = true;
seriesData[i] = columnChartData.getCount();
}
}
if (!seriesDataExists) {
// seriesData[i] = 0;
}
i++;
}
ReportSeriesRecord reportSeriesRecord = new ReportSeriesRecord();
reportSeriesRecord.setName(status);
reportSeriesRecord.setData(seriesData);
seriesDetails.add(reportSeriesRecord);
}
System.out.println(seriesDetails);
reportData.setCategoriesList(catagories);
reportData.setSeriesDataList(seriesDetails);
return new ResponseEntity<>(reportData, HttpStatus.OK);
}
}
src/main/java/com/nisum/myteam/model/BillableEmployee.java 0 → 100644
View file @ 099feaf1
package com.nisum.myteam.model;
import java.io.Serializable;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class BillableEmployee implements Serializable {
private static final long serialVersionUID = 1L;
private String employeeId;
private String employeeName;
private String emailId;
private String projectName;
private String billableStatus;
private Date billingStartDate;
private Date billingEndDate;
private String functionalGroup;
}
src/main/java/com/nisum/myteam/service/IEmployeeService.java
View file @ 099feaf1
package com.nisum.myteam.service;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.dao.Account;
import com.nisum.myteam.model.dao.Employee;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
@Service
public interface IEmployeeService {
boolean isEmployeeExistsById(String employeeId);
Employee createEmployee(Employee employeeRoles, String empId) throws MyTeamException;
Employee updateEmployee(Employee employeeRoles, String empId);
Employee deleteEmployee(String empId);
Employee updateProfile(Employee employeeRoles) throws MyTeamException;
Employee getEmployeeById(String empId);
Employee getEmployeeByEmaillId(String emailId);
List<Employee> getManagers() throws MyTeamException;
List<Employee> getActiveEmployees() throws MyTeamException;
List<Employee> getEmployeesByStatus(String status);
List<Account> getAccounts() throws MyTeamException;
Employee getEmployeeRoleDataForSearchCriteria(String searchId, String searchAttribute);
List<String> getEmployeeDetailsForAutocomplete();
List<HashMap<String, String>> getDeliveryLeads(String domainId);
List<Employee> getEmployeesByFunctionalGrp(String functionalGrp);
boolean verifyEmployeeRole(String empId, String roleName);
List<Employee> getEmployeesFromList(Set<String> empIdsSet);
List<HashMap<String, String>> getDeliveryManagerMap(List deliveryManagerIdsList);
public List<Employee> getAllEmployees();
public List<Employee> getEmployeesByEmpStatusAndShift(String empStatus, String shift);
}
package com.nisum.myteam.service;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.BillableEmployee;
import com.nisum.myteam.model.dao.Account;
import com.nisum.myteam.model.dao.Employee;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
@Service
public interface IEmployeeService {
boolean isEmployeeExistsById(String employeeId);
Employee createEmployee(Employee employeeRoles, String empId) throws MyTeamException;
Employee updateEmployee(Employee employeeRoles, String empId);
Employee deleteEmployee(String empId);
Employee updateProfile(Employee employeeRoles) throws MyTeamException;
Employee getEmployeeById(String empId);
Employee getEmployeeByEmaillId(String emailId);
List<Employee> getManagers() throws MyTeamException;
List<Employee> getActiveEmployees() throws MyTeamException;
List<Employee> getEmployeesByStatus(String status);
List<Account> getAccounts() throws MyTeamException;
Employee getEmployeeRoleDataForSearchCriteria(String searchId, String searchAttribute);
List<String> getEmployeeDetailsForAutocomplete();
List<HashMap<String, String>> getDeliveryLeads(String domainId);
List<Employee> getEmployeesByFunctionalGrp(String functionalGrp);
boolean verifyEmployeeRole(String empId, String roleName);
List<Employee> getEmployeesFromList(Set<String> empIdsSet);
List<HashMap<String, String>> getDeliveryManagerMap(List deliveryManagerIdsList);
public List<Employee> getAllEmployees();
public List<Employee> getEmployeesByEmpStatusAndShift(String empStatus, String shift);
List<BillableEmployee> getEmployeeDetailsByFGAndBillability(String fGroup, String billableStatus);
}
src/main/java/com/nisum/myteam/service/IResourceService.java
View file @ 099feaf1
package com.nisum.myteam.service;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.dao.Employee;
import com.nisum.myteam.model.dao.Resource;
import com.nisum.myteam.model.vo.EmployeeShiftsVO;
import com.nisum.myteam.model.vo.MyProjectAllocationVO;
import com.nisum.myteam.model.vo.ReserveReportsVO;
import com.nisum.myteam.model.vo.ResourceVO;
import java.util.Date;
import java.util.List;
public interface IResourceService {
Resource addResource(Resource resourceAllocation, String loginEmpId) throws MyTeamException;
public void updateExistedResource(Resource resourceAlloc) throws MyTeamException;
public void insertNewResourceWithNewStatus(Resource resourceAllocReq, String loginEmpId) throws MyTeamException;
void deleteResource(Resource resource, String loginEmpId);
List<Resource> getAllResourcesForAllActiveProjects();
List<Resource> getResourcesSortByBillingStartDate(String employeeId);
List<ResourceVO> getActiveResources(String empId);
public List<ResourceVO> getResourcesForProject(String projectId, String statusFlag);
public List<Resource> getResourcesUnderDeliveryLead(String empId);
public List<ResourceVO> getBillingsForEmployee(String empId);
public List<Resource> getBillingsForProject(String empId, String projectId);
public List<MyProjectAllocationVO> getWorkedProjectsForResource(String empId);
public List<Employee> getUnAssignedEmployees();
public List<Resource> getAllResources();
public List<ResourceVO> getAllResourcesVO();
public void deleteResourcesUnderProject(String projectId);
public Resource addResourceToBenchProject(Employee employee, String loginEmpId) throws MyTeamException;
public List<EmployeeShiftsVO> getResourcesForShift(String shift);
public Resource getLatestResourceByEmpId(String employeeId);
public List<Resource> getResourcesByBillingStatus(String resourceStatus);
public List<ReserveReportsVO> prepareReserveReports(List<Resource> resourcesList);
public List<ReserveReportsVO> getResourceReportsByBillingStatus(String resourceStatus);
// List<Resource> getAllResourcesForProject(String projectId, String status);
// List<Resource> getResourcesForEmployee(String empId);
// List<Resource> getAllResourcesForProject(String projectId);
// Resource save(Resource resource);
// void addResources(Employee employee, String loginEmpId);
// void inactivateResource(Employee employeeReq, Employee employeeUpdated, String loginEmpId);
}
package com.nisum.myteam.service;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.dao.Employee;
import com.nisum.myteam.model.dao.Resource;
import com.nisum.myteam.model.vo.EmployeeShiftsVO;
import com.nisum.myteam.model.vo.MyProjectAllocationVO;
import com.nisum.myteam.model.vo.ReserveReportsVO;
import com.nisum.myteam.model.vo.ResourceVO;
import java.util.Date;
import java.util.List;
public interface IResourceService {
Resource addResource(Resource resourceAllocation, String loginEmpId) throws MyTeamException;
public void updateExistedResource(Resource resourceAlloc) throws MyTeamException;
public void insertNewResourceWithNewStatus(Resource resourceAllocReq, String loginEmpId) throws MyTeamException;
void deleteResource(Resource resource, String loginEmpId);
List<Resource> getAllResourcesForAllActiveProjects();
List<Resource> getResourcesSortByBillingStartDate(String employeeId);
List<ResourceVO> getActiveResources(String empId);
public List<ResourceVO> getResourcesForProject(String projectId, String statusFlag);
public List<Resource> getResourcesUnderDeliveryLead(String empId);
public List<ResourceVO> getBillingsForEmployee(String empId);
public List<Resource> getBillingsForProject(String empId, String projectId);
public List<MyProjectAllocationVO> getWorkedProjectsForResource(String empId);
public List<Employee> getUnAssignedEmployees();
public List<Resource> getAllResources();
public List<ResourceVO> getAllResourcesVO();
public void deleteResourcesUnderProject(String projectId);
public Resource addResourceToBenchProject(Employee employee, String loginEmpId) throws MyTeamException;
public List<EmployeeShiftsVO> getResourcesForShift(String shift);
public Resource getLatestResourceByEmpId(String employeeId);
public List<Resource> getResourcesByBillingStatus(String resourceStatus);
public List<ReserveReportsVO> prepareReserveReports(List<Resource> resourcesList);
public List<ReserveReportsVO> getResourceReportsByBillingStatus(String resourceStatus);
List<Resource> findByBillableStatus(String billableStatus);
// List<Resource> getAllResourcesForProject(String projectId, String status);
// List<Resource> getResourcesForEmployee(String empId);
// List<Resource> getAllResourcesForProject(String projectId);
// Resource save(Resource resource);
// void addResources(Employee employee, String loginEmpId);
// void inactivateResource(Employee employeeReq, Employee employeeUpdated, String loginEmpId);
}
src/main/java/com/nisum/myteam/service/impl/EmployeeService.java
View file @ 099feaf1
package com.nisum.myteam.service.impl;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.dao.Account;
import com.nisum.myteam.model.dao.Domain;
import com.nisum.myteam.model.dao.Employee;
import com.nisum.myteam.repository.EmployeeRepo;
import com.nisum.myteam.service.*;
import com.nisum.myteam.utils.MyTeamUtils;
import com.nisum.myteam.utils.constants.ApplicationRole;
import com.nisum.myteam.utils.constants.RoleConstant;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.FindAndModifyOptions;
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.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
@Service
@Slf4j
public class EmployeeService implements IEmployeeService {
@Autowired
private EmployeeRepo employeeRepo;
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private IAccountService accountService;
@Autowired
private IProjectService projectService;
@Autowired
private IDomainService domainService;
@Autowired
private IEmployeeRoleService employeeRoleService;
@Autowired
private IEmployeeLocationService empLocationService;
@Autowired
private IResourceService resourceService;
@Override
public Employee createEmployee(Employee employee, String loginEmpId) throws MyTeamException {
employee.setCreatedOn(new Date());
employee.setCreatedBy(loginEmpId);
employee.setModifiedBy(loginEmpId);
// adding employee to Bench Allocation
resourceService.addResourceToBenchProject(employee, loginEmpId);
// Saving employee Location Details.
empLocationService.save(employee);
return employeeRepo.save(employee);
}
@Override
public Employee updateEmployee(Employee employeeReq, String loginEmpId) {
// update all emp details to inactive if employee is inactive
Query query = new Query(Criteria.where("employeeId").is(employeeReq.getEmployeeId()));
Update update = new Update();
update.set("employeeName", employeeReq.getEmployeeName());
update.set("emailId", employeeReq.getEmailId());
update.set("role", employeeReq.getRole());
update.set("gender", employeeReq.getGender());
update.set("functionalGroup", employeeReq.getFunctionalGroup());
update.set("empStatus", employeeReq.getEmpStatus());
update.set("empSubStatus", employeeReq.getEmpSubStatus());
update.set("employmentType", employeeReq.getEmploymentType());
update.set("empLocation", employeeReq.getEmpLocation());
// update.set("domain", employeeReq.getDomain());
update.set("designation", employeeReq.getDesignation());
update.set("dateOfBirth", employeeReq.getDateOfBirth());
update.set("dateOfJoining", employeeReq.getDateOfJoining());
update.set("lastModifiedOn", new Date());
update.set("hasPassort", employeeReq.getHasPassort());
update.set("hasB1", employeeReq.getHasB1());
update.set("passportExpiryDate", employeeReq.getPassportExpiryDate());
update.set("b1ExpiryDate", employeeReq.getB1ExpiryDate());
update.set("modifiedBy", loginEmpId);
if (employeeReq.getEmpStatus().equalsIgnoreCase(MyTeamUtils.IN_ACTIVE_SPACE)) {
update.set("endDate", employeeReq.getEndDate());
update.set("empSubStatus", null);
}
// update employee location
if (employeeReq.getEmpLocation() != null && !employeeReq.getEmpLocation().equals("")) {
Employee existingEmployee = employeeRepo.findByEmployeeId(employeeReq.getEmployeeId());
if (!existingEmployee.getEmpLocation().equals(employeeReq.getEmpLocation())) {
empLocationService.update(employeeReq, false);
}
}
// update employee details
FindAndModifyOptions options = new FindAndModifyOptions();
options.returnNew(true);
options.upsert(true);
Employee employeeUpdated = mongoTemplate.findAndModify(query, update, options, Employee.class);
try {
// add to resource collection
//resourceService.addResources(employeeUpdated, loginEmpId);
// inactive the employee from the assigned project.
//resourceService.inactivateResource(employeeReq, employeeUpdated, loginEmpId);
} catch (Exception e) {
}
return employeeUpdated;
}
@Override
public Employee deleteEmployee(String employeeId) {
Query query = new Query();
query.addCriteria(Criteria.where("employeeId").is(employeeId));
Update update = new Update();
update.set("empStatus", "InActive");
Employee employeeUpdated = mongoTemplate.findAndModify(query, update, Employee.class);
log.info("The Deletion operation Result::" + employeeUpdated);
return employeeUpdated;
}
@Override
public Employee updateProfile(Employee employeeReq) throws MyTeamException {
boolean mobileNumberChanged = false;
employeeReq.setLastModifiedOn(new Date());
Employee existingEmployee = employeeRepo.findByEmployeeId(employeeReq.getEmployeeId());
String newMobileNumber = employeeReq.getMobileNumber();
if (newMobileNumber != null && !newMobileNumber.equalsIgnoreCase("")) {
if ((existingEmployee != null && existingEmployee.getMobileNumber() != null
&& !existingEmployee.getMobileNumber().equalsIgnoreCase(newMobileNumber))
|| (existingEmployee.getMobileNumber() == null)) {
mobileNumberChanged = true;
}
}
existingEmployee.setMobileNumber(employeeReq.getMobileNumber());
existingEmployee.setAlternateMobileNumber(employeeReq.getAlternateMobileNumber());
existingEmployee.setPersonalEmailId(employeeReq.getPersonalEmailId());
existingEmployee.setBaseTechnology(employeeReq.getBaseTechnology());
existingEmployee.setTechnologyKnown(employeeReq.getTechnologyKnown());
Employee employeePersisted = employeeRepo.save(existingEmployee);
return employeePersisted;
}
public boolean isEmployeeExistsById(String employeeId) {
Employee employeeFound = getEmployeeById(employeeId);
return (employeeFound == null) ? false : true;
}
@Override
public Employee getEmployeeById(String employeeId) {
log.info("The employeeId::" + employeeId);
Employee employee = employeeRepo.findByEmployeeId(employeeId);
log.info("Employee Found in Repo::" + employee);
return employee;
}
@Override
public List<Employee> getAllEmployees() {
return employeeRepo.findAll();
}
@Override
public Employee getEmployeeByEmaillId(String emailId) {
return employeeRepo.findByEmailId(emailId);
}
@Override
public List<Employee> getEmployeesByEmpStatusAndShift(String empStatus, String shift) {
return employeeRepo.findByEmpStatusAndShiftLikeOrderByEmployeeIdDesc(empStatus, shift);
}
public List<Employee> getManagers() throws MyTeamException {
List<Employee> activeEmpsList = getActiveEmployees();
List<Employee> managers = activeEmpsList.stream()
.filter(employee -> (RoleConstant.DIRECTOR.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.DELIVERY_MANAGER.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.MANAGER.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.HR_MANAGER.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.LEAD.getRoleName().equalsIgnoreCase(employee.getRole())))
.sorted(Comparator.comparing(Employee::getEmployeeName)).collect(Collectors.toList());
return managers;
}
@Override
public List<Employee> getActiveEmployees() throws MyTeamException {
return employeeRepo.findByEmpStatus(MyTeamUtils.ACTIVE);
}
@Override
public List<Employee> getEmployeesByStatus(String status) {
if (status.equals("all")) {
return employeeRepo.findAll(new Sort(Sort.Direction.ASC, "employeeName"));
} else if (status.equals("Vacation")) {
Query query = new Query();
query.addCriteria(Criteria.where("empSubStatus").ne("Resigned").andOperator(Criteria.where("empSubStatus").ne(null),Criteria.where("empSubStatus").ne("")));
return mongoTemplate.find(query, Employee.class);
} else if (status.equals("Resigned")) {
return employeeRepo.findByEmpSubStatusOrderByEmployeeNameAsc("Resigned");
} else {
return employeeRepo.findByEmpStatus(status);
}
}
@Override
public List<Account> getAccounts() throws MyTeamException {
return accountService.getAllAccounts();
}
@Override
public Employee getEmployeeRoleDataForSearchCriteria(String searchId, String searchAttribute) {
if (MyTeamUtils.EMPLOYEE_NAME.equals(searchAttribute)) {
return employeeRepo.findByEmployeeName(searchId);
} else if (MyTeamUtils.EMAIL_ID.equals(searchAttribute)) {
return employeeRepo.findByEmailId(searchId);
}
return null;
}
@Override
public List<String> getEmployeeDetailsForAutocomplete() {
List<Employee> employeeList = employeeRepo.findAll();
List<String> resultList = new ArrayList<>();
employeeList.stream().sorted(java.util.Comparator.comparing(Employee::getEmployeeId))
.collect(Collectors.toList()).forEach(employee -> {
resultList.add(employee.getEmployeeId());
});
employeeList.stream().sorted(java.util.Comparator.comparing(Employee::getEmployeeName))
.collect(Collectors.toList()).forEach(employee -> {
resultList.add(employee.getEmployeeName());
});
employeeList.stream().sorted(java.util.Comparator.comparing(Employee::getEmailId)).collect(Collectors.toList())
.forEach(employee -> {
resultList.add(employee.getEmailId());
});
return resultList;
}
@Override
public List<HashMap<String, String>> getDeliveryLeads(String domainId) {
Domain domain = domainService.getDomainById(domainId);
return getDeliveryManagerMap(domain.getDeliveryManagers());
}
@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);
}
@Override
public boolean verifyEmployeeRole(String empId, String roleIdReq) {
boolean flag = false;
log.info("The employeeId::" + empId);
Employee employee = getEmployeeById(empId);
log.info("Employee::::in EmployeeService::" + employee);
String roleName = employee.getRole();
log.info("The employee role::" + roleName);
if (StringUtils.isNotBlank(roleName) && !ApplicationRole.ADMIN.getRoleName().equalsIgnoreCase(roleName)) {
if (ApplicationRole.FUNCTIONAL_MANAGER.getRoleName().equalsIgnoreCase(roleName) ||
ApplicationRole.DELIVERY_LEAD.getRoleName().equalsIgnoreCase(roleName)) {
flag = true;
log.info("in if block");
} else {
log.info("in else block");
Set<String> roleSet = employeeRoleService.empRolesMapInfoByEmpId(empId);
if (null != roleSet && !roleSet.isEmpty() && MyTeamUtils.INT_ZERO < roleSet.size()) {
if (roleSet.contains(roleIdReq)) {
flag = true;
}
}
}
}
log.info("before return flag::" + flag);
return flag;
}
public List<Employee> getEmployeesFromList(Set<String> empIdsSet) {
return employeeRepo.findByEmployeeIdIn(empIdsSet);
}
}
package com.nisum.myteam.service.impl;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.FindAndModifyOptions;
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.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.BillableEmployee;
import com.nisum.myteam.model.dao.Account;
import com.nisum.myteam.model.dao.Domain;
import com.nisum.myteam.model.dao.Employee;
import com.nisum.myteam.model.dao.Project;
import com.nisum.myteam.model.dao.Resource;
import com.nisum.myteam.repository.EmployeeRepo;
import com.nisum.myteam.service.IAccountService;
import com.nisum.myteam.service.IDomainService;
import com.nisum.myteam.service.IEmployeeLocationService;
import com.nisum.myteam.service.IEmployeeRoleService;
import com.nisum.myteam.service.IEmployeeService;
import com.nisum.myteam.service.IProjectService;
import com.nisum.myteam.service.IResourceService;
import com.nisum.myteam.statuscodes.ResourceStatus;
import com.nisum.myteam.utils.MyTeamUtils;
import com.nisum.myteam.utils.constants.ApplicationRole;
import com.nisum.myteam.utils.constants.RoleConstant;
import lombok.extern.slf4j.Slf4j;
@Service
@Slf4j
public class EmployeeService implements IEmployeeService {
@Autowired
private EmployeeRepo employeeRepo;
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private IAccountService accountService;
@Autowired
private IProjectService projectService;
@Autowired
private IDomainService domainService;
@Autowired
private IEmployeeRoleService employeeRoleService;
@Autowired
private IEmployeeLocationService empLocationService;
@Autowired
private IResourceService resourceService;
@Override
public Employee createEmployee(Employee employee, String loginEmpId) throws MyTeamException {
employee.setCreatedOn(new Date());
employee.setCreatedBy(loginEmpId);
employee.setModifiedBy(loginEmpId);
// adding employee to Bench Allocation
resourceService.addResourceToBenchProject(employee, loginEmpId);
// Saving employee Location Details.
empLocationService.save(employee);
return employeeRepo.save(employee);
}
@Override
public Employee updateEmployee(Employee employeeReq, String loginEmpId) {
// update all emp details to inactive if employee is inactive
Query query = new Query(Criteria.where("employeeId").is(employeeReq.getEmployeeId()));
Update update = new Update();
update.set("employeeName", employeeReq.getEmployeeName());
update.set("emailId", employeeReq.getEmailId());
update.set("role", employeeReq.getRole());
update.set("gender", employeeReq.getGender());
update.set("functionalGroup", employeeReq.getFunctionalGroup());
update.set("empStatus", employeeReq.getEmpStatus());
update.set("empSubStatus", employeeReq.getEmpSubStatus());
update.set("employmentType", employeeReq.getEmploymentType());
update.set("empLocation", employeeReq.getEmpLocation());
// update.set("domain", employeeReq.getDomain());
update.set("designation", employeeReq.getDesignation());
update.set("dateOfBirth", employeeReq.getDateOfBirth());
update.set("dateOfJoining", employeeReq.getDateOfJoining());
update.set("lastModifiedOn", new Date());
update.set("hasPassort", employeeReq.getHasPassort());
update.set("hasB1", employeeReq.getHasB1());
update.set("passportExpiryDate", employeeReq.getPassportExpiryDate());
update.set("b1ExpiryDate", employeeReq.getB1ExpiryDate());
update.set("modifiedBy", loginEmpId);
if (employeeReq.getEmpStatus().equalsIgnoreCase(MyTeamUtils.IN_ACTIVE_SPACE)) {
update.set("endDate", employeeReq.getEndDate());
update.set("empSubStatus", null);
}
// update employee location
if (employeeReq.getEmpLocation() != null && !employeeReq.getEmpLocation().equals("")) {
Employee existingEmployee = employeeRepo.findByEmployeeId(employeeReq.getEmployeeId());
if (!existingEmployee.getEmpLocation().equals(employeeReq.getEmpLocation())) {
empLocationService.update(employeeReq, false);
}
}
// update employee details
FindAndModifyOptions options = new FindAndModifyOptions();
options.returnNew(true);
options.upsert(true);
Employee employeeUpdated = mongoTemplate.findAndModify(query, update, options, Employee.class);
try {
// add to resource collection
//resourceService.addResources(employeeUpdated, loginEmpId);
// inactive the employee from the assigned project.
//resourceService.inactivateResource(employeeReq, employeeUpdated, loginEmpId);
} catch (Exception e) {
}
return employeeUpdated;
}
@Override
public Employee deleteEmployee(String employeeId) {
Query query = new Query();
query.addCriteria(Criteria.where("employeeId").is(employeeId));
Update update = new Update();
update.set("empStatus", "InActive");
Employee employeeUpdated = mongoTemplate.findAndModify(query, update, Employee.class);
log.info("The Deletion operation Result::" + employeeUpdated);
return employeeUpdated;
}
@Override
public Employee updateProfile(Employee employeeReq) throws MyTeamException {
boolean mobileNumberChanged = false;
employeeReq.setLastModifiedOn(new Date());
Employee existingEmployee = employeeRepo.findByEmployeeId(employeeReq.getEmployeeId());
String newMobileNumber = employeeReq.getMobileNumber();
if (newMobileNumber != null && !newMobileNumber.equalsIgnoreCase("")) {
if ((existingEmployee != null && existingEmployee.getMobileNumber() != null
&& !existingEmployee.getMobileNumber().equalsIgnoreCase(newMobileNumber))
|| (existingEmployee.getMobileNumber() == null)) {
mobileNumberChanged = true;
}
}
existingEmployee.setMobileNumber(employeeReq.getMobileNumber());
existingEmployee.setAlternateMobileNumber(employeeReq.getAlternateMobileNumber());
existingEmployee.setPersonalEmailId(employeeReq.getPersonalEmailId());
existingEmployee.setBaseTechnology(employeeReq.getBaseTechnology());
existingEmployee.setTechnologyKnown(employeeReq.getTechnologyKnown());
Employee employeePersisted = employeeRepo.save(existingEmployee);
return employeePersisted;
}
public boolean isEmployeeExistsById(String employeeId) {
Employee employeeFound = getEmployeeById(employeeId);
return (employeeFound == null) ? false : true;
}
@Override
public Employee getEmployeeById(String employeeId) {
log.info("The employeeId::" + employeeId);
Employee employee = employeeRepo.findByEmployeeId(employeeId);
log.info("Employee Found in Repo::" + employee);
return employee;
}
@Override
public List<Employee> getAllEmployees() {
return employeeRepo.findAll();
}
@Override
public Employee getEmployeeByEmaillId(String emailId) {
return employeeRepo.findByEmailId(emailId);
}
@Override
public List<Employee> getEmployeesByEmpStatusAndShift(String empStatus, String shift) {
return employeeRepo.findByEmpStatusAndShiftLikeOrderByEmployeeIdDesc(empStatus, shift);
}
public List<Employee> getManagers() throws MyTeamException {
List<Employee> activeEmpsList = getActiveEmployees();
List<Employee> managers = activeEmpsList.stream()
.filter(employee -> (RoleConstant.DIRECTOR.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.DELIVERY_MANAGER.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.MANAGER.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.HR_MANAGER.getRoleName().equalsIgnoreCase(employee.getRole())
|| RoleConstant.LEAD.getRoleName().equalsIgnoreCase(employee.getRole())))
.sorted(Comparator.comparing(Employee::getEmployeeName)).collect(Collectors.toList());
return managers;
}
@Override
public List<Employee> getActiveEmployees() throws MyTeamException {
return employeeRepo.findByEmpStatus(MyTeamUtils.ACTIVE);
}
@Override
public List<Employee> getEmployeesByStatus(String status) {
if (status.equals("all")) {
return employeeRepo.findAll(new Sort(Sort.Direction.ASC, "employeeName"));
} else if (status.equals("Vacation")) {
Query query = new Query();
query.addCriteria(Criteria.where("empSubStatus").ne("Resigned").andOperator(Criteria.where("empSubStatus").ne(null),Criteria.where("empSubStatus").ne("")));
return mongoTemplate.find(query, Employee.class);
} else if (status.equals("Resigned")) {
return employeeRepo.findByEmpSubStatusOrderByEmployeeNameAsc("Resigned");
} else {
return employeeRepo.findByEmpStatus(status);
}
}
@Override
public List<Account> getAccounts() throws MyTeamException {
return accountService.getAllAccounts();
}
@Override
public Employee getEmployeeRoleDataForSearchCriteria(String searchId, String searchAttribute) {
if (MyTeamUtils.EMPLOYEE_NAME.equals(searchAttribute)) {
return employeeRepo.findByEmployeeName(searchId);
} else if (MyTeamUtils.EMAIL_ID.equals(searchAttribute)) {
return employeeRepo.findByEmailId(searchId);
}
return null;
}
@Override
public List<String> getEmployeeDetailsForAutocomplete() {
List<Employee> employeeList = employeeRepo.findAll();
List<String> resultList = new ArrayList<>();
employeeList.stream().sorted(java.util.Comparator.comparing(Employee::getEmployeeId))
.collect(Collectors.toList()).forEach(employee -> {
resultList.add(employee.getEmployeeId());
});
employeeList.stream().sorted(java.util.Comparator.comparing(Employee::getEmployeeName))
.collect(Collectors.toList()).forEach(employee -> {
resultList.add(employee.getEmployeeName());
});
employeeList.stream().sorted(java.util.Comparator.comparing(Employee::getEmailId)).collect(Collectors.toList())
.forEach(employee -> {
resultList.add(employee.getEmailId());
});
return resultList;
}
@Override
public List<HashMap<String, String>> getDeliveryLeads(String domainId) {
Domain domain = domainService.getDomainById(domainId);
return getDeliveryManagerMap(domain.getDeliveryManagers());
}
@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);
}
@Override
public boolean verifyEmployeeRole(String empId, String roleIdReq) {
boolean flag = false;
log.info("The employeeId::" + empId);
Employee employee = getEmployeeById(empId);
log.info("Employee::::in EmployeeService::" + employee);
String roleName = employee.getRole();
log.info("The employee role::" + roleName);
if (StringUtils.isNotBlank(roleName) && !ApplicationRole.ADMIN.getRoleName().equalsIgnoreCase(roleName)) {
if (ApplicationRole.FUNCTIONAL_MANAGER.getRoleName().equalsIgnoreCase(roleName) ||
ApplicationRole.DELIVERY_LEAD.getRoleName().equalsIgnoreCase(roleName)) {
flag = true;
log.info("in if block");
} else {
log.info("in else block");
Set<String> roleSet = employeeRoleService.empRolesMapInfoByEmpId(empId);
if (null != roleSet && !roleSet.isEmpty() && MyTeamUtils.INT_ZERO < roleSet.size()) {
if (roleSet.contains(roleIdReq)) {
flag = true;
}
}
}
}
log.info("before return flag::" + flag);
return flag;
}
public List<Employee> getEmployeesFromList(Set<String> empIdsSet) {
return employeeRepo.findByEmployeeIdIn(empIdsSet);
}
@Override
public List<BillableEmployee> getEmployeeDetailsByFGAndBillability(String fGroup, String billableStatus) {
List<Resource> resources=resourceService.findByBillableStatus(billableStatus);
return getBillableEmployeeByfunctionalGroup(fGroup,resources);
}
private List<BillableEmployee> getBillableEmployeeByfunctionalGroup(String fGroup, List<Resource> resources) {
List<BillableEmployee> employeesForUI=new ArrayList<>();
List<Employee> employeeswithFG=employeeRepo.findByEmpStatusAndFunctionalGroup(ResourceStatus.ACTIVE.getStatus(), fGroup);
for(Resource resourceObj:resources) {
Project project=projectService.getProjectByProjectId(resourceObj.getProjectId());
for(Employee employee:employeeswithFG) {
if(employee.getEmployeeId().equals(resourceObj.getEmployeeId())) {
BillableEmployee billableEmployee=new BillableEmployee();
billableEmployee.setEmployeeId(resourceObj.getEmployeeId());
billableEmployee.setEmployeeName(employee.getEmployeeName());
billableEmployee.setEmailId(employee.getEmailId());
billableEmployee.setProjectName(project.getProjectName());
billableEmployee.setBillingStartDate(resourceObj.getBillingStartDate());
billableEmployee.setBillableStatus(resourceObj.getBillableStatus());
billableEmployee.setBillingEndDate(resourceObj.getBillingEndDate());
billableEmployee.setFunctionalGroup(fGroup);
employeesForUI.add(billableEmployee);
}
}
}
return employeesForUI;
}
}
src/main/java/com/nisum/myteam/service/impl/ResourceService.java
View file @ 099feaf1
package com.nisum.myteam.service.impl;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.dao.*;
import com.nisum.myteam.model.vo.*;
import com.nisum.myteam.repository.ResourceRepo;
import com.nisum.myteam.service.*;
import com.nisum.myteam.statuscodes.ResourceAllocationStatus;
import com.nisum.myteam.statuscodes.ResourceStatus;
import com.nisum.myteam.utils.MyTeamDateUtils;
import com.nisum.myteam.utils.MyTeamUtils;
import com.nisum.myteam.utils.constants.Shifts;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
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 java.util.*;
import java.util.stream.Collectors;
@Service
@Slf4j
public class ResourceService implements IResourceService {
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private ResourceRepo resourceRepo;
@Autowired
private IAccountService accountService;
@Autowired
private IDomainService domainService;
@Autowired
private IProjectService projectService;
@Autowired
private IEmployeeService employeeService;
@Autowired
private IEmployeeShiftService empShiftService;
public HashMap<String, Object> respMap = new HashMap<>();
private Resource getLatestAllocation(List<Resource> resourceAllocList){
Resource latestAlloc = null;
if(!resourceAllocList.isEmpty()) {
latestAlloc = resourceAllocList.get(0);
for (Resource resource : resourceAllocList) {
if (latestAlloc.getBillingEndDate().before(resource.getBillingEndDate()))
latestAlloc = resource;
}
}
return latestAlloc;
}
public List<Resource> getResourcesByEmployeeId(String employeeId){
return resourceRepo.findByEmployeeId(employeeId);
}
public Resource addResource(Resource resourceReq, String loginEmpId) throws MyTeamException {
List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
Resource prevAllocation = this.getLatestAllocation(resourceAllocList);
if (prevAllocation != null) {
if (prevAllocation.getBillingEndDate().compareTo(new Date()) == 0) {
prevAllocation.setBillingEndDate(new Date());
} else {
prevAllocation.setBillingEndDate(MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate())); //adding resource.
}
this.updateExistedResource(prevAllocation);
}
if(resourceAllocList.isEmpty()){
List<Resource> resourceBenchList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(),MyTeamUtils.BENCH_PROJECT_ID);
if(!resourceBenchList.isEmpty()){
Resource resourceBench = resourceBenchList.get(0);
resourceBench.setBillingEndDate(MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate()));
resourceRepo.save(resourceBench);
}
}
return resourceRepo.save(resourceReq);
}
public boolean isResourceExistsForProject(String employeeId, String projectId) {
boolean isExists = false;
List<Resource> resourceList = resourceRepo.findByEmployeeIdAndProjectId(employeeId, projectId);
if (resourceList != null && resourceList.size() > 0) {
isExists = true;
respMap.put("message", "Resourse is already in the project");
return isExists;
}
respMap.put("statusCode", 810);
respMap.put("message", "Resource Not Found");
return isExists;
}
public void updateResourceDetails(Resource resourceReq, String loginEmpId) throws MyTeamException {
// List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
//
// List<Resource> resourceListWithLatestRecord = resourceAllocList.stream().filter(resource -> resource.getBillingEndDate().compareTo(new Date()) >= 0).collect(Collectors.toList());
//
// if (resourceListWithLatestRecord != null && resourceListWithLatestRecord.size() > 0) {
//
// Resource resourcePrev = resourceListWithLatestRecord.get(0); //latest resource record.
// log.info("Requsting Resource Allocation BillingStart Date::::"+resourceReq.getBillingStartDate());
// log.info("The before date is::" + MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate()));
// if(!resourcePrev.getBillableStatus().equals(resourceReq.getBillableStatus())) {
// if (resourcePrev.getBillingEndDate().compareTo(new Date()) == 0) {
// resourcePrev.setBillingEndDate(new Date());
// } else {
// resourcePrev.setBillingEndDate(MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate())); //adding resource.
// }
// insertNewResourceWithNewStatus(resourceReq,loginEmpId);
// }else {
// resourcePrev.setResourceRole(resourceReq.getResourceRole());
// resourcePrev.setBillingStartDate(resourceReq.getBillingStartDate());
// resourcePrev.setBillingEndDate(resourceReq.getBillingEndDate());
// //resourceAllocPrev.setBillingEndDate(); //adding resource.
// }
// log.info("After setting the date:::before saving the Resource::" + resourcePrev);
// this.updateExistedResource(resourcePrev);
// }
Resource resource = resourceRepo.findById(resourceReq.getId());
if(resource!=null){
this.updateExistedResource(resourceReq);
}else {
respMap.put("statusCode", 801);
respMap.put("message", "Record Not Found");
}
}
public void updateExistedResource(Resource resource) {
if (resource != null) {
Resource resourcePers = resourceRepo.save(resource);
respMap.put("statusCode", 801);
respMap.put("message", "Resource updated successfully");
respMap.put("resourceObj", resourcePers);
}
}
public void insertNewResourceWithNewStatus(Resource resourceReq, String loginEmpId) throws MyTeamException {
resourceReq.setId(null);
Resource resourcePers = resourceRepo.insert(resourceReq);
respMap.put("statusCode", 801);
respMap.put("message", "Resource updated successfully");
respMap.put("resourceObj", resourcePers);
}
public boolean validateAllocationAgainstPrevAllocation(Resource resourceReq){
boolean isValid = true;
List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
Resource prevAllocation = this.getLatestAllocation(resourceAllocList);
if (prevAllocation != null) {
if(!prevAllocation.getBillingStartDate().before(resourceReq.getBillingStartDate())){
respMap.put("statusCode", 811);
respMap.put("message", "Billing start date should be after previous allocation start date");
isValid = false;
}
if(prevAllocation.getBillableStatus().equalsIgnoreCase(resourceReq.getBillableStatus())){
respMap.put("statusCode", 811);
respMap.put("message", "Resource is already in "+prevAllocation.getBillableStatus()+" status only");
isValid = false;
}
}
return isValid;
}
public boolean validateBillingStartEndDateAgainstProjectStartEndDate(Resource resource, String loginEmpId) throws MyTeamException {
boolean isValid = true;
Project project = projectService.getProjectByProjectId(resource.getProjectId());
log.info("Project::" + project);
if (!resource.getBillingStartDate().after(project.getProjectStartDate())) {
log.info("Billing start date should be after Project start date");
respMap.put("statusCode", 811);
respMap.put("message", "Billing start date should be after Project start date");
isValid = false;
}
if (!resource.getBillingStartDate().before(resource.getBillingEndDate())) {
log.info("Billing start date should be before Billing End Date.");
respMap.put("statusCode", 812);
respMap.put("message", "Billing start date should be before Billing End Date.");
isValid = false;
}
log.info("ResourceALloc Req::" + resource);
log.info("" + project.getProjectEndDate().toString());
//if (!resourceAllocation.getBillingEndDate().before(project.getProjectEndDate())|| !resourceAllocation.getBillingEndDate().equals(project.getProjectEndDate())) {
if(!(resource.getBillingEndDate().compareTo(project.getProjectEndDate())<=0)) {
log.info("Billing end date should be on or before Project End Date.");
respMap.put("statusCode", 813);
respMap.put("message", "Billing end date should be before Project End Date.");
isValid = false;
}
respMap.put("resourceObj", resource);
return isValid;
}
public boolean validateBillingStartDateAgainstDOJ(Resource resource) {
String message = "";
boolean isValid = true;
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
Date empDoj = employeeService.getEmployeeById(resource.getEmployeeId()).getDateOfJoining();
if (resource.getBillingStartDate().compareTo(empDoj) < 0) {
message = "Resource Billing Start Date (" + resource.getBillingStartDate() + " ) in "
+ projectService.getProjectByProjectId(resource.getProjectId()).getProjectName()
+ " project should not be before Date of Joining ( " + empDoj + ").";
isValid = false;
respMap.put("statusCode", 814);
respMap.put("message", message);
}
return isValid;
}
public boolean isResourceAssignedToAnyProject(Resource resourceReq) {
boolean isAssigned = false;
String message = "";
//List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceAllocReq.getEmployeeId(), resourceAllocReq.getProjectId());
List<Resource> resourceAllocList = resourceRepo.findByEmployeeId(resourceReq.getEmployeeId());
List<Resource> resourceListWithLatestRecord = resourceAllocList.stream().filter(resource -> resource.getBillingEndDate().compareTo(new Date()) >= 0).collect(Collectors.toList());
if (resourceListWithLatestRecord != null && resourceListWithLatestRecord.size() > 0) {
Resource resourcePrev = resourceListWithLatestRecord.get(0);//latest resource record.
if (!resourcePrev.getProjectId().equalsIgnoreCase(MyTeamUtils.BENCH_PROJECT_ID) && !resourceReq.getProjectId().equalsIgnoreCase(resourcePrev.getProjectId())) {
message = "Resource " + resourcePrev.getEmployeeId() + " already Assigned to the "
+ projectService.getProjectByProjectId(resourcePrev.getProjectId()).getProjectName()
+ " Project" + " from " + resourcePrev.getBillingStartDate() + "to " + resourcePrev.getBillingEndDate();
isAssigned = true;
respMap.put("statusCode", 815);
respMap.put("message", message);
}
}
return isAssigned;
}
public void deleteResource(Resource resourceReq, String loginEmpId) {
List<Resource> resourcesList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
resourcesList.forEach(resource -> resourceRepo.delete(resource));
}
@Override
public List<Resource> getAllResources() {
return resourceRepo.findAll();
}
public List<ResourceVO> getAllResourcesVO() {
return getAllResources().stream().map(resource -> {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setEmployeeId(resource.getEmployeeId());
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
if (employee != null) {
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setMobileNo(employee.getMobileNumber());
}
Project project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
resourceVO.setProjectName(project.getProjectName());
resourceVO.setProjectStartDate(project.getProjectStartDate());
resourceVO.setProjectEndDate(project.getProjectEndDate());
resourceVO.setProjectStatus(project.getStatus());
if (project.getAccountId() != null) {
Account account = accountService.getAccountById(project.getAccountId());
if (account != null) {
resourceVO.setAccountName(account.getAccountName());
}
}
}
//Account account=accountService.getAccountById(domainService.getDomainById(project.getProjectId()).getAccountId());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setResourceRole(resource.getResourceRole());
if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
} else {
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
return resourceVO;
}).collect(Collectors.toList());
}
public List<Resource> getResourcesSortByBillingStartDate(String employeeId) {
Query query = prepareQuery(employeeId, MyTeamUtils.BILLING_START_DATE);
return mongoTemplate.find(query, Resource.class);
}
private Query prepareQuery(String employeeId, String dateColumn) {
Query query = new Query();
query.addCriteria(Criteria.where(MyTeamUtils.EMPLOYEE_ID).is(employeeId));
query.limit(MyTeamUtils.ONE);
query.with(new Sort(Sort.Direction.DESC, dateColumn));
return query;
}
@Override
public List<ResourceVO> getActiveResources(String empId) {
List<ResourceVO> resourcesList = new ArrayList<>();
for (Resource resource : resourceRepo.findByEmployeeId(empId)) {
if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
resourcesList.addAll(prepareProjectTeamMembersList(resource.getProjectId()));
}
}
return resourcesList;
}
public List<ResourceVO> prepareProjectTeamMembersList(String projectId) {
List<ResourceVO> finalResourcesList = new ArrayList<>();
Employee employee = null;
for (Resource resource : getAllResourcesForProject(projectId)) {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setEmployeeId(resource.getEmployeeId());
employee = employeeService.getEmployeeById(resource.getEmployeeId());
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setMobileNo(employee.getMobileNumber());
resourceVO.setProjectName(projectService.getProjectByProjectId(resource.getProjectId()).getProjectName());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setResourceRole(resource.getResourceRole());
if(resource.getBillingEndDate().compareTo(new Date())>0)
{
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
}else
{
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
finalResourcesList.add(resourceVO);
}
return finalResourcesList;
}
public List<Resource> getAllResourcesForProject(String projectId) {
return resourceRepo.findByProjectId(projectId);
}
@Override
public List<Resource> getAllResourcesForAllActiveProjects() {
List<Resource> resourceList = new ArrayList<>();
for (Project activeProject : projectService.getOnlyActiveProjects()) {
resourceList.addAll(getAllResourcesForProject(activeProject.getProjectId()));
}
return resourceList;
}
@Override
public List<ResourceVO> getResourcesForProject(String projectId, String statusFlag) {
List<ResourceVO> resourcesList = new ArrayList<>();
for (Resource resource : resourceRepo.findByProjectId(projectId)) {
Date billingEndDate = resource.getBillingEndDate();
if (billingEndDate != null) {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setProjectName(projectService.getProjectByProjectId(resource.getProjectId()).getProjectName());
resourceVO.setResourceRole(resource.getResourceRole());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setEmployeeId(resource.getEmployeeId());
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
// Active
if (statusFlag.equals(ResourceStatus.ACTIVE.getStatus()) && billingEndDate.compareTo(new Date()) >= 0) {
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
resourcesList.add(resourceVO);
} else if (statusFlag.equals(ResourceStatus.IN_ACTIVE.getStatus()) && billingEndDate.compareTo(new Date()) < 0) {
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
resourcesList.add(resourceVO);
} else if (statusFlag.equals(MyTeamUtils.BOTH))
resourcesList.add(resourceVO);
}
}
return resourcesList;
}
@Override
public List<MyProjectAllocationVO> getWorkedProjectsForResource(String empId) {
Project project = null;
Account account = null;
Domain domain = null;
Employee employee = null;
List<MyProjectAllocationVO> myProjectList = new ArrayList<>();
List<Resource> resourcesAllocatedList = resourceRepo.findByEmployeeId(empId);
if (null != resourcesAllocatedList && !resourcesAllocatedList.isEmpty() && MyTeamUtils.INT_ZERO < resourcesAllocatedList.size()) {
for (Resource resourceAlloc : resourcesAllocatedList) {
project = projectService.getProjectByProjectId(resourceAlloc.getProjectId());
account = accountService.getAccountById(project.getAccountId());
domain = domainService.getDomainById(project.getDomainId());
employee = employeeService.getEmployeeById(resourceAlloc.getEmployeeId());
MyProjectAllocationVO myProject = new MyProjectAllocationVO();
myProject.setProjectId(project.getProjectId());
myProject.setProjectName(project.getProjectName());
myProject.setProjectStartDate(project.getProjectStartDate());
myProject.setProjectEndDate(project.getProjectEndDate());
myProject.setProjectStatus(project.getStatus());
myProject.setAccountName(account.getAccountName());
myProject.setBillableStatus(resourceAlloc.getBillableStatus());
myProject.setBillingStartDate(resourceAlloc.getBillingStartDate());
myProject.setBillingEndDate(resourceAlloc.getBillingEndDate());
myProject.setShift(employee.getShift());
if (resourceAlloc.getBillingEndDate().compareTo(new Date()) > 0) {
myProject.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
} else {
myProject.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
if (project.getDeliveryLeadIds() != null) {
myProject.setDeliveryLeadIds(employeeService.getDeliveryManagerMap(project.getDeliveryLeadIds()));
}
myProjectList.add(myProject);
}
}
return myProjectList;
}
@Override
public List<Resource> getResourcesUnderDeliveryLead(String deliveryLeadId) {
List<String> projectIdsList = new ArrayList<>();
List<Resource> resourcesList = new ArrayList<>();
for (Project project : projectService.getProjectsForDeliveryLead(deliveryLeadId))
projectIdsList.add(project.getProjectId());
Query query = new Query(Criteria.where("projectId").in(projectIdsList));
List<Resource> resourcesListPersisted = mongoTemplate.find(query, Resource.class);
for (Resource resourceAlloc : resourcesListPersisted) {
if (!resourceAlloc.getEmployeeId().equals(deliveryLeadId))
resourcesList.add(resourceAlloc);
}
return resourcesList;
}
@Override
public List<ResourceVO> getBillingsForEmployee(String empId) {
List<ResourceVO> finalList=new ArrayList<>();
List<Resource> resourcesList = resourceRepo.findByEmployeeId(empId);
if (resourcesList != null && resourcesList.size() > 0) {
log.info("The resources billing list before sorting::" + resourcesList);
//return billingsList.stream().sorted(Comparator.comparing(Billing::getCreatedOn).reversed()).collect(Collectors.toList());
List<Resource> sortedList = resourcesList.stream().sorted(Comparator.comparing(Resource::getBillingStartDate).reversed()).collect(Collectors.toList());
finalList= convertResourcesToResourcesVO(sortedList);
}
return finalList;
}
@Override
public List<Resource> getBillingsForProject(String empId, String projectId) {
List<Resource> resourcesList = resourceRepo.findByEmployeeIdAndProjectId(empId, projectId);
if (resourcesList == null || resourcesList.size() == 0) {
return resourcesList;
} else {
//return billingsList.stream().sorted(Comparator.comparing(Billing::getCreatedOn).reversed()).collect(Collectors.toList());
return resourcesList.stream().sorted(Comparator.comparing(Resource::getBillingStartDate).reversed()).collect(Collectors.toList());
}
}
@Override
public List<Employee> getUnAssignedEmployees() {
List<Employee> notAssignedEmployees = new ArrayList<>();
List<String> resourceIdsList = new ArrayList<>();
for (Resource resource : this.getAllResources()) {
Project project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null && project.getStatus() != null && !"Completed".equalsIgnoreCase(project.getStatus())) {
resourceIdsList.add(resource.getEmployeeId());
}
}
for (Employee employee : employeeService.getAllEmployees()) {
if (!resourceIdsList.contains(employee.getEmployeeId())) {
notAssignedEmployees.add(employee);
}
}
return notAssignedEmployees;
}
public void deleteResourcesUnderProject(String projectId) {
Query query = new Query(Criteria.where("projectId").is(projectId));
List<Resource> list = mongoTemplate.find(query, Resource.class);
resourceRepo.delete(list);
}
private List<ResourceVO> convertResourcesToResourcesVO(List<Resource> resourcesList) {
List<ResourceVO> finalList = new ArrayList<>();
if (resourcesList != null && resourcesList.size() > 0) {
finalList = resourcesList.stream().map(resource -> {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setEmployeeId(resource.getEmployeeId());
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
if (employee != null) {
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setMobileNo(employee.getMobileNumber());
}
Project project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
resourceVO.setProjectName(project.getProjectName());
resourceVO.setProjectStartDate(project.getProjectStartDate());
resourceVO.setProjectEndDate(project.getProjectEndDate());
resourceVO.setProjectStatus(project.getStatus());
if (project.getAccountId() != null) {
Account account = accountService.getAccountById(project.getAccountId());
if (account != null) {
resourceVO.setAccountName(account.getAccountName());
}
}
}
//Account account=accountService.getAccountById(domainService.getDomainById(project.getProjectId()).getAccountId());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setResourceRole(resource.getResourceRole());
if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
} else {
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
return resourceVO;
}).collect(Collectors.toList());
}
return finalList;
}
@Override
public Resource addResourceToBenchProject(Employee employee, String loginEmpId) throws MyTeamException {
Resource resourcePersisted = null;
Resource resourceBench = new Resource();
resourceBench.setProjectId(MyTeamUtils.BENCH_PROJECT_ID);
resourceBench.setEmployeeId(employee.getEmployeeId());
resourceBench.setResourceRole(employee.getRole());
resourceBench.setBillingStartDate(employee.getDateOfJoining() != null ? employee.getDateOfJoining() : new Date());
resourceBench.setBillableStatus(MyTeamUtils.BENCH_BILLABILITY_STATUS);
resourceBench.setEmployeeId(employee.getEmployeeId());
resourceBench.setBillingEndDate(projectService.getProjectByProjectId(MyTeamUtils.BENCH_PROJECT_ID).getProjectEndDate());
resourcePersisted = addResource(resourceBench, loginEmpId);
return resourcePersisted;
}
@Override
public List<EmployeeShiftsVO> getResourcesForShift(String shift) {
List<Resource> resourcesListPers = null;
List<EmployeeShiftsVO> resourcesList = new ArrayList<>();
List<Project> projects = projectService.getAllProjects();
for (Project project : projects) {
if ("Active".equalsIgnoreCase(project.getStatus())) {
resourcesListPers = getAllResourcesForProject(project.getProjectId());
for (Resource resource : resourcesListPers) {
// EmployeeShift empShift = empShiftService.getEmployeeShift(resource.getEmployeeId());
// if (empShift != null) {
// if (empShift.getShift() != null && empShift.getShift().equalsIgnoreCase(shift))
// resourcesList.add(resource);
// else if (empShift.getShift() == null && Shifts.SHIFT1.getShiftType().equalsIgnoreCase(shift))
// resourcesList.add(resource);
//
// }
if (resource.getBillingEndDate().compareTo(new Date()) >= 0) {
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
EmployeeShiftsVO shiftsVO = new EmployeeShiftsVO();
shiftsVO.setEmployeeId(employee.getEmployeeId());
shiftsVO.setEmployeeName(employee.getEmployeeName());
shiftsVO.setEmailId(employee.getEmailId());
shiftsVO.setMobileNo(employee.getMobileNumber());
shiftsVO.setProjectName(project.getProjectName());
if (employee != null) {
if (shift.equalsIgnoreCase(employee.getShift()))
resourcesList.add(shiftsVO);
else if (employee.getShift() == null && Shifts.SHIFT1.getShiftType().equalsIgnoreCase(shift))
resourcesList.add(shiftsVO);
}
}
}//for
}
}
return resourcesList;
}
@Override
public Resource getLatestResourceByEmpId(String employeeId){
List<Resource> resourceList = resourceRepo.findByEmployeeId(employeeId).stream().
filter(r -> r.getBillingEndDate().after(new Date())).collect(Collectors.toList());
if(!resourceList.isEmpty())
return resourceList.get(0);
else
return null;
}
@Override
public List<Resource> getResourcesByBillingStatus(String resourceStatus) {
return resourceRepo.findByBillableStatus(resourceStatus);
}
@Override
public List<ReserveReportsVO> getResourceReportsByBillingStatus(String resourceStatus) {
return prepareReserveReports(getResourcesByBillingStatus(resourceStatus));
}
@Override
public List<ReserveReportsVO> prepareReserveReports(List<Resource> resourcesList) {
List<ReserveReportsVO> reserveReportsList = new ArrayList<>();
if (resourcesList != null && resourcesList.size() > 0) {
Project project = null;
for (Resource resource : resourcesList) {
ReserveReportsVO reserveReportsVO = new ReserveReportsVO();
reserveReportsVO.setEmployeeId(resource.getEmployeeId());
reserveReportsVO.setEmployeeName(employeeService.getEmployeeById(resource.getEmployeeId()).getEmployeeName());
if (StringUtils.isNotBlank(resource.getProjectId())) {
project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
reserveReportsVO.setProjectName(project.getProjectName());
reserveReportsVO.setAccountName(accountService.getAccountById(project.getAccountId()).getAccountName());
}
}
reserveReportsVO.setBillingStartDate(resource.getBillingStartDate());
reserveReportsVO.setBillingEndDate(resource.getBillingEndDate());
reserveReportsList.add(reserveReportsVO);
}
}
return reserveReportsList;
}
public List<ChangedResourceVO> getChangedResourceByDate(String fromDatestr, String toDatestr){
// List<ChangedResourceVO> changedResourceVOList = new ArrayList();
// SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
//
// try {
// final Date fromDate = format.parse(fromDatestr);
// final Date toDate = format.parse(toDatestr);
// resourceRepo.findAll().stream().
// filter(r -> r.getBillingStartDate().before(toDate)&&r.getBillingEndDate().after(fromDate)).forEach(r -> {
// ChangedResourceVO crv = new ChangedResourceVO();
// Project project = projectService.getProjectByProjectId(r.getProjectId());
// Employee emp = employeeService.getEmployeeById(r.getEmployeeId());
// Account account = accountService.getAccountById(project.getAccountId());
//
//
// if(changedResourceVOList.isEmpty()){
// crv.setEmplyeeId(r.getEmployeeId());
// crv.setEmployeeName(emp.getEmployeeName());
// crv.setPrevBillingStatus(r.getBillableStatus());
// crv.setPrevBillingStartingDate(r.getBillingStartDate());
// crv.setPrevBillingEndDate(r.getBillingEndDate());
// crv.setPrevClient(account.getAccountName());
// crv.setPrevProject(project.getProjectName());
// }else {
//
// if(!crvList.isEmpty()){
//
// }else{
//
// }
// }
// changedResourceVOList.add(crv);
// });
//
// }catch (Exception e){}
//
return null;
}
public boolean validateResourceAllocationStatus(ResourceAllocationStatus resourceStatus) {
boolean isValidStatus = false;
switch (resourceStatus) {
case TRAINEE:
case BILLABLE:
case NON_BILLABLE:
case RESERVED:
isValidStatus = true;
break;
}
return isValidStatus;
}
public List<Resource> getResourcesGreaterThanBillingStartDate(Date billingStartDate) {
return resourceRepo.findByBillingStartDateGreaterThan(billingStartDate);
}
public List<Resource> getResourcesBetweenBillingStartDates(Date fromDate, Date toDate) {
return resourceRepo.findByBillingStartDateBetween(fromDate, toDate);
}
public List<AllocationChangeVO> getAllocationReports(Date fromDate, Date toDate) {
return prepareAllocationResources(getResourcesBetweenBillingStartDates(fromDate,toDate));
}
public List<AllocationChangeVO> prepareAllocationResources(List<Resource> resourcesList) {
List<AllocationChangeVO> allocationList = new ArrayList<>();
if (resourcesList != null && resourcesList.size() > 0) {
Project project = null;
for (Resource resource : resourcesList) {
AllocationChangeVO allocationVO = new AllocationChangeVO();
allocationVO.setEmployeeId(resource.getEmployeeId());
allocationVO.setEmployeeName(employeeService.getEmployeeById(resource.getEmployeeId()).getEmployeeName());
if (StringUtils.isNotBlank(resource.getProjectId())) {
project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
allocationVO.setCurrentProjectName(project.getProjectName());
allocationVO.setCurrentAccountName(accountService.getAccountById(project.getAccountId()).getAccountName());
}
}
allocationVO.setCurrentBillingStatus(resource.getBillableStatus());
allocationVO.setCurrentBillingStartDate(resource.getBillingStartDate());
allocationVO.setCurrentBillingEndDate(resource.getBillingEndDate());
allocationList.add(allocationVO);
}
}
return allocationList;
}
}//class
// @Override
// public List<ResourceVO> getActiveResources(String empId) {
// List<ResourceVO> finalResourcesList = new ArrayList<>();
//
// List<Resource> resourceList = resourceRepo.findByEmployeeId(empId);
// if (resourceList != null && resourceList.size() > 0) {
//
// Resource resourceAlloc=resourceList.get(0);
//
//
//
//
// }
//
// for (Resource resource : resourceRepo.findByEmployeeId(empId)) {
//
// ResourceVO resourceVO=new ResourceVO();
// resourceVO.setEmployeeId(resource.getEmployeeId());
//
// Employee employee=employeeService.getEmployeeById(resource.getEmployeeId());
// resourceVO.setEmployeeName(employee.getEmployeeName());
// resourceVO.setDesignation(employee.getDesignation());
// resourceVO.setEmailId(employee.getEmailId());
// resourceVO.setMobileNo(employee.getMobileNumber());
//
// resourceVO.setProjectName(projectService.getProjectByProjectId(resource.getProjectId()).getProjectName());
//
//
// if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
// finalResourcesList.addAll(getAllResourcesForProject(resource.getProjectId()));
// }
//
//
// }
// return finalResourcesList;
// }
// @Override
// public List<ResourceVO> getActiveResources(String empId) {
// List<ResourceVO> finalResourcesList = new ArrayList<>();
// Employee employee = null;
//
// List<Resource> resourceList = resourceRepo.findByEmployeeId(empId);
// Optional<Resource> optionalResource = resourceList.stream().filter(resource -> resource.getBillingEndDate().compareTo(new Date()) > 0).findAny();
// if (optionalResource.isPresent()) {
// finalResourcesList = prepareProjectTeamMembersList(optionalResource.get().getProjectId());
// }
// return finalResourcesList;
package com.nisum.myteam.service.impl;
import com.nisum.myteam.exception.handler.MyTeamException;
import com.nisum.myteam.model.dao.*;
import com.nisum.myteam.model.vo.*;
import com.nisum.myteam.repository.ResourceRepo;
import com.nisum.myteam.service.*;
import com.nisum.myteam.statuscodes.ResourceAllocationStatus;
import com.nisum.myteam.statuscodes.ResourceStatus;
import com.nisum.myteam.utils.MyTeamDateUtils;
import com.nisum.myteam.utils.MyTeamUtils;
import com.nisum.myteam.utils.constants.Shifts;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
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 java.util.*;
import java.util.stream.Collectors;
@Service
@Slf4j
public class ResourceService implements IResourceService {
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private ResourceRepo resourceRepo;
@Autowired
private IAccountService accountService;
@Autowired
private IDomainService domainService;
@Autowired
private IProjectService projectService;
@Autowired
private IEmployeeService employeeService;
@Autowired
private IEmployeeShiftService empShiftService;
public HashMap<String, Object> respMap = new HashMap<>();
private Resource getLatestAllocation(List<Resource> resourceAllocList){
Resource latestAlloc = null;
if(!resourceAllocList.isEmpty()) {
latestAlloc = resourceAllocList.get(0);
for (Resource resource : resourceAllocList) {
if (latestAlloc.getBillingEndDate().before(resource.getBillingEndDate()))
latestAlloc = resource;
}
}
return latestAlloc;
}
public List<Resource> getResourcesByEmployeeId(String employeeId){
return resourceRepo.findByEmployeeId(employeeId);
}
public Resource addResource(Resource resourceReq, String loginEmpId) throws MyTeamException {
List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
Resource prevAllocation = this.getLatestAllocation(resourceAllocList);
if (prevAllocation != null) {
if (prevAllocation.getBillingEndDate().compareTo(new Date()) == 0) {
prevAllocation.setBillingEndDate(new Date());
} else {
prevAllocation.setBillingEndDate(MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate())); //adding resource.
}
this.updateExistedResource(prevAllocation);
}
if(resourceAllocList.isEmpty()){
List<Resource> resourceBenchList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(),MyTeamUtils.BENCH_PROJECT_ID);
if(!resourceBenchList.isEmpty()){
Resource resourceBench = resourceBenchList.get(0);
resourceBench.setBillingEndDate(MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate()));
resourceRepo.save(resourceBench);
}
}
return resourceRepo.save(resourceReq);
}
public boolean isResourceExistsForProject(String employeeId, String projectId) {
boolean isExists = false;
List<Resource> resourceList = resourceRepo.findByEmployeeIdAndProjectId(employeeId, projectId);
if (resourceList != null && resourceList.size() > 0) {
isExists = true;
respMap.put("message", "Resourse is already in the project");
return isExists;
}
respMap.put("statusCode", 810);
respMap.put("message", "Resource Not Found");
return isExists;
}
public void updateResourceDetails(Resource resourceReq, String loginEmpId) throws MyTeamException {
// List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
//
// List<Resource> resourceListWithLatestRecord = resourceAllocList.stream().filter(resource -> resource.getBillingEndDate().compareTo(new Date()) >= 0).collect(Collectors.toList());
//
// if (resourceListWithLatestRecord != null && resourceListWithLatestRecord.size() > 0) {
//
// Resource resourcePrev = resourceListWithLatestRecord.get(0); //latest resource record.
// log.info("Requsting Resource Allocation BillingStart Date::::"+resourceReq.getBillingStartDate());
// log.info("The before date is::" + MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate()));
// if(!resourcePrev.getBillableStatus().equals(resourceReq.getBillableStatus())) {
// if (resourcePrev.getBillingEndDate().compareTo(new Date()) == 0) {
// resourcePrev.setBillingEndDate(new Date());
// } else {
// resourcePrev.setBillingEndDate(MyTeamDateUtils.getDayLessThanDate(resourceReq.getBillingStartDate())); //adding resource.
// }
// insertNewResourceWithNewStatus(resourceReq,loginEmpId);
// }else {
// resourcePrev.setResourceRole(resourceReq.getResourceRole());
// resourcePrev.setBillingStartDate(resourceReq.getBillingStartDate());
// resourcePrev.setBillingEndDate(resourceReq.getBillingEndDate());
// //resourceAllocPrev.setBillingEndDate(); //adding resource.
// }
// log.info("After setting the date:::before saving the Resource::" + resourcePrev);
// this.updateExistedResource(resourcePrev);
// }
Resource resource = resourceRepo.findById(resourceReq.getId());
if(resource!=null){
this.updateExistedResource(resourceReq);
}else {
respMap.put("statusCode", 801);
respMap.put("message", "Record Not Found");
}
}
public void updateExistedResource(Resource resource) {
if (resource != null) {
Resource resourcePers = resourceRepo.save(resource);
respMap.put("statusCode", 801);
respMap.put("message", "Resource updated successfully");
respMap.put("resourceObj", resourcePers);
}
}
public void insertNewResourceWithNewStatus(Resource resourceReq, String loginEmpId) throws MyTeamException {
resourceReq.setId(null);
Resource resourcePers = resourceRepo.insert(resourceReq);
respMap.put("statusCode", 801);
respMap.put("message", "Resource updated successfully");
respMap.put("resourceObj", resourcePers);
}
public boolean validateAllocationAgainstPrevAllocation(Resource resourceReq){
boolean isValid = true;
List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
Resource prevAllocation = this.getLatestAllocation(resourceAllocList);
if (prevAllocation != null) {
if(!prevAllocation.getBillingStartDate().before(resourceReq.getBillingStartDate())){
respMap.put("statusCode", 811);
respMap.put("message", "Billing start date should be after previous allocation start date");
isValid = false;
}
if(prevAllocation.getBillableStatus().equalsIgnoreCase(resourceReq.getBillableStatus())){
respMap.put("statusCode", 811);
respMap.put("message", "Resource is already in "+prevAllocation.getBillableStatus()+" status only");
isValid = false;
}
}
return isValid;
}
public boolean validateBillingStartEndDateAgainstProjectStartEndDate(Resource resource, String loginEmpId) throws MyTeamException {
boolean isValid = true;
Project project = projectService.getProjectByProjectId(resource.getProjectId());
log.info("Project::" + project);
if (!resource.getBillingStartDate().after(project.getProjectStartDate())) {
log.info("Billing start date should be after Project start date");
respMap.put("statusCode", 811);
respMap.put("message", "Billing start date should be after Project start date");
isValid = false;
}
if (!resource.getBillingStartDate().before(resource.getBillingEndDate())) {
log.info("Billing start date should be before Billing End Date.");
respMap.put("statusCode", 812);
respMap.put("message", "Billing start date should be before Billing End Date.");
isValid = false;
}
log.info("ResourceALloc Req::" + resource);
log.info("" + project.getProjectEndDate().toString());
//if (!resourceAllocation.getBillingEndDate().before(project.getProjectEndDate())|| !resourceAllocation.getBillingEndDate().equals(project.getProjectEndDate())) {
if(!(resource.getBillingEndDate().compareTo(project.getProjectEndDate())<=0)) {
log.info("Billing end date should be on or before Project End Date.");
respMap.put("statusCode", 813);
respMap.put("message", "Billing end date should be before Project End Date.");
isValid = false;
}
respMap.put("resourceObj", resource);
return isValid;
}
public boolean validateBillingStartDateAgainstDOJ(Resource resource) {
String message = "";
boolean isValid = true;
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
Date empDoj = employeeService.getEmployeeById(resource.getEmployeeId()).getDateOfJoining();
if (resource.getBillingStartDate().compareTo(empDoj) < 0) {
message = "Resource Billing Start Date (" + resource.getBillingStartDate() + " ) in "
+ projectService.getProjectByProjectId(resource.getProjectId()).getProjectName()
+ " project should not be before Date of Joining ( " + empDoj + ").";
isValid = false;
respMap.put("statusCode", 814);
respMap.put("message", message);
}
return isValid;
}
public boolean isResourceAssignedToAnyProject(Resource resourceReq) {
boolean isAssigned = false;
String message = "";
//List<Resource> resourceAllocList = resourceRepo.findByEmployeeIdAndProjectId(resourceAllocReq.getEmployeeId(), resourceAllocReq.getProjectId());
List<Resource> resourceAllocList = resourceRepo.findByEmployeeId(resourceReq.getEmployeeId());
List<Resource> resourceListWithLatestRecord = resourceAllocList.stream().filter(resource -> resource.getBillingEndDate().compareTo(new Date()) >= 0).collect(Collectors.toList());
if (resourceListWithLatestRecord != null && resourceListWithLatestRecord.size() > 0) {
Resource resourcePrev = resourceListWithLatestRecord.get(0);//latest resource record.
if (!resourcePrev.getProjectId().equalsIgnoreCase(MyTeamUtils.BENCH_PROJECT_ID) && !resourceReq.getProjectId().equalsIgnoreCase(resourcePrev.getProjectId())) {
message = "Resource " + resourcePrev.getEmployeeId() + " already Assigned to the "
+ projectService.getProjectByProjectId(resourcePrev.getProjectId()).getProjectName()
+ " Project" + " from " + resourcePrev.getBillingStartDate() + "to " + resourcePrev.getBillingEndDate();
isAssigned = true;
respMap.put("statusCode", 815);
respMap.put("message", message);
}
}
return isAssigned;
}
public void deleteResource(Resource resourceReq, String loginEmpId) {
List<Resource> resourcesList = resourceRepo.findByEmployeeIdAndProjectId(resourceReq.getEmployeeId(), resourceReq.getProjectId());
resourcesList.forEach(resource -> resourceRepo.delete(resource));
}
@Override
public List<Resource> getAllResources() {
return resourceRepo.findAll();
}
public List<ResourceVO> getAllResourcesVO() {
return getAllResources().stream().map(resource -> {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setEmployeeId(resource.getEmployeeId());
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
if (employee != null) {
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setMobileNo(employee.getMobileNumber());
}
Project project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
resourceVO.setProjectName(project.getProjectName());
resourceVO.setProjectStartDate(project.getProjectStartDate());
resourceVO.setProjectEndDate(project.getProjectEndDate());
resourceVO.setProjectStatus(project.getStatus());
if (project.getAccountId() != null) {
Account account = accountService.getAccountById(project.getAccountId());
if (account != null) {
resourceVO.setAccountName(account.getAccountName());
}
}
}
//Account account=accountService.getAccountById(domainService.getDomainById(project.getProjectId()).getAccountId());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setResourceRole(resource.getResourceRole());
if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
} else {
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
return resourceVO;
}).collect(Collectors.toList());
}
public List<Resource> getResourcesSortByBillingStartDate(String employeeId) {
Query query = prepareQuery(employeeId, MyTeamUtils.BILLING_START_DATE);
return mongoTemplate.find(query, Resource.class);
}
private Query prepareQuery(String employeeId, String dateColumn) {
Query query = new Query();
query.addCriteria(Criteria.where(MyTeamUtils.EMPLOYEE_ID).is(employeeId));
query.limit(MyTeamUtils.ONE);
query.with(new Sort(Sort.Direction.DESC, dateColumn));
return query;
}
@Override
public List<ResourceVO> getActiveResources(String empId) {
List<ResourceVO> resourcesList = new ArrayList<>();
for (Resource resource : resourceRepo.findByEmployeeId(empId)) {
if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
resourcesList.addAll(prepareProjectTeamMembersList(resource.getProjectId()));
}
}
return resourcesList;
}
public List<ResourceVO> prepareProjectTeamMembersList(String projectId) {
List<ResourceVO> finalResourcesList = new ArrayList<>();
Employee employee = null;
for (Resource resource : getAllResourcesForProject(projectId)) {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setEmployeeId(resource.getEmployeeId());
employee = employeeService.getEmployeeById(resource.getEmployeeId());
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setMobileNo(employee.getMobileNumber());
resourceVO.setProjectName(projectService.getProjectByProjectId(resource.getProjectId()).getProjectName());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setResourceRole(resource.getResourceRole());
if(resource.getBillingEndDate().compareTo(new Date())>0)
{
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
}else
{
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
finalResourcesList.add(resourceVO);
}
return finalResourcesList;
}
public List<Resource> getAllResourcesForProject(String projectId) {
return resourceRepo.findByProjectId(projectId);
}
@Override
public List<Resource> getAllResourcesForAllActiveProjects() {
List<Resource> resourceList = new ArrayList<>();
for (Project activeProject : projectService.getOnlyActiveProjects()) {
resourceList.addAll(getAllResourcesForProject(activeProject.getProjectId()));
}
return resourceList;
}
@Override
public List<ResourceVO> getResourcesForProject(String projectId, String statusFlag) {
List<ResourceVO> resourcesList = new ArrayList<>();
for (Resource resource : resourceRepo.findByProjectId(projectId)) {
Date billingEndDate = resource.getBillingEndDate();
if (billingEndDate != null) {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setProjectName(projectService.getProjectByProjectId(resource.getProjectId()).getProjectName());
resourceVO.setResourceRole(resource.getResourceRole());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setEmployeeId(resource.getEmployeeId());
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
// Active
if (statusFlag.equals(ResourceStatus.ACTIVE.getStatus()) && billingEndDate.compareTo(new Date()) >= 0) {
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
resourcesList.add(resourceVO);
} else if (statusFlag.equals(ResourceStatus.IN_ACTIVE.getStatus()) && billingEndDate.compareTo(new Date()) < 0) {
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
resourcesList.add(resourceVO);
} else if (statusFlag.equals(MyTeamUtils.BOTH))
resourcesList.add(resourceVO);
}
}
return resourcesList;
}
@Override
public List<MyProjectAllocationVO> getWorkedProjectsForResource(String empId) {
Project project = null;
Account account = null;
Domain domain = null;
Employee employee = null;
List<MyProjectAllocationVO> myProjectList = new ArrayList<>();
List<Resource> resourcesAllocatedList = resourceRepo.findByEmployeeId(empId);
if (null != resourcesAllocatedList && !resourcesAllocatedList.isEmpty() && MyTeamUtils.INT_ZERO < resourcesAllocatedList.size()) {
for (Resource resourceAlloc : resourcesAllocatedList) {
project = projectService.getProjectByProjectId(resourceAlloc.getProjectId());
account = accountService.getAccountById(project.getAccountId());
domain = domainService.getDomainById(project.getDomainId());
employee = employeeService.getEmployeeById(resourceAlloc.getEmployeeId());
MyProjectAllocationVO myProject = new MyProjectAllocationVO();
myProject.setProjectId(project.getProjectId());
myProject.setProjectName(project.getProjectName());
myProject.setProjectStartDate(project.getProjectStartDate());
myProject.setProjectEndDate(project.getProjectEndDate());
myProject.setProjectStatus(project.getStatus());
myProject.setAccountName(account.getAccountName());
myProject.setBillableStatus(resourceAlloc.getBillableStatus());
myProject.setBillingStartDate(resourceAlloc.getBillingStartDate());
myProject.setBillingEndDate(resourceAlloc.getBillingEndDate());
myProject.setShift(employee.getShift());
if (resourceAlloc.getBillingEndDate().compareTo(new Date()) > 0) {
myProject.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
} else {
myProject.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
if (project.getDeliveryLeadIds() != null) {
myProject.setDeliveryLeadIds(employeeService.getDeliveryManagerMap(project.getDeliveryLeadIds()));
}
myProjectList.add(myProject);
}
}
return myProjectList;
}
@Override
public List<Resource> getResourcesUnderDeliveryLead(String deliveryLeadId) {
List<String> projectIdsList = new ArrayList<>();
List<Resource> resourcesList = new ArrayList<>();
for (Project project : projectService.getProjectsForDeliveryLead(deliveryLeadId))
projectIdsList.add(project.getProjectId());
Query query = new Query(Criteria.where("projectId").in(projectIdsList));
List<Resource> resourcesListPersisted = mongoTemplate.find(query, Resource.class);
for (Resource resourceAlloc : resourcesListPersisted) {
if (!resourceAlloc.getEmployeeId().equals(deliveryLeadId))
resourcesList.add(resourceAlloc);
}
return resourcesList;
}
@Override
public List<ResourceVO> getBillingsForEmployee(String empId) {
List<ResourceVO> finalList=new ArrayList<>();
List<Resource> resourcesList = resourceRepo.findByEmployeeId(empId);
if (resourcesList != null && resourcesList.size() > 0) {
log.info("The resources billing list before sorting::" + resourcesList);
//return billingsList.stream().sorted(Comparator.comparing(Billing::getCreatedOn).reversed()).collect(Collectors.toList());
List<Resource> sortedList = resourcesList.stream().sorted(Comparator.comparing(Resource::getBillingStartDate).reversed()).collect(Collectors.toList());
finalList= convertResourcesToResourcesVO(sortedList);
}
return finalList;
}
@Override
public List<Resource> getBillingsForProject(String empId, String projectId) {
List<Resource> resourcesList = resourceRepo.findByEmployeeIdAndProjectId(empId, projectId);
if (resourcesList == null || resourcesList.size() == 0) {
return resourcesList;
} else {
//return billingsList.stream().sorted(Comparator.comparing(Billing::getCreatedOn).reversed()).collect(Collectors.toList());
return resourcesList.stream().sorted(Comparator.comparing(Resource::getBillingStartDate).reversed()).collect(Collectors.toList());
}
}
@Override
public List<Employee> getUnAssignedEmployees() {
List<Employee> notAssignedEmployees = new ArrayList<>();
List<String> resourceIdsList = new ArrayList<>();
for (Resource resource : this.getAllResources()) {
Project project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null && project.getStatus() != null && !"Completed".equalsIgnoreCase(project.getStatus())) {
resourceIdsList.add(resource.getEmployeeId());
}
}
for (Employee employee : employeeService.getAllEmployees()) {
if (!resourceIdsList.contains(employee.getEmployeeId())) {
notAssignedEmployees.add(employee);
}
}
return notAssignedEmployees;
}
public void deleteResourcesUnderProject(String projectId) {
Query query = new Query(Criteria.where("projectId").is(projectId));
List<Resource> list = mongoTemplate.find(query, Resource.class);
resourceRepo.delete(list);
}
private List<ResourceVO> convertResourcesToResourcesVO(List<Resource> resourcesList) {
List<ResourceVO> finalList = new ArrayList<>();
if (resourcesList != null && resourcesList.size() > 0) {
finalList = resourcesList.stream().map(resource -> {
ResourceVO resourceVO = new ResourceVO();
resourceVO.setId(resource.getId());
resourceVO.setProjectId(resource.getProjectId());
resourceVO.setEmployeeId(resource.getEmployeeId());
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
if (employee != null) {
resourceVO.setEmployeeName(employee.getEmployeeName());
resourceVO.setDesignation(employee.getDesignation());
resourceVO.setEmailId(employee.getEmailId());
resourceVO.setMobileNo(employee.getMobileNumber());
}
Project project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
resourceVO.setProjectName(project.getProjectName());
resourceVO.setProjectStartDate(project.getProjectStartDate());
resourceVO.setProjectEndDate(project.getProjectEndDate());
resourceVO.setProjectStatus(project.getStatus());
if (project.getAccountId() != null) {
Account account = accountService.getAccountById(project.getAccountId());
if (account != null) {
resourceVO.setAccountName(account.getAccountName());
}
}
}
//Account account=accountService.getAccountById(domainService.getDomainById(project.getProjectId()).getAccountId());
resourceVO.setBillableStatus(resource.getBillableStatus());
resourceVO.setBillingStartDate(resource.getBillingStartDate());
resourceVO.setBillingEndDate(resource.getBillingEndDate());
resourceVO.setResourceRole(resource.getResourceRole());
if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
resourceVO.setResourceStatus(ResourceStatus.ACTIVE.getStatus());
} else {
resourceVO.setResourceStatus(ResourceStatus.IN_ACTIVE.getStatus());
}
return resourceVO;
}).collect(Collectors.toList());
}
return finalList;
}
@Override
public Resource addResourceToBenchProject(Employee employee, String loginEmpId) throws MyTeamException {
Resource resourcePersisted = null;
Resource resourceBench = new Resource();
resourceBench.setProjectId(MyTeamUtils.BENCH_PROJECT_ID);
resourceBench.setEmployeeId(employee.getEmployeeId());
resourceBench.setResourceRole(employee.getRole());
resourceBench.setBillingStartDate(employee.getDateOfJoining() != null ? employee.getDateOfJoining() : new Date());
resourceBench.setBillableStatus(MyTeamUtils.BENCH_BILLABILITY_STATUS);
resourceBench.setEmployeeId(employee.getEmployeeId());
resourceBench.setBillingEndDate(projectService.getProjectByProjectId(MyTeamUtils.BENCH_PROJECT_ID).getProjectEndDate());
resourcePersisted = addResource(resourceBench, loginEmpId);
return resourcePersisted;
}
@Override
public List<EmployeeShiftsVO> getResourcesForShift(String shift) {
List<Resource> resourcesListPers = null;
List<EmployeeShiftsVO> resourcesList = new ArrayList<>();
List<Project> projects = projectService.getAllProjects();
for (Project project : projects) {
if ("Active".equalsIgnoreCase(project.getStatus())) {
resourcesListPers = getAllResourcesForProject(project.getProjectId());
for (Resource resource : resourcesListPers) {
// EmployeeShift empShift = empShiftService.getEmployeeShift(resource.getEmployeeId());
// if (empShift != null) {
// if (empShift.getShift() != null && empShift.getShift().equalsIgnoreCase(shift))
// resourcesList.add(resource);
// else if (empShift.getShift() == null && Shifts.SHIFT1.getShiftType().equalsIgnoreCase(shift))
// resourcesList.add(resource);
//
// }
if (resource.getBillingEndDate().compareTo(new Date()) >= 0) {
Employee employee = employeeService.getEmployeeById(resource.getEmployeeId());
EmployeeShiftsVO shiftsVO = new EmployeeShiftsVO();
shiftsVO.setEmployeeId(employee.getEmployeeId());
shiftsVO.setEmployeeName(employee.getEmployeeName());
shiftsVO.setEmailId(employee.getEmailId());
shiftsVO.setMobileNo(employee.getMobileNumber());
shiftsVO.setProjectName(project.getProjectName());
if (employee != null) {
if (shift.equalsIgnoreCase(employee.getShift()))
resourcesList.add(shiftsVO);
else if (employee.getShift() == null && Shifts.SHIFT1.getShiftType().equalsIgnoreCase(shift))
resourcesList.add(shiftsVO);
}
}
}//for
}
}
return resourcesList;
}
@Override
public Resource getLatestResourceByEmpId(String employeeId){
List<Resource> resourceList = resourceRepo.findByEmployeeId(employeeId).stream().
filter(r -> r.getBillingEndDate().after(new Date())).collect(Collectors.toList());
if(!resourceList.isEmpty())
return resourceList.get(0);
else
return null;
}
@Override
public List<Resource> getResourcesByBillingStatus(String resourceStatus) {
return resourceRepo.findByBillableStatus(resourceStatus);
}
@Override
public List<ReserveReportsVO> getResourceReportsByBillingStatus(String resourceStatus) {
return prepareReserveReports(getResourcesByBillingStatus(resourceStatus));
}
@Override
public List<ReserveReportsVO> prepareReserveReports(List<Resource> resourcesList) {
List<ReserveReportsVO> reserveReportsList = new ArrayList<>();
if (resourcesList != null && resourcesList.size() > 0) {
Project project = null;
for (Resource resource : resourcesList) {
ReserveReportsVO reserveReportsVO = new ReserveReportsVO();
reserveReportsVO.setEmployeeId(resource.getEmployeeId());
reserveReportsVO.setEmployeeName(employeeService.getEmployeeById(resource.getEmployeeId()).getEmployeeName());
if (StringUtils.isNotBlank(resource.getProjectId())) {
project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
reserveReportsVO.setProjectName(project.getProjectName());
reserveReportsVO.setAccountName(accountService.getAccountById(project.getAccountId()).getAccountName());
}
}
reserveReportsVO.setBillingStartDate(resource.getBillingStartDate());
reserveReportsVO.setBillingEndDate(resource.getBillingEndDate());
reserveReportsList.add(reserveReportsVO);
}
}
return reserveReportsList;
}
public List<ChangedResourceVO> getChangedResourceByDate(String fromDatestr, String toDatestr){
// List<ChangedResourceVO> changedResourceVOList = new ArrayList();
// SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
//
// try {
// final Date fromDate = format.parse(fromDatestr);
// final Date toDate = format.parse(toDatestr);
// resourceRepo.findAll().stream().
// filter(r -> r.getBillingStartDate().before(toDate)&&r.getBillingEndDate().after(fromDate)).forEach(r -> {
// ChangedResourceVO crv = new ChangedResourceVO();
// Project project = projectService.getProjectByProjectId(r.getProjectId());
// Employee emp = employeeService.getEmployeeById(r.getEmployeeId());
// Account account = accountService.getAccountById(project.getAccountId());
//
//
// if(changedResourceVOList.isEmpty()){
// crv.setEmplyeeId(r.getEmployeeId());
// crv.setEmployeeName(emp.getEmployeeName());
// crv.setPrevBillingStatus(r.getBillableStatus());
// crv.setPrevBillingStartingDate(r.getBillingStartDate());
// crv.setPrevBillingEndDate(r.getBillingEndDate());
// crv.setPrevClient(account.getAccountName());
// crv.setPrevProject(project.getProjectName());
// }else {
//
// if(!crvList.isEmpty()){
//
// }else{
//
// }
// }
// changedResourceVOList.add(crv);
// });
//
// }catch (Exception e){}
//
return null;
}
public boolean validateResourceAllocationStatus(ResourceAllocationStatus resourceStatus) {
boolean isValidStatus = false;
switch (resourceStatus) {
case TRAINEE:
case BILLABLE:
case NON_BILLABLE:
case RESERVED:
isValidStatus = true;
break;
}
return isValidStatus;
}
public List<Resource> getResourcesGreaterThanBillingStartDate(Date billingStartDate) {
return resourceRepo.findByBillingStartDateGreaterThan(billingStartDate);
}
public List<Resource> getResourcesBetweenBillingStartDates(Date fromDate, Date toDate) {
return resourceRepo.findByBillingStartDateBetween(fromDate, toDate);
}
public List<AllocationChangeVO> getAllocationReports(Date fromDate, Date toDate) {
return prepareAllocationResources(getResourcesBetweenBillingStartDates(fromDate,toDate));
}
public List<AllocationChangeVO> prepareAllocationResources(List<Resource> resourcesList) {
List<AllocationChangeVO> allocationList = new ArrayList<>();
if (resourcesList != null && resourcesList.size() > 0) {
Project project = null;
for (Resource resource : resourcesList) {
AllocationChangeVO allocationVO = new AllocationChangeVO();
allocationVO.setEmployeeId(resource.getEmployeeId());
allocationVO.setEmployeeName(employeeService.getEmployeeById(resource.getEmployeeId()).getEmployeeName());
if (StringUtils.isNotBlank(resource.getProjectId())) {
project = projectService.getProjectByProjectId(resource.getProjectId());
if (project != null) {
allocationVO.setCurrentProjectName(project.getProjectName());
allocationVO.setCurrentAccountName(accountService.getAccountById(project.getAccountId()).getAccountName());
}
}
allocationVO.setCurrentBillingStatus(resource.getBillableStatus());
allocationVO.setCurrentBillingStartDate(resource.getBillingStartDate());
allocationVO.setCurrentBillingEndDate(resource.getBillingEndDate());
allocationList.add(allocationVO);
}
}
return allocationList;
}
@Override
public List<Resource> findByBillableStatus(String billableStatus) {
return resourceRepo.findByBillableStatus(billableStatus);
}
}//class
// @Override
// public List<ResourceVO> getActiveResources(String empId) {
// List<ResourceVO> finalResourcesList = new ArrayList<>();
//
// List<Resource> resourceList = resourceRepo.findByEmployeeId(empId);
// if (resourceList != null && resourceList.size() > 0) {
//
// Resource resourceAlloc=resourceList.get(0);
//
//
//
//
// }
//
// for (Resource resource : resourceRepo.findByEmployeeId(empId)) {
//
// ResourceVO resourceVO=new ResourceVO();
// resourceVO.setEmployeeId(resource.getEmployeeId());
//
// Employee employee=employeeService.getEmployeeById(resource.getEmployeeId());
// resourceVO.setEmployeeName(employee.getEmployeeName());
// resourceVO.setDesignation(employee.getDesignation());
// resourceVO.setEmailId(employee.getEmailId());
// resourceVO.setMobileNo(employee.getMobileNumber());
//
// resourceVO.setProjectName(projectService.getProjectByProjectId(resource.getProjectId()).getProjectName());
//
//
// if (resource.getBillingEndDate().compareTo(new Date()) > 0) {
// finalResourcesList.addAll(getAllResourcesForProject(resource.getProjectId()));
// }
//
//
// }
// return finalResourcesList;
// }
// @Override
// public List<ResourceVO> getActiveResources(String empId) {
// List<ResourceVO> finalResourcesList = new ArrayList<>();
// Employee employee = null;
//
// List<Resource> resourceList = resourceRepo.findByEmployeeId(empId);
// Optional<Resource> optionalResource = resourceList.stream().filter(resource -> resource.getBillingEndDate().compareTo(new Date()) > 0).findAny();
// if (optionalResource.isPresent()) {
// finalResourcesList = prepareProjectTeamMembersList(optionalResource.get().getProjectId());
// }
// return finalResourcesList;
// }
\ No newline at end of file
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