public async Task <IActionResult> AssignProject()
{
var projectx = new EmployeeProjectModel();
var projects = _context.Projects;
var projectss = _context.Employees;
foreach (var projectxx in projectss)
{
projectx.EmpoyeeList.Add(new SelectListItem()
{
Value = projectxx.EmployeeId.ToString(),
Text = projectxx.LastName
}
);;
}
foreach (var projx in projects)
{
projectx.ProjectList.Add(new SelectListItem()
{
Value = projx.ProjectId.ToString(),
Text = projx.ProjectName
}
);;
}
return(View(projectx));
}
public async Task <IActionResult> Edit(int ProjectID, string EmployeeID, EmployeeProjectModel employeeProjectModel)
{
if (ProjectID != employeeProjectModel.ProjectID || EmployeeID != employeeProjectModel.EmployeeID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employeeProjectModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeProjectModelExists(employeeProjectModel.ProjectID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(employeeProjectModel));
}
public IActionResult Assign(string employeeId)
{
if (ModelState.IsValid)
{
var projects = projectDataService.GetAllProjects(userManager.GetUserAsync(this.User).Result.CompanyId);
var model = new AssignViewModel()
{
EmployeeId = employeeId,
AllProjects = projects.Select(p => new ProjectViewModel
{
Id = projectDataService.FindProjectById(p.ProjectId).Id,
Name = projectDataService.FindProjectById(p.ProjectId).Name,
Description = projectDataService.FindProjectById(p.ProjectId).Description,
StartDate = projectDataService.FindProjectById(p.ProjectId).StartDate,
EndDate = projectDataService.FindProjectById(p.ProjectId).EndDate
})
};
return(View(model));
}
var model1 = new EmployeeProjectModel {
employeeId = employeeId
};
return(RedirectToAction("Assign", "Project", model1));
}
public async Task <IActionResult> Create(EmployeeProjectModel employeeProjectModel)
{
if (ModelState.IsValid)
{
_context.Add(employeeProjectModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(employeeProjectModel));
}
public async Task <IActionResult> Get()
{
var empid = _identityService.GetIdentity().EmpId;
var name = _identityService.GetIdentity().FullName;
EmployeeProjectModel result = _empProjectService.GetEmpProjectDetail(empid);
result.EmployeeName = name;
var model = await Task.Run(() => result);
if (model == null)
{
return(NotFound());
}
return(Ok(model));
}
public IActionResult AssignTo(int projectId, string employeeId)
{
if (ModelState.IsValid)
{
if (projectDataService.IsEmployeeInProject(employeeId, projectId))
{
ModelState.AddModelError("EmployeeId", "This employee is already in this project");
var model = new EmployeeProjectModel {
employeeId = employeeId
};
return(RedirectToAction("Assign", "Project", model));
}
projectDataService.Assign(employeeId, projectId);
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Assign", "Project"));
}
public async Task <ProjectMonthlyModel> GetMonthly(int year, int month)
{
ProjectMonthlyModel pmm = new ProjectMonthlyModel();
var source = (await _unit.Details.Get(d => d.Day.Date.Year == year && d.Day.Date.Month == month)).ToList();
var tasks = source.OrderBy(x => x.Day.Employee.Id)
.ThenBy(x => x.Project.Id)
.ToList();
pmm.Projects = tasks.GroupBy(p => new { p.Project.Id, p.Project.Name })
.Select(p => new MasterModel {
Id = p.Key.Id, Name = p.Key.Name
})
.ToList();
List <int> pList = pmm.Projects.Select(p => p.Id).ToList();
var details = tasks.GroupBy(x => new {
empId = x.Day.Employee.Id,
empName = x.Day.Employee.FullName,
projId = x.Project.Id,
projName = x.Project.Name
}).Select(y => new
{
employee = new MasterModel {
Id = y.Key.empId, Name = y.Key.empName
},
project = new MasterModel {
Id = y.Key.projId, Name = y.Key.projName
},
hours = y.Sum(h => h.Hours)
}).ToList();
EmployeeProjectModel epm = new EmployeeProjectModel(pList)
{
Employee = new MasterModel {
Id = 0
}
};
foreach (var item in details)
{
if (epm.Employee.Id != item.employee.Id)
{
if (epm.Employee.Id != 0)
{
pmm.Employees.Add(epm);
}
epm = new EmployeeProjectModel(pList)
{
Employee = item.employee
};
}
epm.Hours[item.project.Id] += item.hours;
epm.TotalHours += item.hours;
}
if (epm.Employee.Id != 0)
{
pmm.Employees.Add(epm);
}
return(pmm);
}
public async Task <ProjectMonthlyModel> GetStored(int year, int month)
{
ProjectMonthlyModel pmm = new ProjectMonthlyModel();
List <ProjectRawModel> rawData = new List <ProjectRawModel>();
var cmd = _unit.Context.Database.GetDbConnection().CreateCommand();
if (Startup.Configuration["Connection:Type"] == "SQL")
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = $"MonthlyReport";
cmd.Parameters.Add(new SqlParameter {
ParameterName = "year", Value = year
});
cmd.Parameters.Add(new SqlParameter {
ParameterName = "month", Value = month
});
}
else
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = $"select * from MonthlylReport({year}, {month})";
}
if (cmd.Connection.State == ConnectionState.Closed)
{
cmd.Connection.Open();
}
DbDataReader sql = await cmd.ExecuteReaderAsync();
if (sql.HasRows)
{
while (sql.Read())
{
rawData.Add(new ProjectRawModel
{
EmpId = sql.GetInt32(0),
FirstName = sql.GetString(1),
LastName = sql.GetString(2),
ProjId = sql.GetInt32(3),
ProjName = sql.GetString(4),
Hours = sql.GetDecimal(5)
});
}
pmm.Projects = rawData.GroupBy(p => new { p.ProjId, p.ProjName })
.OrderBy(p => p.Key.ProjId)
.Select(p => new MasterModel {
Id = p.Key.ProjId, Name = p.Key.ProjName
})
.ToList();
List <int> pList = pmm.Projects.Select(p => p.Id).ToList();
EmployeeProjectModel epm = new EmployeeProjectModel(pList)
{
Employee = new MasterModel {
Id = 0
}
};
foreach (var item in rawData)
{
if (epm.Employee.Id != item.EmpId)
{
if (epm.Employee.Id != 0)
{
pmm.Employees.Add(epm);
}
epm = new EmployeeProjectModel(pList)
{
Employee = new MasterModel {
Id = item.EmpId, Name = item.FirstName + " " + item.LastName
}
};
}
epm.Hours[item.ProjId] += item.Hours;
epm.TotalHours += item.Hours;
}
if (epm.Employee.Id != 0)
{
pmm.Employees.Add(epm);
}
}
return(pmm);
}
public MonthlyTimeModel GetStored(int year, int month)
{
MonthlyTimeModel result = new MonthlyTimeModel();
var cmd = _unit.Context.Database.GetDbConnection().CreateCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = $"select * from MonthlyReport({year},{month})";
if (cmd.Connection.State == ConnectionState.Closed)
{
cmd.Connection.Open();
}
DbDataReader sql = cmd.ExecuteReader();
List <MonthlyRawData> rawData = new List <MonthlyRawData>();
if (sql.HasRows)
{
while (sql.Read())
{
rawData.Add(new MonthlyRawData
{
EmpId = sql.GetInt32(0),
EmpName = sql.GetString(1),
ProjId = sql.GetInt32(2),
ProjName = sql.GetString(3),
Hours = sql.GetDecimal(4)
});
}
result.Projects = rawData.GroupBy(x => new { x.ProjId, x.ProjName })
.Select(x => new MasterModel {
Id = x.Key.ProjId, Name = x.Key.ProjName
}).ToList();
List <int> projList = result.Projects.Select(x => x.Id).ToList();
EmployeeProjectModel total = new EmployeeProjectModel(projList)
{
Employee = new MasterModel {
Id = 0, Name = "TOTAL"
}
};
total.TotalHours = 0;
EmployeeProjectModel epm = new EmployeeProjectModel(projList)
{
Employee = new MasterModel {
Id = 0
}
};
foreach (MonthlyRawData item in rawData)
{
//is it new employee?
if (item.EmpId != epm.Employee.Id)
{
if (epm.Employee.Id != 0)
{
result.Employees.Add(epm);
}
epm = new EmployeeProjectModel(projList)
{
Employee = new MasterModel {
Id = item.EmpId, Name = item.EmpName
}
};
}
epm.Hours[item.ProjId] = item.Hours;
epm.TotalHours += item.Hours;
total.Hours[item.ProjId] += item.Hours;
total.TotalHours += item.Hours;
}
if (epm.Employee.Id != 0)
{
result.Employees.Add(epm);
}
result.Employees.Add(total);
}
return(result);
}
