public async void handle_Exception_test()
{
Project returnn = new Project();
OrganisationProject op = new OrganisationProject();
ProjectCategory pc = new ProjectCategory();
ProjectResearcher pr = new ProjectResearcher();
this._unitOfUnitMock.Setup(mock => mock.ProjectRepository.Update(It.IsAny <Project>())).Returns(returnn);
this._unitOfUnitMock.Setup(mock => mock.RelationsRepository.DeleteProjectOrganisation(It.IsAny <int>()))
.Returns(true);
this._unitOfUnitMock.Setup(mock =>
mock.RelationsRepository.CreateOrganisationProject(It.IsAny <OrganisationProject>())).Returns(op);
this._unitOfUnitMock.Setup(mock => mock.RelationsRepository.DeleteCategoriesProject(It.IsAny <int>()))
.Returns(true);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.CreateProjectCategory(It.IsAny <ProjectCategory>())).Returns(pc);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.DeleteProjectResearcherWithProjectId(It.IsAny <int>()))
.Returns(true);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.CreateProjectResearcher(It.IsAny <ProjectResearcher>()))
.Throws(new Exception());
UpdateProjectCommand command = new UpdateProjectCommand(new CreateProjectModel()
{
ProjectName = "test",
Categories = new List <Category>()
{
new Category()
{
CategoryId = 1, CategoryName = "test", Created = DateTime.Now, Id = 1
}
},
ResearcherCategories = new List <ResearcherCategory>()
{
new ResearcherCategory()
{
Researcher = new Researcher()
{
Id = 1
}, Category = new Category()
{
Id = 1
}
}
},
Organisations = new List <Organisation>()
{
new Organisation()
{
Id = 1,
}
}
});
UpdateProjectHandler handler = new UpdateProjectHandler(this._unitOfUnitMock.Object);
var result = await handler.Handle(command, new CancellationTokenSource().Token);
Assert.Null(result);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,projectId,researcherId")] ProjectResearcher projectResearcher)
{
if (id != projectResearcher.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(projectResearcher);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectResearcherExists(projectResearcher.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["projectId"] = new SelectList(_context.Project, "ID", "fundAmount", projectResearcher.projectId);
ViewData["researcherId"] = new SelectList(_context.Set <Researcher>(), "ID", "reseacherName", projectResearcher.researcherId);
return(View(projectResearcher));
}
public async void handle_Succes_test()
{
Project project = new Project()
{
Id = 1
};
ProjectCategory pc = new ProjectCategory();
ProjectResearcher pr = new ProjectResearcher();
OrganisationProject op = new OrganisationProject();
this._unitOfUnitMock.Setup(mock => mock.ProjectRepository.Create(It.IsAny <Project>())).Returns(project);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.CreateProjectCategory(It.IsAny <ProjectCategory>())).Returns(pc);
this._unitOfUnitMock
.Setup(mock => mock.RelationsRepository.CreateProjectResearcher(It.IsAny <ProjectResearcher>()))
.Returns(pr);
this._unitOfUnitMock.Setup(mock =>
mock.RelationsRepository.CreateOrganisationProject(It.IsAny <OrganisationProject>())).Returns(op);
CreateProjectCommand command = new CreateProjectCommand(
new CreateProjectModel()
{
ProjectName = "test",
Categories = new List <Category>()
{
new Category()
{
CategoryId = 1, CategoryName = "test", Created = DateTime.Now, Id = 1
}
},
ResearcherCategories = new List <ResearcherCategory>()
{
new ResearcherCategory()
{
Researcher = new Researcher()
{
Id = 1
}, Category = new Category()
{
Id = 1
}
}
},
Organisations = new List <Organisation>()
{
new Organisation()
{
Id = 1,
}
}
});
CreateProjectHandler handler = new CreateProjectHandler(this._unitOfUnitMock.Object);
var result = await handler.Handle(command, new CancellationTokenSource().Token);
Assert.Equal(result, project);
}
public async Task <IActionResult> Create([Bind("ID,projectId,researcherId")] ProjectResearcher projectResearcher)
{
if (ModelState.IsValid)
{
_context.Add(projectResearcher);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["projectId"] = new SelectList(_context.Project, "ID", "fundAmount", projectResearcher.projectId);
ViewData["researcherId"] = new SelectList(_context.Set <Researcher>(), "ID", "reseacherName", projectResearcher.researcherId);
return(View(projectResearcher));
}
public void InsertProjectResearcher(ProjectResearcher projectResearcher)
{
if (projectResearcher == null)
{
throw new ArgumentNullException(nameof(projectResearcher));
}
if (projectResearcher is IEntityForCaching)
{
throw new ArgumentException("Cacheable entities are not supported by Entity Framework");
}
_projectResearcherRepository.Insert(projectResearcher);
}
public void RemoveProjectResearcher(Project project, ProjectResearcher projectResearcher)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (projectResearcher == null)
{
throw new ArgumentNullException(nameof(projectResearcher));
}
//project.ProjectResearchers.Remove(projectResearcher);
_projectResearcherRepository.Delete(projectResearcher);
}
public virtual IActionResult ProjectResearcherAdd(int projectId, string researcherName,
int roleId, int portion)
{
//if (!_permissionService.Authorize(StandardPermissionProvider.ManageResearchers))
// return AccessDeniedView();
//try to get a project with the specified id
var project = _projectService.GetProjectById(projectId);
if (project == null)
{
return(Json(new { Result = false }));
}
project.LastUpdateBy = _workContext.CurrentUser.UserName;
project.Modified = DateTime.UtcNow;
_projectService.UpdateProject(project);
int portions = _projectService.GetAllProjectResearchers(project.Id).Select(x => x.Portion).Sum();
portions += portion;
if (portions > 100)
{
ModelState.AddModelError("", "สัดส่วนนักวิจัย มากกว่า 100 %.");
return(Json(new { Result = false }));
}
else
{
var projectResearcher = new ProjectResearcher
{
ProjectId = project.Id,
ResearcherName = researcherName,
ProjectRoleId = roleId,
Portion = portion
};
_projectService.InsertProjectResearcher(projectResearcher);
}
return(Json(new { Result = true }));
}
public ProjectResearcher CreateProjectResearcher(ProjectResearcher entity)
{
try
{
string createProjectResearcherQuery = "INSERT INTO EIC.dbo.PROJECTRESEARCHER (Created, ProjectId, ResearcherId, CategoryId, TitleId) " +
"VALUES (@Created, @ProjectId, @ResearcherId, @CategoryId, @TitleId); " +
"SELECT SCOPE_IDENTITY();";
var result = this._connection.ExecuteScalar <int>(createProjectResearcherQuery, entity, this._transaction);
if (result <= 0)
{
return(null);
}
entity.Id = result;
return(entity);
}
catch (Exception e)
{
return(null);
}
}
public async Task <object> Handle(CreateProjectCommand request, CancellationToken cancellationToken)
{
try
{
Project project = new Project();
project.Created = DateTime.Now;
project.ProjectName = request.Model.ProjectName;
project.StartDate = request.Model.StartDate; // Check if date is valid
project.EndDate = request.Model.EndDate;
var projectResult = this._projectRepository.Create(project);
if (projectResult == null)
{
this._unitOfWork.Rollback();
return(false);
}
foreach (var cat in request.Model.Categories)
{
ProjectCategory projectCategory = new ProjectCategory();
projectCategory.Created = DateTime.Now;
projectCategory.CategoryId = cat.Id;
projectCategory.ProjectId = projectResult.Id;
var catResult = this._relationsRepository.CreateProjectCategory(projectCategory);
if (catResult == null)
{
this._unitOfWork.Rollback();
return(false);
}
}
foreach (var researcherCategory in request.Model.ResearcherCategories)
{
ProjectResearcher projectResearcher = new ProjectResearcher();
projectResearcher.Created = DateTime.Now;
projectResearcher.ResearcherId = researcherCategory.Researcher.Id;
projectResearcher.ProjectId = projectResult.Id;
projectResearcher.CategoryId = researcherCategory.Category.Id;
projectResearcher.TitleId = 1;
var researcherResult = this._relationsRepository.CreateProjectResearcher(projectResearcher);
if (researcherResult == null)
{
this._unitOfWork.Rollback();
return(false);
}
}
foreach (var organisation in request.Model.Organisations)
{
OrganisationProject organisationProject = new OrganisationProject();
organisationProject.Created = DateTime.Now;
organisationProject.OrganisationId = organisation.Id;
organisationProject.ProjectId = projectResult.Id;
var orgaResult = this._relationsRepository.CreateOrganisationProject(organisationProject);
if (orgaResult == null)
{
this._unitOfWork.Rollback();
return(false);
}
}
this._unitOfWork.Commit();
this._unitOfWork.Dispose();
this._unitOfWork.QueueUserActivityLogItem(ActivityTypes.Activities.ProjectCreated, projectResult.Id);
return(projectResult);
}
catch (Exception e)
{
this._unitOfWork.Rollback();
this._unitOfWork.QueueErrorLogItem(
ActivityTypes.Activities.ProjectCreated,
ActivityTypes.Areas.CreateProjectHandler,
e.Message);
return(null);
}
}
public async Task <object> Handle(UpdateProjectCommand request, CancellationToken cancellationToken)
{
try
{
var project = new Project();
project.Created = DateTime.Now;
project.StartDate = request.Model.StartDate;
project.EndDate = request.Model.EndDate;
project.ProjectName = request.Model.ProjectName;
project.Id = request.Model.Id;
var result = this._projectRepository.Update(project);
if (result == null)
{
this._unitOfWork.Rollback();
return(null);
}
// OrganisationProject
var result1 = this._relationsRepository.DeleteProjectOrganisation(result.Id);
if (result1 == false)
{
this._unitOfWork.Rollback();
return(null);
}
foreach (var organisation in request.Model.Organisations)
{
OrganisationProject organisationProject = new OrganisationProject();
organisationProject.Created = DateTime.Now;
organisationProject.OrganisationId = organisation.OrganisationId;
organisationProject.ProjectId = result.Id;
var orgaResult = this._relationsRepository.CreateOrganisationProject(organisationProject);
if (orgaResult == null)
{
this._unitOfWork.Rollback();
return(false);
}
}
// CategoriesProject
var result2 = this._relationsRepository.DeleteCategoriesProject(result.Id);
if (result2 == false)
{
this._unitOfWork.Rollback();
return(null);
}
foreach (var cat in request.Model.Categories)
{
ProjectCategory projectCategory = new ProjectCategory();
projectCategory.Created = DateTime.Now;
projectCategory.CategoryId = cat.CategoryId;
projectCategory.ProjectId = result.Id;
var catResult = this._relationsRepository.CreateProjectCategory(projectCategory);
if (catResult == null)
{
this._unitOfWork.Rollback();
return(false);
}
}
var result3 = this._relationsRepository.DeleteProjectResearcherWithProjectId(result.Id);
if (result3 == false)
{
this._unitOfWork.Rollback();
return(null);
}
foreach (var researcherCategory in request.Model.ResearcherCategories)
{
ProjectResearcher projectResearcher = new ProjectResearcher();
projectResearcher.Created = DateTime.Now;
projectResearcher.ResearcherId = researcherCategory.Researcher.Id;
projectResearcher.ProjectId = result.Id;
projectResearcher.CategoryId = researcherCategory.Category.Id;
projectResearcher.TitleId = 1;
var researcherResult = this._relationsRepository.CreateProjectResearcher(projectResearcher);
if (researcherResult == null)
{
this._unitOfWork.Rollback();
return(false);
}
}
this._unitOfWork.Commit();
this._unitOfWork.Dispose();
return(true);
}
catch (Exception e)
{
this._unitOfWork.Rollback();
return(null);
}
}
public virtual IActionResult Create(ProjectModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageProjects))
{
return(AccessDeniedView());
}
int fiscalYear = DateTime.Now.Year + 543;
var fiscalSchedule = _fiscalScheduleService.GetAllFiscalSchedules(fiscalScheduleName: string.Empty,
fiscalYear: fiscalYear)
.Where(x => x.ClosingDate >= DateTime.Today)
.OrderByDescending(x => x.OpeningDate).FirstOrDefault();
if (fiscalSchedule == null)
{
ModelState.AddModelError("", "ไม่พบช่วงเวลา วันเปิดรับข้อเสนอโครงการวิจัย โปรดติดต่อผู้ดูแลระบบ");
}
if (ModelState.IsValid)
{
var user = _workContext.CurrentUser;
var project = model.ToEntity <Project>();
project.ProjectType = string.IsNullOrEmpty(model.ProjectType) ? "N" : model.ProjectType;
project.ProjectStartDate = fiscalSchedule.OpeningDate;
project.ProjectEndDate = fiscalSchedule.ClosingDate;
project.Created = DateTime.UtcNow;
project.Modified = DateTime.UtcNow;
project.LastUpdateBy = user.UserName;
project.ProjectStatusId = (int)ProjectStatus.WaitingApproval;
project.CreatedBy = _workContext.CurrentUser.UserName;
_projectService.InsertProject(project);
var researcher = user.Researcher;
string title = (researcher.Title != null) ? researcher.Title.TitleNameTH : string.Empty;
if (researcher != null)
{
var projectResearcher = new ProjectResearcher
{
ProjectId = project.Id,
Portion = 100,
ProjectRoleId = (int)ProjectRole.ProjectManager,
ResearcherName = $"{title}{researcher.FirstName} {researcher.LastName}"
};
_projectService.InsertProjectResearcher(projectResearcher);
}
SuccessNotification("Admin.ContentManagement.Projects.Added");
//activity log
//_userActivityService.InsertActivity("AddNewProject", "ActivityLog.AddNewProject", project);
if (!continueEditing)
{
return(RedirectToAction("List"));
}
//selected tab
SaveSelectedTabName();
return(RedirectToAction("Edit", new { id = project.Id }));
}
//prepare model
model = _projectModelFactory.PrepareProjectModel(model, null);
//if we got this far, something failed, redisplay form
return(View(model));
}
