Skip to content

M
mytime
Commit e09a1938 authored by mduppanapudi-nisum-com's avatar mduppanapudi-nisum-com Committed by rbonthala-nisum-com
Browse files
Options

integration issue (#78)

parent c99aa775
Hide whitespace changes
Inline Side-by-side
Showing with 912 additions and 895 deletions
src/main/java/com/nisum/mytime/model/Project.java
View file @ e09a1938
package com.nisum.mytime.model; package com.nisum.mytime.model;
import java.io.Serializable; import java.io.Serializable;
import java.util.List; import java.util.List;
import org.bson.types.ObjectId; import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id; import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document; import org.springframework.data.mongodb.core.mapping.Document;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Getter; import lombok.Getter;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import lombok.Setter; import lombok.Setter;
import lombok.ToString; import lombok.ToString;
@Setter @Setter
@Getter @Getter
@AllArgsConstructor @AllArgsConstructor
@NoArgsConstructor @NoArgsConstructor
@ToString @ToString
@Document(collection = "Teams") @Document(collection = "Teams")
public class Project implements Serializable { public class Project implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@Id @Id
private ObjectId id; private ObjectId id;
private String projectId; private String projectId;
private String projectName; private String projectName;
/* /*
* After Ui Integration this below commented code will be removed * After Ui Integration this below commented code will be removed
*/ */
//private String managerId; //private String managerId;
// private String managerName; // private String managerName;
// private String account; // private String account;
private String domain; private String domain;
private String status; private String status;
private List<String> employeeIds; private List<String> employeeIds;
private List<String> managerIds; private List<String> managerIds;
private String accountId; private String accountId;
private String domainId; private String domainId;
private List<String> deliveryLeadIds;
}
}
src/main/java/com/nisum/mytime/service/ProjectServiceImpl.java
View file @ e09a1938
package com.nisum.mytime.service; package com.nisum.mytime.service;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
import java.util.Comparator; import java.util.Comparator;
import java.util.Date; import java.util.Date;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import org.apache.commons.lang.time.DateUtils; import org.apache.commons.lang.time.DateUtils;
import org.bson.types.ObjectId; import org.bson.types.ObjectId;
import org.springframework.beans.BeanUtils; import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.FindAndModifyOptions; import org.springframework.data.mongodb.core.FindAndModifyOptions;
import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update; import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils; import org.springframework.util.CollectionUtils;
import com.mongodb.BasicDBObject; import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection; import com.mongodb.DBCollection;
import com.nisum.mytime.controller.DomainController; import com.nisum.mytime.controller.DomainController;
import com.nisum.mytime.exception.handler.MyTimeException; import com.nisum.mytime.exception.handler.MyTimeException;
import com.nisum.mytime.model.Account; import com.nisum.mytime.model.Account;
import com.nisum.mytime.model.BillingDetails; import com.nisum.mytime.model.BillingDetails;
import com.nisum.mytime.model.Domains; import com.nisum.mytime.model.Domains;
import com.nisum.mytime.model.EmpLoginData; import com.nisum.mytime.model.EmpLoginData;
import com.nisum.mytime.model.EmpShiftDetails; import com.nisum.mytime.model.EmpShiftDetails;
import com.nisum.mytime.model.EmployeeDashboardVO; import com.nisum.mytime.model.EmployeeDashboardVO;
import com.nisum.mytime.model.EmployeeRoles; import com.nisum.mytime.model.EmployeeRoles;
import com.nisum.mytime.model.Project; import com.nisum.mytime.model.Project;
import com.nisum.mytime.model.ProjectTeamMate; import com.nisum.mytime.model.ProjectTeamMate;
import com.nisum.mytime.repository.AccountRepo; import com.nisum.mytime.repository.AccountRepo;
import com.nisum.mytime.repository.DomainRepo; import com.nisum.mytime.repository.DomainRepo;
import com.nisum.mytime.repository.EmpShiftDetailsRepo; import com.nisum.mytime.repository.EmpShiftDetailsRepo;
import com.nisum.mytime.repository.EmployeeRolesRepo; import com.nisum.mytime.repository.EmployeeRolesRepo;
import com.nisum.mytime.repository.ProjectRepo; import com.nisum.mytime.repository.ProjectRepo;
import com.nisum.mytime.repository.ProjectTeamMatesRepo; import com.nisum.mytime.repository.ProjectTeamMatesRepo;
import com.nisum.mytime.repository.TeamMatesBillingRepo; import com.nisum.mytime.repository.TeamMatesBillingRepo;
import com.nisum.mytime.utils.MyTimeUtils; import com.nisum.mytime.utils.MyTimeUtils;
import com.nisum.mytime.utils.PdfReportGenerator; import com.nisum.mytime.utils.PdfReportGenerator;
@Service("projectService") @Service("projectService")
public class ProjectServiceImpl implements ProjectService { public class ProjectServiceImpl implements ProjectService {
@Autowired @Autowired
private EmployeeRolesRepo employeeRolesRepo; private EmployeeRolesRepo employeeRolesRepo;
@Autowired @Autowired
private ProjectRepo projectRepo; private ProjectRepo projectRepo;
@Autowired @Autowired
private ProjectTeamMatesRepo projectTeamMatesRepo; private ProjectTeamMatesRepo projectTeamMatesRepo;
@Autowired @Autowired
private TeamMatesBillingRepo teamMatesBillingRepo; private TeamMatesBillingRepo teamMatesBillingRepo;
@Autowired @Autowired
private EmployeeDataService employeeDataBaseService; private EmployeeDataService employeeDataBaseService;
@Autowired @Autowired
private PdfReportGenerator pdfReportGenerator; private PdfReportGenerator pdfReportGenerator;
@Autowired @Autowired
private MongoTemplate mongoTemplate; private MongoTemplate mongoTemplate;
@Autowired @Autowired
private EmpShiftDetailsRepo empShiftDetailsRepo; private EmpShiftDetailsRepo empShiftDetailsRepo;
@Autowired @Autowired
private DomainController domainController; private DomainController domainController;
@Autowired @Autowired
private RoleInfoService roleInfoService; private RoleInfoService roleInfoService;
@Autowired @Autowired
private RoleMappingService roleMappingService; private RoleMappingService roleMappingService;
@Autowired @Autowired
private AccountRepo accountRepo; private AccountRepo accountRepo;
@Autowired @Autowired
private DomainRepo domainRepo; private DomainRepo domainRepo;
@Override @Override
public List<EmpLoginData> employeeLoginsBasedOnDate(long id, public List<EmpLoginData> employeeLoginsBasedOnDate(long id,
String fromDate, String toDate) throws MyTimeException { String fromDate, String toDate) throws MyTimeException {
return employeeDataBaseService.fetchEmployeeLoginsBasedOnDates(id, return employeeDataBaseService.fetchEmployeeLoginsBasedOnDates(id,
fromDate, toDate); fromDate, toDate);
} }
@Override @Override
public String generatePdfReport(long id, String fromDate, String toDate) public String generatePdfReport(long id, String fromDate, String toDate)
throws MyTimeException { throws MyTimeException {
return pdfReportGenerator.generateEmployeeReport(id, fromDate, toDate); return pdfReportGenerator.generateEmployeeReport(id, fromDate, toDate);
} }
@Override @Override
public List<HashMap<Object, Object>> getProjects() throws MyTimeException { public List<HashMap<Object, Object>> getProjects() throws MyTimeException {
/* /*
* MT-79:returns all project info. This will get implemented once managers are * MT-79:returns all project info. This will get implemented once managers are
* maintained as List and not attributes * maintained as List and not attributes
* return projectRepo.findAll(); * return projectRepo.findAll();
*/ */
List<HashMap<Object, Object>> projectList = new ArrayList<>(); List<HashMap<Object, Object>> projectList = new ArrayList<>();
List<HashMap<String, String>> EmployeeList = null; List<HashMap<String, String>> EmployeeList = null;
List<Project> projects=projectRepo.findAll(); List<HashMap<String, String>> managerList = null;
for (Project p : projects) { List<Project> projects=projectRepo.findAll();
HashMap<Object, Object> projectMap = new HashMap<>(); for (Project p : projects) {
projectMap.put("id", p.getId()); HashMap<Object, Object> projectMap = new HashMap<>();
projectMap.put("projectId", p.getProjectId()); projectMap.put("id", p.getId());
projectMap.put("projectName", p.getProjectName()); projectMap.put("projectId", p.getProjectId());
Account account= accountRepo.findByAccountId(p.getAccountId()); projectMap.put("projectName", p.getProjectName());
Domains domain = domainRepo.findByDomainId(p.getDomainId()); Account account= accountRepo.findByAccountId(p.getAccountId());
if(domain!=null) Domains domain = domainRepo.findByDomainId(p.getDomainId());
projectMap.put("domain", domain.getDomainName()); if(domain!=null)
if(account!=null) projectMap.put("domain", domain.getDomainName());
projectMap.put("account", account.getAccountName()); if(account!=null)
projectMap.put("accountId", p.getAccountId()); projectMap.put("account", account.getAccountName());
projectMap.put("domainId", p.getDomainId()); projectMap.put("accountId", p.getAccountId());
projectMap.put("status", p.getStatus()); projectMap.put("domainId", p.getDomainId());
projectMap.put("employeeIds", p.getEmployeeIds()); projectMap.put("status", p.getStatus());
projectMap.put("employeeIds", p.getEmployeeIds());
/*if (p.getManagerIds() == null && p.getManagerId() != null) { // projectMap.put("deliveryLeadIds", p.getDeliveryLeadIds());
EmployeeList = getEmployeeData(Arrays.asList(p.getManagerId()));
} else*/ if (p.getManagerIds() != null) { /*if (p.getManagerIds() == null && p.getManagerId() != null) {
EmployeeList = getEmployeeData(Arrays.asList(p.getManagerId()));
List<String> managerIds = p.getManagerIds(); } else*/ if (p.getDeliveryLeadIds() != null) {
EmployeeList = getEmployeeData(managerIds);
} List<String> deliverLeadsId = p.getDeliveryLeadIds();
projectMap.put("managerIds", EmployeeList); EmployeeList = getEmployeeData(deliverLeadsId);
projectList.add(projectMap); projectMap.put("deliveryLeadIds", EmployeeList);
} }
return projectList; if (p.getManagerIds() != null) {
}
List<String> managerid = p.getManagerIds();
@Override managerList = getEmployeeData(managerid);
public Project addProject(Project project) throws MyTimeException { projectMap.put("managerIds", managerList);
if(project.getDomainId()==null) }
{ projectList.add(projectMap);
Domains domain=new Domains(); }
domain.setAccountId(project.getAccountId()); return projectList;
domain.setDomainName(project.getDomain()); }
domain.setDeliveryManagers(project.getManagerIds());
domain.setStatus(project.getStatus()); @Override
domainController.addDomain(domain); public Project addProject(Project project) throws MyTimeException {
} if(project.getDomainId()==null)
return projectRepo.save(project); {
} Domains domain=new Domains();
domain.setAccountId(project.getAccountId());
@Override domain.setDomainName(project.getDomain());
public EmployeeRoles getEmployeesRole(String emailId) { domain.setDeliveryManagers(project.getManagerIds());
return employeeRolesRepo.findByEmailId(emailId); domain.setStatus(project.getStatus());
domainController.addDomain(domain);
} List<Domains> domainsList=domainRepo.findByAccountId(project.getAccountId());
Domains savedDomain=domainsList.get(0);
@Override project.setDomainId(savedDomain.getDomainId());
public void deleteProject(String projectId) { project.setDomain(savedDomain.getDomainName());
Project project = projectRepo.findByProjectId(projectId); }
projectRepo.delete(project); return projectRepo.save(project);
Query query = new Query(Criteria.where("projectId").is(projectId)); }
List<ProjectTeamMate> list = mongoTemplate.find(query,
ProjectTeamMate.class); @Override
projectTeamMatesRepo.delete(list); public EmployeeRoles getEmployeesRole(String emailId) {
} return employeeRolesRepo.findByEmailId(emailId);
@Override }
public Project updateProject(Project project) {
Query query = new Query( @Override
Criteria.where("projectId").is(project.getProjectId())); public void deleteProject(String projectId) {
Update update = new Update(); Project project = projectRepo.findByProjectId(projectId);
update.set("projectName", project.getProjectName()); projectRepo.delete(project);
if(project.getManagerIds()!= null) Query query = new Query(Criteria.where("projectId").is(projectId));
{ List<ProjectTeamMate> list = mongoTemplate.find(query,
update.set("managerIds", project.getManagerIds()); ProjectTeamMate.class);
}/*else{ projectTeamMatesRepo.delete(list);
update.set("managerIds",Arrays.asList(project.getManagerId())); }
}*/
update.set("accountId", project.getAccountId()); @Override
update.set("status", project.getStatus()); public Project updateProject(Project project) {
FindAndModifyOptions options = new FindAndModifyOptions(); Query query = new Query(
options.returnNew(true); Criteria.where("projectId").is(project.getProjectId()));
options.upsert(true); Update update = new Update();
Project projectDB = mongoTemplate.findAndModify(query, update, options, update.set("projectName", project.getProjectName());
Project.class); if(project.getDeliveryLeadIds()!=null)
List<ProjectTeamMate> employeeDetails = projectTeamMatesRepo {
.findByProjectId(project.getProjectId()); update.set("deliveryLeadIds", project.getDeliveryLeadIds());
if (employeeDetails != null && projectDB != null) { }
for (ProjectTeamMate emp : employeeDetails) { /* if(project.getManagerIds()!= null)
//emp.setManagerId(projectDB.getManagerId()); {
//emp.setManagerName(projectDB.getManagerName()); update.set("managerIds", project.getManagerIds());
emp.setAccountId(projectDB.getAccountId()); }*//*else{
emp.setProjectName(projectDB.getProjectName()); update.set("managerIds",Arrays.asList(project.getManagerId()));
//MT-79:Maintatin the managerids in List }*/
// emp.setManagerIds(projectDB.getManagerIds()); update.set("accountId", project.getAccountId());
projectTeamMatesRepo.save(emp); update.set("status", project.getStatus());
} FindAndModifyOptions options = new FindAndModifyOptions();
} options.returnNew(true);
return projectDB; options.upsert(true);
} Project projectDB = mongoTemplate.findAndModify(query, update, options,
Project.class);
@Override List<ProjectTeamMate> employeeDetails = projectTeamMatesRepo
public EmployeeRoles getEmployeesRoleData(String employeeId) { .findByProjectId(project.getProjectId());
return employeeRolesRepo.findByEmployeeId(employeeId); if (employeeDetails != null && projectDB != null) {
} for (ProjectTeamMate emp : employeeDetails) {
//emp.setManagerId(projectDB.getManagerId());
@Override //emp.setManagerName(projectDB.getManagerName());
public List<ProjectTeamMate> getTeamDetails(String empId) { emp.setAccountId(projectDB.getAccountId());
List<String> projectsId = new ArrayList<>(); emp.setProjectName(projectDB.getProjectName());
List<ProjectTeamMate> listOfTeamMates=new ArrayList<>(); //MT-79:Maintatin the managerids in List
Query query = new Query(Criteria.where("employeeId").is(empId).and("role").is("Lead")); // emp.setManagerIds(projectDB.getManagerIds());
List<ProjectTeamMate> projectMatesList = mongoTemplate.find(query, ProjectTeamMate.class); projectTeamMatesRepo.save(emp);
for (ProjectTeamMate projectMate : projectMatesList) }
projectsId.add(projectMate.getProjectId()); }
Query query1 = new Query(Criteria.where("projectId").in(projectsId)); return projectDB;
List<ProjectTeamMate> projectMateList = mongoTemplate.find(query1, ProjectTeamMate.class); }
for (ProjectTeamMate projectTeamMate : projectMateList) {
if (!projectTeamMate.getEmployeeId().equals(empId)) @Override
listOfTeamMates.add(projectTeamMate); public EmployeeRoles getEmployeesRoleData(String employeeId) {
} return employeeRolesRepo.findByEmployeeId(employeeId);
return listOfTeamMates; }
} @Override
public List<ProjectTeamMate> getTeamDetails(String empId) {
// MT-72: fetching the projectteammate details. List<String> projectsId = new ArrayList<>();
@Override List<ProjectTeamMate> listOfTeamMates=new ArrayList<>();
public List<ProjectTeamMate> getProjectInfo(String employeeId) { Query query = new Query(Criteria.where("employeeId").is(empId).and("role").is("Lead"));
return mongoTemplate.find(getQuery(employeeId, MyTimeUtils.START_DATE), ProjectTeamMate.class); List<ProjectTeamMate> projectMatesList = mongoTemplate.find(query, ProjectTeamMate.class);
} for (ProjectTeamMate projectMate : projectMatesList)
projectsId.add(projectMate.getProjectId());
Query query1 = new Query(Criteria.where("projectId").in(projectsId));
@Override List<ProjectTeamMate> projectMateList = mongoTemplate.find(query1, ProjectTeamMate.class);
public ProjectTeamMate addProjectTeamMate(ProjectTeamMate projectTeamMate) for (ProjectTeamMate projectTeamMate : projectMateList) {
throws MyTimeException { if (!projectTeamMate.getEmployeeId().equals(empId))
if (projectTeamMate.getRole() != null && projectTeamMate.getRole().equals("Lead")) { listOfTeamMates.add(projectTeamMate);
Project project = projectRepo.findByProjectId(projectTeamMate.getProjectId()); }
project.getManagerIds().add(projectTeamMate.getEmployeeId()); return listOfTeamMates;
projectRepo.save(project);
} }
updateProjectEndDateInProjectTeamMate(projectTeamMate);
ProjectTeamMate pT = projectTeamMatesRepo.save(projectTeamMate); // MT-72: fetching the projectteammate details.
List<BillingDetails> listBD = getEmployeeActiveNisumBench( @Override
pT.getEmployeeId()); public List<ProjectTeamMate> getProjectInfo(String employeeId) {
for (BillingDetails b : listBD) { return mongoTemplate.find(getQuery(employeeId, MyTimeUtils.START_DATE), ProjectTeamMate.class);
Date d = pT.getStartDate() != null ? pT.getStartDate() : new Date(); }
b.setBillingEndDate(DateUtils.truncate(DateUtils.addDays(d, -1), Calendar.DATE));
b.setActive(false);
updateEmployeeBilling(b); @Override
} public ProjectTeamMate addProjectTeamMate(ProjectTeamMate projectTeamMate)
BillingDetails billings = new BillingDetails(); throws MyTimeException {
billings.setEmployeeId(pT.getEmployeeId()); if (projectTeamMate.getRole() != null && projectTeamMate.getRole().equals("Lead")) {
billings.setEmployeeName(pT.getEmployeeName()); Project project = projectRepo.findByProjectId(projectTeamMate.getProjectId());
billings.setProjectId(pT.getProjectId()); //project.getManagerIds().add(projectTeamMate.getEmployeeId());
billings.setProjectName(pT.getProjectName()); if(project.getManagerIds()!=null)
billings.setBillableStatus(pT.getBillableStatus()); project.getManagerIds().add(projectTeamMate.getEmployeeId());
billings.setAccount(pT.getAccount()); else
billings.setActive(true); project.setManagerIds(Arrays.asList(projectTeamMate.getEmployeeId()));
billings.setBillingStartDate(pT.getStartDate() == null projectRepo.save(project);
? DateUtils.truncate(new Date(), Calendar.DATE) }
: DateUtils.truncate(pT.getStartDate(), Calendar.DATE)); updateProjectEndDateInProjectTeamMate(projectTeamMate);
if (pT.getEndDate() != null) { ProjectTeamMate pT = projectTeamMatesRepo.save(projectTeamMate);
billings.setBillingEndDate( List<BillingDetails> listBD = getEmployeeActiveNisumBench(
DateUtils.truncate(pT.getEndDate(), Calendar.DATE)); pT.getEmployeeId());
} for (BillingDetails b : listBD) {
billings.setCreateDate(new Date()); Date d = pT.getStartDate() != null ? pT.getStartDate() : new Date();
updateProjectEndDateInBillingDetails(projectTeamMate.getNewBillingStartDate(), billings); b.setBillingEndDate(DateUtils.truncate(DateUtils.addDays(d, -1), Calendar.DATE));
addEmployeeBillingDetails(billings); b.setActive(false);
addShiftDetails(projectTeamMate); updateEmployeeBilling(b);
if (projectTeamMate.getProjectId() != null && !projectTeamMate }
.getProjectId().equalsIgnoreCase("Nisum0000")) { BillingDetails billings = new BillingDetails();
List<ProjectTeamMate> activeBenchProject = projectTeamMatesRepo billings.setEmployeeId(pT.getEmployeeId());
.findByEmployeeIdAndProjectIdAndActive( billings.setEmployeeName(pT.getEmployeeName());
projectTeamMate.getEmployeeId(), "Nisum0000", true); billings.setProjectId(pT.getProjectId());
if (activeBenchProject != null || activeBenchProject.size() != 0) { billings.setProjectName(pT.getProjectName());
for (ProjectTeamMate pteamMate : activeBenchProject) { billings.setBillableStatus(pT.getBillableStatus());
Date d = pT.getStartDate() != null ? pT.getStartDate() billings.setAccount(pT.getAccount());
: new Date(); billings.setActive(true);
pteamMate.setActive(false); billings.setBillingStartDate(pT.getStartDate() == null
pteamMate.setEndDate(DateUtils.truncate(DateUtils.addDays(d, -1), Calendar.DATE)); ? DateUtils.truncate(new Date(), Calendar.DATE)
projectTeamMatesRepo.save(pteamMate); : DateUtils.truncate(pT.getStartDate(), Calendar.DATE));
} if (pT.getEndDate() != null) {
} billings.setBillingEndDate(
} DateUtils.truncate(pT.getEndDate(), Calendar.DATE));
if (projectTeamMate.getRole()!= null && projectTeamMate.getRole().equals("Lead")) { }
Query query = new Query( billings.setCreateDate(new Date());
Criteria.where("employeeId").is(projectTeamMate.getEmployeeId()).and("role").ne("Lead")); updateProjectEndDateInBillingDetails(projectTeamMate.getNewBillingStartDate(), billings);
List<ProjectTeamMate> projectMates = mongoTemplate.find(query, ProjectTeamMate.class); addEmployeeBillingDetails(billings);
if (projectMates.size() == 0) { addShiftDetails(projectTeamMate);
String roleId = roleInfoService.getRole(MyTimeUtils.LEAD); if (projectTeamMate.getProjectId() != null && !projectTeamMate
roleMappingService.saveUniqueEmployeeAndRole(Arrays.asList(projectTeamMate.getEmployeeId()), roleId); .getProjectId().equalsIgnoreCase("Nisum0000")) {
} List<ProjectTeamMate> activeBenchProject = projectTeamMatesRepo
} .findByEmployeeIdAndProjectIdAndActive(
return pT; projectTeamMate.getEmployeeId(), "Nisum0000", true);
} if (activeBenchProject != null || activeBenchProject.size() != 0) {
for (ProjectTeamMate pteamMate : activeBenchProject) {
@Override Date d = pT.getStartDate() != null ? pT.getStartDate()
public ProjectTeamMate updateTeammate(ProjectTeamMate projectTeamMate) { : new Date();
pteamMate.setActive(false);
ProjectTeamMate existingTeammate = projectTeamMatesRepo pteamMate.setEndDate(DateUtils.truncate(DateUtils.addDays(d, -1), Calendar.DATE));
.findByEmployeeIdAndProjectId(projectTeamMate.getEmployeeId(), projectTeamMatesRepo.save(pteamMate);
projectTeamMate.getProjectId()); }
existingTeammate.setProjectId(projectTeamMate.getProjectId()); }
existingTeammate.setProjectName(projectTeamMate.getProjectName()); }
if (existingTeammate.getBillableStatus() == null if (projectTeamMate.getRole()!= null && projectTeamMate.getRole().equals("Lead")) {
|| projectTeamMate.getBillableStatus() != null Query query = new Query(
&& existingTeammate.getBillableStatus() != null Criteria.where("employeeId").is(projectTeamMate.getEmployeeId()).and("role").ne("Lead"));
&& !existingTeammate.getBillableStatus() List<ProjectTeamMate> projectMates = mongoTemplate.find(query, ProjectTeamMate.class);
.equalsIgnoreCase( if (projectMates.size() == 0) {
projectTeamMate.getBillableStatus())) { String roleId = roleInfoService.getRole(MyTimeUtils.LEAD);
List<BillingDetails> listBD = getEmployeeActiveBillingDetails( roleMappingService.saveUniqueEmployeeAndRole(Arrays.asList(projectTeamMate.getEmployeeId()), roleId);
projectTeamMate.getEmployeeId(), }
projectTeamMate.getProjectId()); }
if (listBD != null && !listBD.isEmpty()) { return pT;
BillingDetails billingDetails = listBD.get(0); }
/* Date d = new Date();
d.setDate(d.getDate() - 1);*/ @Override
Date d = projectTeamMate.getNewBillingStartDate(); public ProjectTeamMate updateTeammate(ProjectTeamMate projectTeamMate) {
d.setDate(d.getDate() - 1);
billingDetails.setBillingEndDate( ProjectTeamMate existingTeammate = projectTeamMatesRepo
DateUtils.truncate(d, Calendar.DATE)); .findByEmployeeIdAndProjectId(projectTeamMate.getEmployeeId(),
billingDetails.setActive(false); projectTeamMate.getProjectId());
updateEmployeeBilling(billingDetails); existingTeammate.setProjectId(projectTeamMate.getProjectId());
} existingTeammate.setProjectName(projectTeamMate.getProjectName());
BillingDetails billings = new BillingDetails(); if (existingTeammate.getBillableStatus() == null
billings.setEmployeeId(projectTeamMate.getEmployeeId()); || projectTeamMate.getBillableStatus() != null
billings.setEmployeeName(projectTeamMate.getEmployeeName()); && existingTeammate.getBillableStatus() != null
billings.setProjectId(projectTeamMate.getProjectId()); && !existingTeammate.getBillableStatus()
billings.setAccount(existingTeammate.getAccount()); .equalsIgnoreCase(
billings.setProjectName(projectTeamMate.getProjectName()); projectTeamMate.getBillableStatus())) {
billings.setBillableStatus(projectTeamMate.getBillableStatus()); List<BillingDetails> listBD = getEmployeeActiveBillingDetails(
billings.setActive(true); projectTeamMate.getEmployeeId(),
billings.setBillingStartDate( projectTeamMate.getProjectId());
DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE)); if (listBD != null && !listBD.isEmpty()) {
billings.setBillingEndDate(DateUtils BillingDetails billingDetails = listBD.get(0);
.truncate(projectTeamMate.getEndDate(), Calendar.DATE)); /* Date d = new Date();
billings.setCreateDate(new Date()); d.setDate(d.getDate() - 1);*/
addEmployeeBillingDetails(billings); Date d = projectTeamMate.getNewBillingStartDate();
// TODO d.setDate(d.getDate() - 1);
} billingDetails.setBillingEndDate(
existingTeammate.setBillableStatus(projectTeamMate.getBillableStatus()); DateUtils.truncate(d, Calendar.DATE));
existingTeammate.setStartDate(projectTeamMate.getStartDate()); billingDetails.setActive(false);
existingTeammate.setEndDate(projectTeamMate.getEndDate()); updateEmployeeBilling(billingDetails);
existingTeammate.setShift(projectTeamMate.getShift()); }
ProjectTeamMate teamMate = projectTeamMatesRepo.save(existingTeammate); BillingDetails billings = new BillingDetails();
EmployeeRoles employeeDB = employeeRolesRepo billings.setEmployeeId(projectTeamMate.getEmployeeId());
.findByEmployeeId(teamMate.getEmployeeId()); billings.setEmployeeName(projectTeamMate.getEmployeeName());
employeeDB.setShift(teamMate.getShift()); billings.setProjectId(projectTeamMate.getProjectId());
employeeRolesRepo.save(employeeDB); billings.setAccount(existingTeammate.getAccount());
return teamMate; billings.setProjectName(projectTeamMate.getProjectName());
} billings.setBillableStatus(projectTeamMate.getBillableStatus());
billings.setActive(true);
public void updateShiftDetails(ProjectTeamMate existingTeammate) { billings.setBillingStartDate(
Query getQuery = new Query(); DateUtils.truncate(projectTeamMate.getNewBillingStartDate(), Calendar.DATE));
getQuery.addCriteria(new Criteria().andOperator( billings.setBillingEndDate(DateUtils
Criteria.where("active").is(true), Criteria.where("employeeId") .truncate(projectTeamMate.getEndDate(), Calendar.DATE));
.is(existingTeammate.getEmployeeId()))); billings.setCreateDate(new Date());
Calendar cal = Calendar.getInstance(); addEmployeeBillingDetails(billings);
cal.add(Calendar.DATE, -1); // TODO
EmpShiftDetails existingShift = mongoTemplate.findOne(getQuery, }
EmpShiftDetails.class); existingTeammate.setBillableStatus(projectTeamMate.getBillableStatus());
if (existingShift != null) { existingTeammate.setStartDate(projectTeamMate.getStartDate());
existingShift.setActive(false); existingTeammate.setEndDate(projectTeamMate.getEndDate());
existingShift.setUpdatedDate(new Date()); existingTeammate.setShift(projectTeamMate.getShift());
mongoTemplate.save(existingShift); ProjectTeamMate teamMate = projectTeamMatesRepo.save(existingTeammate);
} EmployeeRoles employeeDB = employeeRolesRepo
} .findByEmployeeId(teamMate.getEmployeeId());
employeeDB.setShift(teamMate.getShift());
public void addShiftDetails(ProjectTeamMate projectTeamMate) { employeeRolesRepo.save(employeeDB);
EmpShiftDetails empShiftDetails = new EmpShiftDetails(); return teamMate;
empShiftDetails.setUpdatedDate(new Date()); }
empShiftDetails.setEmployeeName(projectTeamMate.getEmployeeName());
empShiftDetails.setEmployeeId(projectTeamMate.getEmployeeId()); public void updateShiftDetails(ProjectTeamMate existingTeammate) {
empShiftDetails.setShift(projectTeamMate.getShift()); Query getQuery = new Query();
empShiftDetails.setActive(true); getQuery.addCriteria(new Criteria().andOperator(
empShiftDetailsRepo.save(empShiftDetails); Criteria.where("active").is(true), Criteria.where("employeeId")
} .is(existingTeammate.getEmployeeId())));
Calendar cal = Calendar.getInstance();
@Override cal.add(Calendar.DATE, -1);
public void deleteTeammate(String empId, String projectId, ObjectId id) { EmpShiftDetails existingShift = mongoTemplate.findOne(getQuery,
ProjectTeamMate existingTeammate = projectTeamMatesRepo.findById(id); EmpShiftDetails.class);
existingTeammate.setActive(false); if (existingShift != null) {
existingTeammate.setEndDate(new Date()); existingShift.setActive(false);
BillingDetails billingDetails = new BillingDetails(); existingShift.setUpdatedDate(new Date());
billingDetails.setBillableStatus("Non-Billable"); mongoTemplate.save(existingShift);
billingDetails.setBillingStartDate(new Date()); }
billingDetails.setAccount("Nisum"); }
billingDetails.setActive(true);
billingDetails.setEmployeeId(existingTeammate.getEmployeeId()); public void addShiftDetails(ProjectTeamMate projectTeamMate) {
billingDetails.setEmployeeName(existingTeammate.getEmployeeName()); EmpShiftDetails empShiftDetails = new EmpShiftDetails();
billingDetails.setCreateDate(new Date()); empShiftDetails.setUpdatedDate(new Date());
billingDetails.setProjectId("Nisum0000"); empShiftDetails.setEmployeeName(projectTeamMate.getEmployeeName());
billingDetails.setProjectName("Free Pool"); empShiftDetails.setEmployeeId(projectTeamMate.getEmployeeId());
addEmployeeBillingDetails(billingDetails); empShiftDetails.setShift(projectTeamMate.getShift());
List<BillingDetails> listBD = getEmployeeActiveBillingDetails(empId, empShiftDetails.setActive(true);
projectId); empShiftDetailsRepo.save(empShiftDetails);
if (listBD != null && !listBD.isEmpty()) { }
BillingDetails billingDetailsExisting = listBD.get(0);
Date d = new Date(); @Override
d.setDate(d.getDate() - 1); public void deleteTeammate(String empId, String projectId, ObjectId id) {
billingDetailsExisting.setBillingEndDate(d); ProjectTeamMate existingTeammate = projectTeamMatesRepo.findById(id);
billingDetailsExisting.setActive(false); existingTeammate.setActive(false);
updateEmployeeBilling(billingDetailsExisting); existingTeammate.setEndDate(new Date());
} BillingDetails billingDetails = new BillingDetails();
projectTeamMatesRepo.save(existingTeammate); billingDetails.setBillableStatus("Non-Billable");
ProjectTeamMate newBenchAllocation = new ProjectTeamMate(); billingDetails.setBillingStartDate(new Date());
newBenchAllocation.setAccount("Nisum"); billingDetails.setAccount("Nisum");
newBenchAllocation.setBillableStatus("Non-Billable"); billingDetails.setActive(true);
newBenchAllocation.setDesignation(existingTeammate.getDesignation()); billingDetails.setEmployeeId(existingTeammate.getEmployeeId());
newBenchAllocation.setEmailId(existingTeammate.getEmailId()); billingDetails.setEmployeeName(existingTeammate.getEmployeeName());
newBenchAllocation.setEmployeeId(existingTeammate.getEmployeeId()); billingDetails.setCreateDate(new Date());
newBenchAllocation.setActive(true); billingDetails.setProjectId("Nisum0000");
newBenchAllocation.setEmployeeName(existingTeammate.getEmployeeName()); billingDetails.setProjectName("Free Pool");
newBenchAllocation.setProjectId("Nisum0000"); addEmployeeBillingDetails(billingDetails);
newBenchAllocation.setStartDate(new Date()); List<BillingDetails> listBD = getEmployeeActiveBillingDetails(empId,
Project p = projectRepo.findByProjectId("Nisum0000"); projectId);
newBenchAllocation.setProjectName(p.getProjectName()); if (listBD != null && !listBD.isEmpty()) {
// newBenchAllocation.setManagerId(p.getManagerId()); BillingDetails billingDetailsExisting = listBD.get(0);
//newBenchAllocation.setManagerName(p.getManagerName()); Date d = new Date();
projectTeamMatesRepo.save(newBenchAllocation); d.setDate(d.getDate() - 1);
updateShiftDetails(existingTeammate); billingDetailsExisting.setBillingEndDate(d);
} billingDetailsExisting.setActive(false);
updateEmployeeBilling(billingDetailsExisting);
@Override }
public List<Project> getProjects(String managerId) throws MyTimeException { projectTeamMatesRepo.save(existingTeammate);
Query query = new Query(Criteria.where("managerId").is(managerId) ProjectTeamMate newBenchAllocation = new ProjectTeamMate();
.and("status").ne("Completed")); newBenchAllocation.setAccount("Nisum");
return mongoTemplate.find(query, Project.class); newBenchAllocation.setBillableStatus("Non-Billable");
} newBenchAllocation.setDesignation(existingTeammate.getDesignation());
newBenchAllocation.setEmailId(existingTeammate.getEmailId());
@Override newBenchAllocation.setEmployeeId(existingTeammate.getEmployeeId());
public List<ProjectTeamMate> getMyTeamDetails(String empId) { newBenchAllocation.setActive(true);
List<ProjectTeamMate> teamMates = new ArrayList<>(); newBenchAllocation.setEmployeeName(existingTeammate.getEmployeeName());
List<ProjectTeamMate> empRecords = projectTeamMatesRepo newBenchAllocation.setProjectId("Nisum0000");
.findByEmployeeId(empId); newBenchAllocation.setStartDate(new Date());
for (ProjectTeamMate pt : empRecords) { Project p = projectRepo.findByProjectId("Nisum0000");
if (pt.isActive()) { newBenchAllocation.setProjectName(p.getProjectName());
teamMates.addAll(projectTeamMatesRepo // newBenchAllocation.setManagerId(p.getManagerId());
.findByProjectId(pt.getProjectId())); //newBenchAllocation.setManagerName(p.getManagerName());
} projectTeamMatesRepo.save(newBenchAllocation);
} updateShiftDetails(existingTeammate);
return teamMates; }
}
@Override
@Override public List<Project> getProjects(String managerId) throws MyTimeException {
public List<EmployeeRoles> getUnAssignedEmployees() { Query query = new Query(Criteria.where("managerId").is(managerId)
List<EmployeeRoles> allEmployees = employeeRolesRepo.findAll(); .and("status").ne("Completed"));
List<EmployeeRoles> notAssignedEmployees = new ArrayList<>(); return mongoTemplate.find(query, Project.class);
List<String> teamMates = new ArrayList<>(); }
List<ProjectTeamMate> empRecords = projectTeamMatesRepo.findAll();
for (ProjectTeamMate pt : empRecords) { @Override
Project project = projectRepo.findByProjectId(pt.getProjectId()); public List<ProjectTeamMate> getMyTeamDetails(String empId) {
if (project != null && project.getStatus() != null List<ProjectTeamMate> teamMates = new ArrayList<>();
&& !"Completed".equalsIgnoreCase(project.getStatus())) { List<ProjectTeamMate> empRecords = projectTeamMatesRepo
teamMates.add(pt.getEmployeeId()); .findByEmployeeId(empId);
} for (ProjectTeamMate pt : empRecords) {
} if (pt.isActive()) {
for (EmployeeRoles emp : allEmployees) { teamMates.addAll(projectTeamMatesRepo
.findByProjectId(pt.getProjectId()));
if (!teamMates.contains(emp.getEmployeeId())) { }
notAssignedEmployees.add(emp); }
} return teamMates;
} }
return notAssignedEmployees; @Override
} public List<EmployeeRoles> getUnAssignedEmployees() {
List<EmployeeRoles> allEmployees = employeeRolesRepo.findAll();
@Override List<EmployeeRoles> notAssignedEmployees = new ArrayList<>();
public List<ProjectTeamMate> getShiftDetails(String shift) { List<String> teamMates = new ArrayList<>();
List<Project> projects = projectRepo.findAll(); List<ProjectTeamMate> empRecords = projectTeamMatesRepo.findAll();
List<ProjectTeamMate> shiftEmpDetails = new ArrayList<>(); for (ProjectTeamMate pt : empRecords) {
for (Project pt : projects) { Project project = projectRepo.findByProjectId(pt.getProjectId());
if ("Active".equalsIgnoreCase(pt.getStatus())) { if (project != null && project.getStatus() != null
List<ProjectTeamMate> employeeDetails = projectTeamMatesRepo && !"Completed".equalsIgnoreCase(project.getStatus())) {
.findByProjectId(pt.getProjectId()); teamMates.add(pt.getEmployeeId());
for (ProjectTeamMate emp : employeeDetails) { }
if (emp.getShift() != null }
&& emp.getShift().equalsIgnoreCase(shift)) { for (EmployeeRoles emp : allEmployees) {
shiftEmpDetails.add(emp);
} else if (emp.getShift() == null if (!teamMates.contains(emp.getEmployeeId())) {
&& "Shift 1(09:00 AM - 06:00 PM)" notAssignedEmployees.add(emp);
.equalsIgnoreCase(shift)) }
shiftEmpDetails.add(emp); }
}
} return notAssignedEmployees;
} }
return shiftEmpDetails;
} @Override
public List<ProjectTeamMate> getShiftDetails(String shift) {
@Override List<Project> projects = projectRepo.findAll();
public List<ProjectTeamMate> getAllProjectDetails() { List<ProjectTeamMate> shiftEmpDetails = new ArrayList<>();
List<Project> projects = projectRepo.findAll(); for (Project pt : projects) {
List<ProjectTeamMate> allprojectMates = new ArrayList<>(); if ("Active".equalsIgnoreCase(pt.getStatus())) {
for (Project pt : projects) { List<ProjectTeamMate> employeeDetails = projectTeamMatesRepo
if (!"Completed".equalsIgnoreCase(pt.getStatus())) { .findByProjectId(pt.getProjectId());
List<ProjectTeamMate> employeeDetails = projectTeamMatesRepo for (ProjectTeamMate emp : employeeDetails) {
.findByProjectId(pt.getProjectId()); if (emp.getShift() != null
allprojectMates.addAll(employeeDetails); && emp.getShift().equalsIgnoreCase(shift)) {
} shiftEmpDetails.add(emp);
} else if (emp.getShift() == null
} && "Shift 1(09:00 AM - 06:00 PM)"
return allprojectMates; .equalsIgnoreCase(shift))
} shiftEmpDetails.add(emp);
}
@Override }
public List<ProjectTeamMate> getProjectDetails(String projectId) { }
//return projectTeamMatesRepo.findByProjectId(projectId); return shiftEmpDetails;
//MT-79: adding the existing managerIds in List and sending them as response }
List<ProjectTeamMate> teamMates=projectTeamMatesRepo.findByProjectId(projectId);
/* for(ProjectTeamMate pt:teamMates) @Override
{ public List<ProjectTeamMate> getAllProjectDetails() {
if(pt.getManagerIds()== null && pt.getManagerId()!= null) List<Project> projects = projectRepo.findAll();
pt.setManagerIds(Arrays.asList(pt.getManagerId())); List<ProjectTeamMate> allprojectMates = new ArrayList<>();
}*/ for (Project pt : projects) {
return teamMates; if (!"Completed".equalsIgnoreCase(pt.getStatus())) {
List<ProjectTeamMate> employeeDetails = projectTeamMatesRepo
} .findByProjectId(pt.getProjectId());
allprojectMates.addAll(employeeDetails);
@Override }
public List<ProjectTeamMate> getMyProjectAllocations(String empId) {
return projectTeamMatesRepo.findByEmployeeId(empId); }
} return allprojectMates;
}
@Override
public List<BillingDetails> getEmployeeBillingDetails(String empId, @Override
String projectId) { public List<ProjectTeamMate> getProjectDetails(String projectId) {
//return projectTeamMatesRepo.findByProjectId(projectId);
List<BillingDetails> billings = teamMatesBillingRepo //MT-79: adding the existing managerIds in List and sending them as response
.findByEmployeeIdAndProjectId(empId, projectId); List<ProjectTeamMate> teamMates=projectTeamMatesRepo.findByProjectId(projectId);
List<BillingDetails> billingsSorted = billings; /* for(ProjectTeamMate pt:teamMates)
try { {
billingsSorted = (billings == null || billings.size() == 0) if(pt.getManagerIds()== null && pt.getManagerId()!= null)
? billings pt.setManagerIds(Arrays.asList(pt.getManagerId()));
: billings.stream() }*/
.sorted(Comparator return teamMates;
.comparing(BillingDetails::getCreateDate)
.reversed()) }
.collect(Collectors.toList());
} catch (Exception e) { @Override
// TODO: handle exception public List<ProjectTeamMate> getMyProjectAllocations(String empId) {
} return projectTeamMatesRepo.findByEmployeeId(empId);
return billingsSorted; }
}
@Override
@Override public List<BillingDetails> getEmployeeBillingDetails(String empId,
public List<BillingDetails> getEmployeeBillingDetailsAll(String empId) { String projectId) {
List<BillingDetails> billings = teamMatesBillingRepo List<BillingDetails> billings = teamMatesBillingRepo
.findByEmployeeId(empId); .findByEmployeeIdAndProjectId(empId, projectId);
List<BillingDetails> billingsSorted = billings; List<BillingDetails> billingsSorted = billings;
try { try {
billingsSorted = (billings == null || billings.size() == 0) billingsSorted = (billings == null || billings.size() == 0)
? billings ? billings
: billings.stream() : billings.stream()
.sorted(Comparator .sorted(Comparator
.comparing(BillingDetails::getCreateDate) .comparing(BillingDetails::getCreateDate)
.reversed()) .reversed())
.collect(Collectors.toList()); .collect(Collectors.toList());
} catch (Exception e) { } catch (Exception e) {
// TODO: handle exception // TODO: handle exception
} }
return billingsSorted; return billingsSorted;
} }
@Override @Override
public List<BillingDetails> getEmployeeActiveBillingDetails(String empId, public List<BillingDetails> getEmployeeBillingDetailsAll(String empId) {
String projectId) {
Query query4 = new Query(); List<BillingDetails> billings = teamMatesBillingRepo
query4.addCriteria(Criteria.where("active").is(new Boolean(true))); .findByEmployeeId(empId);
query4.addCriteria(Criteria.where("employeeId").is(empId)); List<BillingDetails> billingsSorted = billings;
query4.addCriteria(Criteria.where("projectId").is(projectId)); try {
List<BillingDetails> billings = mongoTemplate.find(query4, billingsSorted = (billings == null || billings.size() == 0)
BillingDetails.class); ? billings
List<BillingDetails> billingsSorted = billings; : billings.stream()
try { .sorted(Comparator
billingsSorted = (billings == null || billings.size() == 0) .comparing(BillingDetails::getCreateDate)
? billings .reversed())
: billings.stream() .collect(Collectors.toList());
.sorted(Comparator } catch (Exception e) {
.comparing( // TODO: handle exception
BillingDetails::getBillingStartDate) }
.reversed()) return billingsSorted;
.collect(Collectors.toList()); }
} catch (Exception e) {
// TODO: handle exception @Override
} public List<BillingDetails> getEmployeeActiveBillingDetails(String empId,
return billingsSorted; String projectId) {
} Query query4 = new Query();
query4.addCriteria(Criteria.where("active").is(new Boolean(true)));
@Override query4.addCriteria(Criteria.where("employeeId").is(empId));
public List<BillingDetails> getEmployeeActiveNisumBench(String empId) { query4.addCriteria(Criteria.where("projectId").is(projectId));
Query query4 = new Query(); List<BillingDetails> billings = mongoTemplate.find(query4,
query4.addCriteria(Criteria.where("active").is(new Boolean(true))); BillingDetails.class);
query4.addCriteria(Criteria.where("projectId").is("Nisum0000")); List<BillingDetails> billingsSorted = billings;
query4.addCriteria(Criteria.where("employeeId").is(empId)); try {
List<BillingDetails> billings = mongoTemplate.find(query4, billingsSorted = (billings == null || billings.size() == 0)
BillingDetails.class); ? billings
List<BillingDetails> billingsSorted = billings; : billings.stream()
try { .sorted(Comparator
billingsSorted = (billings == null || billings.size() == 0) .comparing(
? billings BillingDetails::getBillingStartDate)
: billings.stream() .reversed())
.sorted(Comparator .collect(Collectors.toList());
.comparing( } catch (Exception e) {
BillingDetails::getBillingStartDate) // TODO: handle exception
.reversed()) }
.collect(Collectors.toList()); return billingsSorted;
} catch (Exception e) { }
// TODO: handle exception
} @Override
return billingsSorted; public List<BillingDetails> getEmployeeActiveNisumBench(String empId) {
} Query query4 = new Query();
query4.addCriteria(Criteria.where("active").is(new Boolean(true)));
@Override query4.addCriteria(Criteria.where("projectId").is("Nisum0000"));
public BillingDetails addEmployeeBillingDetails(BillingDetails teamMate) { query4.addCriteria(Criteria.where("employeeId").is(empId));
/* List<BillingDetails> billings = mongoTemplate.find(query4,
* List<BillingDetails> billingsPast = getEmployeeBillingDetails( BillingDetails.class);
* teamMate.getEmployeeId(), teamMate.getProjectId()); List<BillingDetails> billingsSorted = billings;
*/ /* try {
* for (BillingDetails tB : billingsPast) { tB.setActive(false); billingsSorted = (billings == null || billings.size() == 0)
* teamMatesBillingRepo.save(tB); } ? billings
*/ : billings.stream()
return teamMatesBillingRepo.save(teamMate); .sorted(Comparator
} .comparing(
BillingDetails::getBillingStartDate)
@Override .reversed())
public BillingDetails updateEmployeeBilling(BillingDetails teamMate) { .collect(Collectors.toList());
return teamMatesBillingRepo.save(teamMate); } catch (Exception e) {
} // TODO: handle exception
}
// Updating the projectenddate field in ProjectTeamMate . return billingsSorted;
private void updateProjectEndDateInProjectTeamMate(ProjectTeamMate projectTeamMate) { }
List<ProjectTeamMate> projectTeamMateList = mongoTemplate
.find(getQuery(projectTeamMate.getEmployeeId(), MyTimeUtils.ENDDATE_COLUMN), ProjectTeamMate.class); @Override
if (!CollectionUtils.isEmpty(projectTeamMateList)) { public BillingDetails addEmployeeBillingDetails(BillingDetails teamMate) {
for (ProjectTeamMate teamMate : projectTeamMateList) { /*
if (teamMate.getEndDate() != null * List<BillingDetails> billingsPast = getEmployeeBillingDetails(
&& !teamMate.getProjectName().equalsIgnoreCase(MyTimeUtils.FREE_POLL)) { * teamMate.getEmployeeId(), teamMate.getProjectId());
updateProjectEndDate(projectTeamMate.getNewBillingStartDate(), teamMate.getEmployeeId(), */ /*
teamMate.getProjectName(), MyTimeUtils.ENDDATE_COLUMN, * for (BillingDetails tB : billingsPast) { tB.setActive(false);
MyTimeUtils.TEAMDETAILS_COLLECTION_NAME); * teamMatesBillingRepo.save(tB); }
*/
} return teamMatesBillingRepo.save(teamMate);
} }
}
@Override
} public BillingDetails updateEmployeeBilling(BillingDetails teamMate) {
return teamMatesBillingRepo.save(teamMate);
// Updating the billingenddate in BillingDetails . }
private void updateProjectEndDateInBillingDetails(Date newBillingStartDate, BillingDetails billingDetails) {
List<BillingDetails> billingDetailsList = mongoTemplate // Updating the projectenddate field in ProjectTeamMate .
.find(getQuery(billingDetails.getEmployeeId(), MyTimeUtils.CREATED_DATE_COLUMN), BillingDetails.class); private void updateProjectEndDateInProjectTeamMate(ProjectTeamMate projectTeamMate) {
if (!CollectionUtils.isEmpty(billingDetailsList)) { List<ProjectTeamMate> projectTeamMateList = mongoTemplate
for (BillingDetails billing : billingDetailsList) { .find(getQuery(projectTeamMate.getEmployeeId(), MyTimeUtils.ENDDATE_COLUMN), ProjectTeamMate.class);
if (billing.getBillingEndDate() != null if (!CollectionUtils.isEmpty(projectTeamMateList)) {
&& !billing.getProjectName().equalsIgnoreCase(MyTimeUtils.FREE_POLL)) { for (ProjectTeamMate teamMate : projectTeamMateList) {
updateProjectEndDate(newBillingStartDate, billing.getEmployeeId(), billing.getProjectName(), if (teamMate.getEndDate() != null
MyTimeUtils.BILLING_ENDDATE_COLUMN, MyTimeUtils.BILLINGDETAILS_COLLECTION_NAME); && !teamMate.getProjectName().equalsIgnoreCase(MyTimeUtils.FREE_POLL)) {
} updateProjectEndDate(projectTeamMate.getNewBillingStartDate(), teamMate.getEmployeeId(),
teamMate.getProjectName(), MyTimeUtils.ENDDATE_COLUMN,
} MyTimeUtils.TEAMDETAILS_COLLECTION_NAME);
}
} }
}
// Updating the projectenddate }
private void updateProjectEndDate(Date newBillingStartDate, String employeeId, String projectName,
String dateColumn, String collectionName) { }
DBCollection collection = mongoTemplate.getCollection(collectionName);
BasicDBObject searchQuery = new BasicDBObject(); // Updating the billingenddate in BillingDetails .
searchQuery.append(MyTimeUtils.EMPLOYEE_ID, employeeId); private void updateProjectEndDateInBillingDetails(Date newBillingStartDate, BillingDetails billingDetails) {
searchQuery.append(MyTimeUtils.PROJECT_NAME, projectName); List<BillingDetails> billingDetailsList = mongoTemplate
BasicDBObject updateQuery = new BasicDBObject(); .find(getQuery(billingDetails.getEmployeeId(), MyTimeUtils.CREATED_DATE_COLUMN), BillingDetails.class);
updateQuery.append(MyTimeUtils.SET, if (!CollectionUtils.isEmpty(billingDetailsList)) {
new BasicDBObject().append(dateColumn, DateUtils.addDays(newBillingStartDate, MyTimeUtils.MINUS_ONE))); for (BillingDetails billing : billingDetailsList) {
collection.update(searchQuery, updateQuery); if (billing.getBillingEndDate() != null
} && !billing.getProjectName().equalsIgnoreCase(MyTimeUtils.FREE_POLL)) {
updateProjectEndDate(newBillingStartDate, billing.getEmployeeId(), billing.getProjectName(),
private Query getQuery(String employeeId, String dateColumn) { MyTimeUtils.BILLING_ENDDATE_COLUMN, MyTimeUtils.BILLINGDETAILS_COLLECTION_NAME);
Query query = new Query(); }
query.addCriteria(Criteria.where(MyTimeUtils.EMPLOYEE_ID).is(employeeId));
query.limit(MyTimeUtils.ONE); }
query.with(new Sort(Sort.Direction.DESC, dateColumn)); }
return query; }
}
// Updating the projectenddate
@Override private void updateProjectEndDate(Date newBillingStartDate, String employeeId, String projectName,
public void deleteEmployeeBilling(BillingDetails teamMate) { String dateColumn, String collectionName) {
// TODO Auto-generated method stub DBCollection collection = mongoTemplate.getCollection(collectionName);
teamMatesBillingRepo.delete(teamMate); BasicDBObject searchQuery = new BasicDBObject();
} searchQuery.append(MyTimeUtils.EMPLOYEE_ID, employeeId);
searchQuery.append(MyTimeUtils.PROJECT_NAME, projectName);
@Override BasicDBObject updateQuery = new BasicDBObject();
public List<EmployeeDashboardVO> getEmployeesDashBoard() { updateQuery.append(MyTimeUtils.SET,
List<EmployeeRoles> allEmployees = employeeRolesRepo.findAll(); new BasicDBObject().append(dateColumn, DateUtils.addDays(newBillingStartDate, MyTimeUtils.MINUS_ONE)));
List<EmployeeRoles> notAssignedEmployees = new ArrayList<>(); collection.update(searchQuery, updateQuery);
List<EmployeeDashboardVO> employeeDashboard = new ArrayList<>(); }
Map<String, Object> teamMatesMap = new HashMap();
Map<String, Object> teamMatesStatusMap = new HashMap(); private Query getQuery(String employeeId, String dateColumn) {
Query query = new Query();
List<ProjectTeamMate> empRecords = projectTeamMatesRepo.findAll(); // find query.addCriteria(Criteria.where(MyTimeUtils.EMPLOYEE_ID).is(employeeId));
// all query.limit(MyTimeUtils.ONE);
// active query.with(new Sort(Sort.Direction.DESC, dateColumn));
// employees return query;
for (ProjectTeamMate pt : empRecords) { }
if (pt.isActive()) {
Project project = projectRepo @Override
.findByProjectId(pt.getProjectId()); public void deleteEmployeeBilling(BillingDetails teamMate) {
if (project != null && project.getStatus() != null // TODO Auto-generated method stub
&& !"Completed".equalsIgnoreCase(project.getStatus())) { teamMatesBillingRepo.delete(teamMate);
Object projectTeamMate = teamMatesMap }
.get(pt.getEmployeeId());
@Override
if (projectTeamMate == null) { public List<EmployeeDashboardVO> getEmployeesDashBoard() {
List listOfObjects = new ArrayList<>(); List<EmployeeRoles> allEmployees = employeeRolesRepo.findAll();
listOfObjects.add(pt); List<EmployeeRoles> notAssignedEmployees = new ArrayList<>();
teamMatesMap.put(pt.getEmployeeId(), listOfObjects);// TODO List<EmployeeDashboardVO> employeeDashboard = new ArrayList<>();
// a Map<String, Object> teamMatesMap = new HashMap();
// person Map<String, Object> teamMatesStatusMap = new HashMap();
// can
// have List<ProjectTeamMate> empRecords = projectTeamMatesRepo.findAll(); // find
// multiple // all
// active // active
// projects // employees
// with for (ProjectTeamMate pt : empRecords) {
// billability if (pt.isActive()) {
} else { Project project = projectRepo
List existingRecordsInMap = (List) teamMatesMap .findByProjectId(pt.getProjectId());
.get(pt.getEmployeeId()); if (project != null && project.getStatus() != null
existingRecordsInMap.add(pt); && !"Completed".equalsIgnoreCase(project.getStatus())) {
teamMatesMap.put(pt.getEmployeeId(), Object projectTeamMate = teamMatesMap
existingRecordsInMap); .get(pt.getEmployeeId());
} if (projectTeamMate == null) {
} List listOfObjects = new ArrayList<>();
} listOfObjects.add(pt);
} teamMatesMap.put(pt.getEmployeeId(), listOfObjects);// TODO
for (EmployeeRoles emp : allEmployees) { // a
if (emp.getEmployeeId() != null // person
&& emp.getEmployeeId().equalsIgnoreCase("16112")) { // can
System.out.println(emp); // have
} // multiple
// active
if (teamMatesMap.containsKey(emp.getEmployeeId())) { // projects
System.out.println("***************** Empl alrady assigned"); // with
Object value = teamMatesMap.get(emp.getEmployeeId()); // billability
if (value instanceof List) { } else {
List listOfTeamMates = (List) value; List existingRecordsInMap = (List) teamMatesMap
String billableStatus = "NA"; .get(pt.getEmployeeId());
existingRecordsInMap.add(pt);
for (Object obj : listOfTeamMates) { teamMatesMap.put(pt.getEmployeeId(),
ProjectTeamMate projectTeamMate = (ProjectTeamMate) obj; existingRecordsInMap);
String status = projectTeamMate.getBillableStatus();
if (status == null) { }
status = "NA"; }
} }
System.out.println("---------------------------"); }
EmployeeDashboardVO empVo = new EmployeeDashboardVO(); for (EmployeeRoles emp : allEmployees) {
if (emp.getEmployeeId() != null
System.out.println(emp); && emp.getEmployeeId().equalsIgnoreCase("16112")) {
BeanUtils.copyProperties(emp, empVo); System.out.println(emp);
BeanUtils.copyProperties(projectTeamMate, empVo, }
"employeeId", "employeeName", "emailId", "role",
"designation", "mobileNumber"); if (teamMatesMap.containsKey(emp.getEmployeeId())) {
System.out.println("***************** Empl alrady assigned");
employeeDashboard.add(empVo); Object value = teamMatesMap.get(emp.getEmployeeId());
} if (value instanceof List) {
List listOfTeamMates = (List) value;
} String billableStatus = "NA";
} else {
EmployeeDashboardVO empVo = new EmployeeDashboardVO(); for (Object obj : listOfTeamMates) {
ProjectTeamMate projectTeamMate = (ProjectTeamMate) obj;
System.out.println(emp); String status = projectTeamMate.getBillableStatus();
BeanUtils.copyProperties(emp, empVo); if (status == null) {
empVo.setBillableStatus("UA"); status = "NA";
empVo.setProjectAssigned(false); }
employeeDashboard.add(empVo); System.out.println("---------------------------");
} EmployeeDashboardVO empVo = new EmployeeDashboardVO();
System.out.println("&&&&&&&&&&");
// System.out.println(empVo); System.out.println(emp);
BeanUtils.copyProperties(emp, empVo);
System.out.println("---------------------------"); BeanUtils.copyProperties(projectTeamMate, empVo,
"employeeId", "employeeName", "emailId", "role",
} "designation", "mobileNumber");
return employeeDashboard; employeeDashboard.add(empVo);
} }
@Override }
public List<ProjectTeamMate> findByAccountAndActiveAndBillableStatus( } else {
String account, boolean status, String billableStatus) { EmployeeDashboardVO empVo = new EmployeeDashboardVO();
return projectTeamMatesRepo.findByAccountAndActiveAndBillableStatus(
account, status, billableStatus); System.out.println(emp);
} BeanUtils.copyProperties(emp, empVo);
empVo.setBillableStatus("UA");
public List<HashMap<String, String>> getEmployeeData(List<String> ids) { empVo.setProjectAssigned(false);
List<HashMap<String, String>> EmployeeList = new ArrayList<>(); employeeDashboard.add(empVo);
}
Query query = new Query(Criteria.where("employeeId").in(ids)); System.out.println("&&&&&&&&&&");
List<EmployeeRoles> employeeRoles = mongoTemplate.find(query, EmployeeRoles.class); // System.out.println(empVo);
for (EmployeeRoles employeesRole : employeeRoles) {
HashMap<String, String> managerMap = new HashMap<>(); System.out.println("---------------------------");
managerMap.put("employeeId", employeesRole.getEmployeeId());
managerMap.put("employeeName", employeesRole.getEmployeeName()); }
EmployeeList.add(managerMap);
} return employeeDashboard;
return EmployeeList; }
}
} @Override
public List<ProjectTeamMate> findByAccountAndActiveAndBillableStatus(
String account, boolean status, String billableStatus) {
return projectTeamMatesRepo.findByAccountAndActiveAndBillableStatus(
account, status, billableStatus);
}
public List<HashMap<String, String>> getEmployeeData(List<String> ids) {
List<HashMap<String, String>> EmployeeList = new ArrayList<>();
Query query = new Query(Criteria.where("employeeId").in(ids));
List<EmployeeRoles> employeeRoles = mongoTemplate.find(query, EmployeeRoles.class);
for (EmployeeRoles employeesRole : employeeRoles) {
HashMap<String, String> managerMap = new HashMap<>();
managerMap.put("employeeId", employeesRole.getEmployeeId());
managerMap.put("employeeName", employeesRole.getEmployeeName());
EmployeeList.add(managerMap);
}
return EmployeeList;
}
}
src/main/webapp/WEB-INF/controllers/ProjectController.js
View file @ e09a1938
...@@ -37,7 +37,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -37,7 +37,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
{ field: 'projectName', displayName: 'Project ', enableColumnMenu: false, enableSorting: true, enableFiltering: true }, { field: 'projectName', displayName: 'Project ', enableColumnMenu: false, enableSorting: true, enableFiltering: true },
{ field: 'account', displayName: 'Account ', enableColumnMenu: false, enableSorting: true, enableFiltering: true }, { field: 'account', displayName: 'Account ', enableColumnMenu: false, enableSorting: true, enableFiltering: true },
//{field : 'managerId',displayName: 'Manager ID ', enableColumnMenu: false, enableSorting: false}, //{field : 'managerId',displayName: 'Manager ID ', enableColumnMenu: false, enableSorting: false},
{ field: 'managerIds', displayName: 'Manager Name ', cellTemplate: '<div ng-repeat= "item in row.entity[col.field]">{{item.employeeName}}<span ng-hide="$last">,</span></div>', enableColumnMenu: false, enableSorting: true, enableFiltering: true }, { field: 'managerIds', displayName: 'Delivery Lead / Lead ', cellTemplate: '<div ng-repeat= "item in row.entity[col.field]">{{item.employeeName}}<span ng-hide="$last">,</span></div>', enableColumnMenu: false, enableSorting: true, enableFiltering: true },
{ field: 'status', displayName: 'Status ', enableColumnMenu: false, enableSorting: true, enableFiltering: false }, { field: 'status', displayName: 'Status ', enableColumnMenu: false, enableSorting: true, enableFiltering: false },
{ name: 'Actions', displayName: 'Actions', cellTemplate: getCellTemplate, enableColumnMenu: false, enableSorting: false, enableFiltering: false, width: 130 } { name: 'Actions', displayName: 'Actions', cellTemplate: getCellTemplate, enableColumnMenu: false, enableSorting: false, enableFiltering: false, width: 130 }
] ]
...@@ -54,6 +54,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -54,6 +54,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
$scope.parentData.status = row.entity.status; $scope.parentData.status = row.entity.status;
$scope.parentData.accountId = row.entity.accountId; $scope.parentData.accountId = row.entity.accountId;
$scope.parentData.domainId = row.entity.domainId; $scope.parentData.domainId = row.entity.domainId;
$scope.parentData.deliveryLeadIds = row.entity.deliveryLeadIds;
if (action == "Update") if (action == "Update")
$scope.addProject(action, $scope.parentData); $scope.addProject(action, $scope.parentData);
else if (action == "Delete") else if (action == "Delete")
...@@ -67,7 +68,10 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -67,7 +68,10 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
$scope.getProjects(); $scope.getProjects();
$scope.getManagerDetails(); $scope.getManagerDetails();
} }
getLeads = function(){
}
$scope.getProjects = function () { $scope.getProjects = function () {
$http({ $http({
method: "GET", method: "GET",
...@@ -273,7 +277,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -273,7 +277,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
$scope.billableStatuses = ["Billable","Shadow","Non-Billable","Reserved"]; $scope.billableStatuses = ["Billable","Shadow","Non-Billable","Reserved"];
$scope.accounts=myFactory.getAccounts(); $scope.accounts=myFactory.getAccounts();
$scope.selectedTab = 0; $scope.selectedTab = 0;
$scope.managersSelectedList = []; $scope.deliveryLeadsSelectedList = [];
$scope.employeeInTeam = []; $scope.employeeInTeam = [];
$scope.employeeRoles = ["Lead","Employee"]; $scope.employeeRoles = ["Lead","Employee"];
$scope.accountId = dataToPass.accountId; $scope.accountId = dataToPass.accountId;
...@@ -331,7 +335,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -331,7 +335,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
// code added // code added
$scope.clearSearchTerm = function () { $scope.clearSearchTerm = function () {
console.log($scope.managersSelectedList); console.log($scope.deliveryLeadsSelectedList);
// $("#lead .lead-search .md-select-value span .md-text").css({ // $("#lead .lead-search .md-select-value span .md-text").css({
//  'border': '1px solid #000', //  'border': '1px solid #000',
...@@ -341,24 +345,24 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -341,24 +345,24 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
} }
// $scope.removeSelectedLead = function (item) { // $scope.removeSelectedLead = function (item) {
// var index = $scope.managersSelectedList.indexOf(item); // var index = $scope.deliveryLeadsSelectedList.indexOf(item);
// $scope.managersSelectedList.splice(index, 1); // $scope.deliveryLeadsSelectedList.splice(index, 1);
// } // }
$scope.closeSelectBox = function () { $scope.closeSelectBox = function () {
$mdSelect.hide(); $mdSelect.hide();
} }
getSelectedLead = function () { getSelectedDeliveryLeadIds = function () {
var managerIds = []; var deliveryLeadIds = [];
if($scope.managersSelectedList.name){ if($scope.deliveryLeadsSelectedList.name){
managerIds.push($scope.managersSelectedList.id) managerIds.push($scope.deliveryLeadsSelectedList.id)
} }
else{ else{
managerIds.push($scope.managersSelectedList.employeeId) deliveryLeadIds.push($scope.deliveryLeadsSelectedList.employeeId)
} }
return managerIds; return deliveryLeadIds;
} }
...@@ -395,8 +399,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -395,8 +399,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
} }
console.log(dataToPass.managerIds[0]); $scope.deliveryLeadsSelectedList = dataToPass.deliveryLeadIds[0];
$scope.managersSelectedList = dataToPass.managerIds[0];
$scope.domain = {"domainName":dataToPass.domain,"domainId":dataToPass.domainId}; $scope.domain = {"domainName":dataToPass.domain,"domainId":dataToPass.domainId};
$scope.projectStatus = dataToPass.status; $scope.projectStatus = dataToPass.status;
$scope.managerModel = { $scope.managerModel = {
...@@ -582,37 +585,30 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -582,37 +585,30 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
$scope.getAccountText = function () { $scope.getAccountText = function () {
if ($scope.account !== undefined) { if ($scope.account !== undefined) {
getDomainsAssoicatedToAccount($scope.account.accountId);
return $scope.account.accountName; return $scope.account.accountName;
} else { } else {
return "Please select account"; return "Please select account";
} }
}; };
$scope.onAccountChange = function(){
if($scope.account.accountId){
getDomainsAssoicatedToAccount($scope.account.accountId);
}
};
$scope.getDomainText = function () { $scope.getDomainText = function () {
console.log($scope.domain,$scope.domains); if($scope.domain != undefined){
if ($scope.domain !== undefined) {
if($scope.domain.domainId != undefined){
getManagersAssociatedToDomain($scope.domain.domainId);
}
else{
$scope.managerDetails = managers;
}
return $scope.domain.domainName; return $scope.domain.domainName;
} else {
return "Please select domain";
}
};
$scope.onDomainChange = function(){
if($scope.domain.domainId !== undefined){
getManagersAssociatedToDomain($scope.domain.domainId);
} }
else{ else{
$scope.managerDetails = managers; $scope.managerDetails = managers;
} return "Please select domain";
}
} };
function getManagersAssociatedToDomain(id){ function getManagersAssociatedToDomain(id){
$http({ $http({
method : "GET", method : "GET",
...@@ -679,11 +675,11 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -679,11 +675,11 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
} }
return false; return false;
} }
$scope.getSelectedManager = function () { $scope.getSelectedDeliveryLead = function () {
if (Object.keys($scope.managersSelectedList).length > 0) { if (Object.keys($scope.deliveryLeadsSelectedList).length > 0) {
return $scope.managersSelectedList.employeeName; return $scope.deliveryLeadsSelectedList.employeeName;
} else { } else {
return "Please select a lead"; return "Please select a Delivery lead";
} }
} }
...@@ -771,7 +767,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS ...@@ -771,7 +767,7 @@ myApp.controller("projectController", function ($scope, myFactory, exportUiGridS
else { else {
$scope.alertMsg = ""; $scope.alertMsg = "";
console.log($scope.projectStatus,$scope.domain.domainId); console.log($scope.projectStatus,$scope.domain.domainId);
var record = { "projectId": $scope.projectId, "projectName": $scope.projectName,"account": $scope.account.accountName, "domain": $scope.domain.domainName, "accountId":$scope.account.accountId, "domainId": $scope.domain.domainId, "managerIds": getSelectedLead(), "status": $scope.projectStatus}; var record = { "projectId": $scope.projectId, "projectName": $scope.projectName,"account": $scope.account.accountName, "domain": $scope.domain.domainName, "accountId":$scope.account.accountId, "domainId": $scope.domain.domainId, "managerIds": [], "deliveryLeadIds":getSelectedDeliveryLeadIds(), "status": $scope.projectStatus};
console.log(record); console.log(record);
addOrUpdateProject(record, $scope.templateTitle); addOrUpdateProject(record, $scope.templateTitle);
$timeout(function () { updateGrid($scope.templateTitle, record) }, 500); $timeout(function () { updateGrid($scope.templateTitle, record) }, 500);
......
src/main/webapp/WEB-INF/templates/newProject.html
View file @ e09a1938
...@@ -37,7 +37,7 @@ ...@@ -37,7 +37,7 @@
<b>Account</b> <b>Account</b>
</td> </td>
<td colspan="8"> <td colspan="8">
<md-select ng-model="account" md-selected-text="getAccountText()" ng-change="onAccountChange()" id="account"> <md-select ng-model="account" md-selected-text="getAccountText()" id="account">
<md-optgroup label="account"> <md-optgroup label="account">
<md-option ng-value="account1" ng-repeat="account1 in accounts">{{account1.accountName}}</md-option> <md-option ng-value="account1" ng-repeat="account1 in accounts">{{account1.accountName}}</md-option>
</md-optgroup> </md-optgroup>
...@@ -50,7 +50,7 @@ ...@@ -50,7 +50,7 @@
<b>Domain</b> <b>Domain</b>
</td> </td>
<td colspan="8"> <td colspan="8">
<md-select ng-model="domain" md-selected-text="getDomainText()" ng-change="onDomainChange()" id="domain"> <md-select ng-model="domain" md-selected-text="getDomainText()" id="domain">
<md-optgroup label="domain"> <md-optgroup label="domain">
<md-option ng-value="domain" ng-repeat="domain in domains">{{domain.domainName}}</md-option> <md-option ng-value="domain" ng-repeat="domain in domains">{{domain.domainName}}</md-option>
</md-optgroup> </md-optgroup>
...@@ -59,11 +59,11 @@ ...@@ -59,11 +59,11 @@
</tr> </tr>
<tr> <tr>
<td colspan="4"> <td colspan="4">
<b>Lead</b> <b>Delivery Lead</b>
</td> </td>
<td colspan="8"> <td colspan="8">
<div style="display: block; float: left; width: 100%;"> <div style="display: block; float: left; width: 100%;">
<md-select ng-model="managersSelectedList" data-md-container-class="selectHeader" md-selected-text="getSelectedManager()" > <md-select ng-model="deliveryLeadsSelectedList" data-md-container-class="selectHeader" md-selected-text="getSelectedDeliveryLead()" >
<md-select-header class="selectHeaderChild header-spacing" layout="column"> <md-select-header class="selectHeaderChild header-spacing" layout="column">
<input ng-model="searchTerm" type="search" ng-keydown="updateSearch($event)" ng-model-options="{debounce: {'default': 500, 'blur': 0}}" <input ng-model="searchTerm" type="search" ng-keydown="updateSearch($event)" ng-model-options="{debounce: {'default': 500, 'blur': 0}}"
placeholder="Please Search for a lead" class="searchBoxHeader demo-header-searchbox md-text search-spacingleft" /> placeholder="Please Search for a lead" class="searchBoxHeader demo-header-searchbox md-text search-spacingleft" />
......
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