/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="condition"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <Project> SearchProjectAsync(SearchProjectViewModel condition,
CancellationToken cancellationToken = default(CancellationToken))
{
var project = await GetProjects(condition).FirstOrDefaultAsync(cancellationToken);
return(project);
}
public async Task <IHttpActionResult> SearchProjects([FromBody] SearchProjectViewModel model)
{
model = model ?? new SearchProjectViewModel();
Validate(model);
var projects = await _projectDomain.SearchProjectAsync(model);
return(Ok(projects));
}
public async Task <IHttpActionResult> Search([FromBody] SearchProjectViewModel condition)
{
if (condition == null)
{
condition = new SearchProjectViewModel();
Validate(condition);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var loadProjectsResult = await _projectService.SearchProjectsAsync(condition, CancellationToken.None);
return(Ok(loadProjectsResult));
}
/// <summary>
/// Get projects by using specific conditions.
/// </summary>
/// <param name="condition"></param>
/// <returns></returns>
protected virtual IQueryable <Project> GetProjects(SearchProjectViewModel condition)
{
var projects = _unitOfWork.Projects.Search();
if (condition.Ids != null)
{
var ids = condition.Ids.Where(x => x > 0).ToList();
if (ids.Count > 0)
{
projects = projects.Where(x => ids.Contains(x.Id));
}
}
if (condition.Names != null)
{
var names = condition.Names.Where(c => !string.IsNullOrEmpty(c)).ToList();
if (names.Count > 0)
{
projects = projects.Where(c => condition.Names.Contains(c.Name));
}
}
if (condition.UserIds != null)
{
var userIds = condition.UserIds.Where(c => c > 0).ToList();
if (userIds.Count > 0)
{
projects = projects.Where(c => condition.UserIds.Contains(c.UserId));
}
}
if (condition.StartedTime != null)
{
projects = projects.Where(c => c.StartedTime >= condition.StartedTime.From &&
c.StartedTime <= condition.StartedTime.To);
}
if (condition.FinishedTime != null)
{
projects = projects.Where(c => c.FinishedTime >= condition.FinishedTime.From &&
c.FinishedTime <= condition.FinishedTime.To);
}
return(projects);
}
public ActionResult SearchProject()
{
if (Session["username"] == null || Session["username"].Equals(""))
{
return(RedirectToAction("Index", "Session"));
}
SearchProjectViewModel vm = new SearchProjectViewModel();
vm.Data = new DataTable();
vm.Data.Columns.Add(new DataColumn("ID", typeof(string)));
vm.Data.Columns.Add(new DataColumn("Name", typeof(string)));
vm.Data.Columns.Add(new DataColumn("Area", typeof(string)));
vm.Data.Columns.Add(new DataColumn("PartyA", typeof(string)));
vm.Data.Columns.Add(new DataColumn("PartyB", typeof(string)));
vm.Data.Columns.Add(new DataColumn("Money", typeof(string)));
vm.Data.Columns.Add(new DataColumn("Date", typeof(string)));
using (var db = new ProjectManagementEntities())
{
vm.RecordCount = db.Project.Count();
foreach (var item in db.Project.OrderBy(u => u.ID).Take(pageCount))
{
var newRow = vm.Data.NewRow();
newRow["ID"] = item.ID;
newRow["Name"] = item.Name;
newRow["Area"] = String.Format("{0} - {1} - {2}", item.County.City.Province.Name, item.County.City.Name, item.County.Name);
newRow["PartyA"] = item.PartyAName;
newRow["PartyB"] = item.PartyB.Name;
newRow["Money"] = item.Money.ToString("C");
newRow["Date"] = item.Date.ToString("yyyy-MM-dd");
vm.Data.Rows.Add(newRow);
}
}
return(View(vm));
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="id"></param>
/// <param name="model"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <Project> EditProjectAsync(int id, EditProjectViewModel model,
CancellationToken cancellationToken = default(CancellationToken))
{
var loadProjectCondition = new SearchProjectViewModel();
loadProjectCondition.Ids = new HashSet <int>();
loadProjectCondition.Ids.Add(id);
var profile = _profileService.GetProfile(_httpRequestMessage);
if (profile == null)
{
throw new HttpException((int)HttpStatusCode.Forbidden, HttpMessages.ActionIsForbidden);
}
// Non admin user can only edit his/her project.
if (profile.Role != UserRoles.Admin)
{
loadProjectCondition.UserIds = new HashSet <int>();
loadProjectCondition.UserIds.Add(profile.Id);
}
var project = await GetProjects(loadProjectCondition).FirstOrDefaultAsync(cancellationToken);
if (project == null)
{
throw new HttpException((int)HttpStatusCode.NotFound, HttpMessages.ProjectNotFound);
}
// Transaction begin.
var transaction = _unitOfWork.BeginTransactionScope();
//Update information
project.UserId = model.UserId;
project.Name = model.Name;
project.Description = model.Description;
project.FinishedTime = model.FinishedTime;
project.StartedTime = model.StatedTime;
// Update skills
if (model.SkillIds != null)
{
// Get the list of available skills.
var skills = _unitOfWork.Skills.Search();
var availableSkills = await skills.Where(x => model.SkillIds.Contains(x.Id)).ToListAsync(cancellationToken);
var projectSkills = _unitOfWork.ProjectSkills.Search();
projectSkills = projectSkills.Where(x => x.ProjectId == id);
_unitOfWork.ProjectSkills.Remove(projectSkills);
foreach (var availableSkill in availableSkills)
{
var projectSkill = new ProjectSkill();
projectSkill.ProjectId = id;
projectSkill.SkillId = availableSkill.Id;
_unitOfWork.ProjectSkills.Insert(projectSkill);
}
}
// Update responsibilities
if (model.ResponsibilityIds != null)
{
// Get the list of available skills.
var responsibilities = _unitOfWork.Responsibilities.Search();
var availableResponsibilities = await responsibilities.Where(x => model.ResponsibilityIds.Contains(x.Id)).ToListAsync(cancellationToken);
var projectResponsibilities = _unitOfWork.ProjectResponsibilities.Search();
projectResponsibilities = projectResponsibilities.Where(x => x.ProjectId == id);
_unitOfWork.ProjectResponsibilities.Remove(projectResponsibilities);
foreach (var availableResponsibility in availableResponsibilities)
{
var projectResponsibility = new ProjectResponsibility();
projectResponsibility.ProjectId = id;
projectResponsibility.ResponsibilityId = availableResponsibility.Id;
_unitOfWork.ProjectResponsibilities.Insert(projectResponsibility);
}
}
await _unitOfWork.CommitAsync();
transaction.Commit();
return(project);
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="condition"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <SearchResultViewModel <IList <Project> > > SearchProjectsAsync(SearchProjectViewModel condition,
CancellationToken cancellationToken = default(CancellationToken))
{
var projects = GetProjects(condition);
var result = new SearchResultViewModel <IList <Project> >();
result.Total = await projects.CountAsync(cancellationToken);
//Do sort
projects = _dbService.Sort(projects, SortDirection.Ascending, ProjectSortProperty.Id);
//Do Pagination
result.Records = await _dbService.Paginate(projects, condition.Pagination).ToListAsync(cancellationToken);
return(result);
}
public async Task <IHttpActionResult> Search([FromBody] SearchProjectViewModel condition)
{
if (condition == null)
{
condition = new SearchProjectViewModel();
Validate(condition);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var projects = _unitOfWork.Projects.Search();
if (condition.Ids != null)
{
var ids = condition.Ids.Where(x => x > 0).ToList();
if (ids.Count > 0)
{
projects = projects.Where(x => ids.Contains(x.Id));
}
}
if (condition.Names != null)
{
var names = condition.Names.Where(c => !string.IsNullOrEmpty(c)).ToList();
if (names.Count > 0)
{
projects = projects.Where(c => condition.Names.Contains(c.Name));
}
}
if (condition.UserIds != null)
{
var userIds = condition.UserIds.Where(c => c > 0).ToList();
if (userIds.Count > 0)
{
projects = projects.Where(c => condition.UserIds.Contains(c.UserId));
}
}
if (condition.StartedTime != null)
{
projects = projects.Where(c => c.StartedTime >= condition.StartedTime.From &&
c.StartedTime <= condition.StartedTime.To);
}
if (condition.FinishedTime != null)
{
projects = projects.Where(c => c.FinishedTime >= condition.FinishedTime.From &&
c.FinishedTime <= condition.FinishedTime.To);
}
var result = new SearchResultViewModel <IList <Project> >();
result.Total = await projects.CountAsync();
//Do sort
projects = _dbService.Sort(projects, SortDirection.Ascending, ProjectSortProperty.Id);
//Do Pagination
projects = _dbService.Paginate(projects, condition.Pagination);
result.Records = await projects.ToListAsync();
return(Ok(result));
}
public async Task <SearchResultViewModel <IList <ProjectModel> > > SearchProjectAsync(SearchProjectViewModel condition, CancellationToken cancellationToken = default(CancellationToken))
{
var projects = _dbContext.Projects.AsQueryable();
if (condition.Ids != null)
{
var ids = condition.Ids.Where(x => x > 0).ToList();
if (ids.Count > 0)
{
projects = projects.Where(x => ids.Contains(x.Id));
}
}
if (condition.Names != null)
{
var names = condition.Names.Where(c => !string.IsNullOrEmpty(c)).ToList();
if (names.Count > 0)
{
projects = projects.Where(c => condition.Names.Contains(c.Name));
}
}
if (condition.UserIds != null)
{
var userIds = condition.UserIds.Where(c => c > 0).ToList();
if (userIds.Count > 0)
{
projects = projects.Where(c => condition.UserIds.Contains(c.UserId));
}
}
if (condition.StartedTime != null)
{
projects = projects.Where(c => c.StartedTime >= condition.StartedTime.From &&
c.StartedTime <= condition.StartedTime.To);
}
if (condition.FinishedTime != null)
{
projects = projects.Where(c => c.FinishedTime >= condition.FinishedTime.From &&
c.FinishedTime <= condition.FinishedTime.To);
}
#region Search project skills & responsibilities.
var skills = Enumerable.Empty <Skill>().AsQueryable();
var projectSkills = Enumerable.Empty <ProjectSkill>().AsQueryable();
if (condition.IncludeSkills)
{
skills = _dbContext.Skills.AsQueryable();
projectSkills = _dbContext.ProjectSkills.AsQueryable();
}
var responsibilities = Enumerable.Empty <Responsibility>().AsQueryable();
var projectResponsibilities = Enumerable.Empty <ProjectResponsibility>().AsQueryable();
if (condition.IncludeResponsibilities)
{
responsibilities = _dbContext.Responsibilities.AsQueryable();
projectResponsibilities = _dbContext.ProjectResponsibilities.AsQueryable();
}
var loadedProjects = from project in projects
select new ProjectModel
{
Id = project.Id,
UserId = project.UserId,
Name = project.Name,
Description = project.Description,
StartedTime = project.StartedTime,
FinishedTime = project.FinishedTime,
Skills = from projectSkill in projectSkills
from skill in skills
where projectSkill.ProjectId == project.Id && projectSkill.SkillId == skill.Id
select new SkillModel
{
Id = skill.Id,
Name = skill.Name,
CreatedTime = skill.CreatedTime,
LastModifiedTime = skill.LastModifiedTime
},
Responsibilities = from projectResponsibility in projectResponsibilities
from responsibility in responsibilities
where projectResponsibility.ProjectId == project.Id &&
projectResponsibility.ResponsibilityId == responsibility.Id
select new ResponsibilityModel
{
Id = responsibility.Id,
Name = responsibility.Name,
CreatedTime = responsibility.CreatedTime,
LastModifiedTime = responsibility.LastModifiedTime
}
};
#endregion
var result = new SearchResultViewModel <IList <ProjectModel> >();
result.Total = await projects.CountAsync(cancellationToken);
//Do sort
loadedProjects = _dbService.Sort(loadedProjects, SortDirection.Ascending, ProjectSortProperty.Id);
//Do Pagination
loadedProjects = _dbService.Paginate(loadedProjects, condition.Pagination);
result.Records = await loadedProjects.ToListAsync(cancellationToken);
return(result);
}
