/// <summary> /// Get requirement by name. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requirement that contains the name field to filter by.</param> /// <returns>A DTO requirement.</returns> public DTORequirements getRequirementByName(IDbContext context, DTORequirements requirement) { var query = getAllByProjectId(context, requirement) .Where(x => x.Name == requirement.Name && x.ProjectId == requirement.ProjectId).FirstOrDefault(); return(Mapper.mapDTORequirements(query)); }
/// <summary> /// Get json for datatable in requirements. /// </summary> /// <param name="requirement">Requirement that contains the projectId.</param> /// <param name="dataTableparms">Parameters sent from ajax.</param> /// <returns>A DataTableJson object.</returns> public DataTableJson <DTORequirementDataTable> getJsonDataTable(DTORequirements requirement, DataTableParams dataTableparms) { using (DbContext) { var query = requirementRepository.getJsonDataTable(DbContext, requirement, dataTableparms); return(query); } }
public DTORequirements insertAndgetRequirement(DTORequirements DTORequirement) { int idOfInsertedRequirement = Container.createIRequirementsRepository().insertRequirementAndSaveChanges(Container.createIDbContext(), DTORequirement); DTORequirement.Id = idOfInsertedRequirement; return(DTORequirement); }
/// <summary> /// Add error to modelState if the name already exists. /// </summary> /// <param name="dbContext">Context of the database.</param> /// <param name="requirement">The requirement that contains the name to be validated.</param> private void addErrorIfNameExist(DTORequirements requirement) { bool nameExist = requirementRepository.getRequirementByName(DbContext, requirement) != null; if (nameExist) { ControllerUI.ModelStateService.AddModelError("Name", GlobalResources["nameEntity"]); } }
/// <summary> /// Insert a requirement in the db. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requirement DTO to be inserted.</param> /// <returns>The id of the inserted record.</returns> public int insertRequirementAndSaveChanges(IDbContext context, DTORequirements requirement) { throwExceptionIfForeignKeyInvalid(requirement.ProjectId); // Get entity from DTO var requirementEntity = Mapper.mapEntityRequirements(requirement); // Return id return(insertAndSaveChanges <Requirement>(context, requirementEntity)); }
/// <summary> /// Get project name by project id. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requirement that contains the projectId to filterby.</param> /// <returns>The name of the project</returns> public DTOProject getProjectNameAndIdByRequirement(IDbContext context, DTORequirements requirement) { var query = getAll <Project>(context) .Where(x => x.Id == requirement.ProjectId) .Select(x => new { x.Name, x.Id }) .AsEnumerable().Select(x => new DTOProject { Name = x.Name, Id = x.Id }).FirstOrDefault(); return(query); }
/// <summary> /// Check if a requirement can be deleted. /// </summary> /// <param name="requirement">Requirement to be checked.</param> /// <returns></returns> private bool deleteRequirementIsOk(DTORequirements requirement) { var existTasksForThisReq = taskRepository.tasksExistByRequirementId(DbContext, new DTOTask { RequirementId = requirement.Id }); if (existTasksForThisReq) { ControllerUI.ModelStateService.AddModelError(SummaryError, GlobalResources["deleteRequirement"]); } return(ControllerUI.ModelStateService.IsValid); }
/// <summary> /// Get all the requirement DTO by all fields except for the id. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requirement DTO.</param> /// <returns>A collection of requirement DTO matching the criteria.</returns> public List <DTORequirements> getByAllFieldsExceptId(IDbContext context, DTORequirements requirement) { var query = getAllByProjectId(context, requirement) .Where(x => x.Description == requirement.Description && x.Name == requirement.Name && x.IsComplete == requirement.IsComplete ).AsEnumerable().Select(x => Mapper.mapDTORequirements(x) ).ToList(); return(query); }
// Task public DTOTask getRandomTask(DTORequirements requirement) { var randonDescription = "descrp-" + getRString(); var randonCreationDate = getRandomDate(); var taskToInsert = new DTOTask { RequirementId = requirement.Id, Description = randonDescription, CreationDate = randonCreationDate }; return(taskToInsert); }
/// <summary> /// Delete a requirement. /// </summary> /// <param name="requirement">Requirement to be deleted.</param> public void deleteRequirement(DTORequirements requirement) { using (DbContext) { // Validate if the requirement can be deleted if (!deleteRequirementIsOk(requirement)) { return; } // Delete requirement requirementRepository.deleteRequirement(DbContext, requirement); DbContext.SaveChanges(); } }
/// <summary> /// Get all the requirements. /// </summary> /// <returns>A collection of DTO requirements.</returns> public DTORequirementView getAllRequirements(DTORequirements requirement) { using (DbContext) { // Get requirements and project name var project = requirementRepository.getProjectNameAndIdByRequirement(DbContext, requirement); // Return requirement view return(new DTORequirementView { ProjectId = requirement.ProjectId, ProjectName = project.Name, }); } }
/// <summary> /// Update a requirement. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requirement to update.</param> public void updateRequirement(IDbContext context, DTORequirements requirement) { // Old entity var oldEntity = context.Requirements.Where(x => x.Id == requirement.Id).FirstOrDefault(); // New entity and set fk and dates var newEntity = Mapper.mapEntityRequirements(requirement); newEntity.ProjectId = oldEntity.ProjectId; newEntity.CreationDate = oldEntity.CreationDate; newEntity.FinalizationDate = oldEntity.FinalizationDate; // Update entity update <Requirement>(context, newEntity, oldEntity); }
public DTORequirements getRandomRequirement(DTOProject project) { var randonName = "req-" + getRString().ToString(); var randonDescription = "desp-" + getRString().ToString(); var randonCreationDate = getRandomDate(); var requirementToInsert = new DTORequirements { ProjectId = project.Id, Name = randonName, Description = randonDescription, CreationDate = randonCreationDate, FinalizationDate = (DateTime)SqlDateTime.MaxValue }; return(requirementToInsert); }
public List <DTOTask> insertTasksAndgetList(DTORequirements requirement, int listLength) { List <DTOTask> taskList = new List <DTOTask>(); for (int i = 0; i < listLength; i++) { // Get individual task var taskToInsert = getRandomTask(requirement); // Insert task int insertedRecord = Container.createITaskRepository().insertTaskAndSaveChanges(Container.createIDbContext(), taskToInsert); taskToInsert.Id = insertedRecord; // Add task to list taskList.Add(taskToInsert); } return(taskList); }
/// <summary> /// Insert a requirement in db. /// </summary> /// <param name="Requirement">Requirement to be inserted.</param> /// <returns>The id of the inserted record.</returns> public int insertRequirement(DTORequirements Requirement) { using (DbContext) { // Validate insert requirement if (!insertRequirementIsOk(Requirement)) { return(-1); } // Set dates Requirement.CreationDate = DateTime.Now; Requirement.FinalizationDate = (DateTime)SqlDateTime.MinValue; // Insert requirement int id = requirementRepository.insertRequirementAndSaveChanges(DbContext, Requirement); return(id); } }
/// <summary> /// Update a requirement. /// </summary> /// <param name="requirement">Requirement to update.</param> public void updateRequirement(DTORequirements requirement) { using (DbContext) { // Validate requirement to update if (!updateRequirementIsOk(requirement)) { return; } // Set creation and finalization date var oldRequirement = requirementRepository.getRequirementById(DbContext, requirement); requirement.CreationDate = oldRequirement.CreationDate; requirement.FinalizationDate = oldRequirement.FinalizationDate; // Update requirement and save changes requirementRepository.updateRequirement(DbContext, requirement); DbContext.SaveChanges(); } }
public ActionResult DataTableAjaxHandler(DTORequirements requirement, DataTableParams dataTableParams) { var data = requirementService.getJsonDataTable(requirement, dataTableParams); return(Json(data, JsonRequestBehavior.AllowGet)); }
/// <summary> /// Get a requirement by id. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="id">Id of the requirement to get.</param> /// <returns>A requirement DTO.</returns> public DTORequirements getRequirementById(IDbContext context, DTORequirements requirement) { var query = getById <Requirement>(context, Mapper.mapEntityRequirements(requirement)).FirstOrDefault(); return(Mapper.mapDTORequirements(query)); }
/// <summary> /// Delete a requirement. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requirement to remove.</param> public void deleteRequirement(IDbContext context, DTORequirements requirement) { // Delete entity delete <Requirement>(context, Mapper.mapEntityRequirements(requirement)); }
/// <summary> /// Get all the requirements as iqueryable and by project id. /// </summary> /// <param name="context">context of the database.</param> /// <param name="requirement">Requirement that contains the project id fk.</param> /// <returns>An iqueryable collection.</returns> private IQueryable <Requirement> getAllByProjectId(IDbContext context, DTORequirements requirement) { throwExceptionIfForeignKeyInvalid(requirement.ProjectId); return(getAll <Requirement>(context).Where(x => x.ProjectId == requirement.ProjectId).AsQueryable()); }
/// <summary> /// Check if a requirement exist. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requiremet to check in db.</param> /// <returns>True if the requirement exist. Otherwise false.</returns> public bool requirementExistsByProjectId(IDbContext context, DTORequirements requirement) { var query = getAll <Requirement>(context).Where(x => x.ProjectId == requirement.ProjectId).Any(); return(query); }
/// <summary> /// Validate the insert requirement method. /// </summary> /// <param name="dbContext">Context of the database.</param> /// <param name="requirement">Requirement to be validated.</param> /// <returns>True if validation is successful. Otherwise false.</returns> private bool insertRequirementIsOk(DTORequirements requirement) { addErrorIfNameExist(requirement); return(ControllerUI.ModelStateService.IsValid); }
/// <summary> /// Get json datatable for requirements. /// </summary> /// <param name="context">Context of the database.</param> /// <param name="requirement">Requirement that contains the projectId</param> /// <param name="dataTableparms"></param> /// <returns></returns> public DataTableJson <DTORequirementDataTable> getJsonDataTable(IDbContext context, DTORequirements requirement, DataTableParams dataTableparms) { // Get requirement as a list of DTORequirementDataTable var requirementsDataTable = getAllByProjectId(context, requirement) .Select(x => new DTORequirementDataTable { RequirementId = x.Id, ProjectId = x.ProjectId, CreationDate = x.CreationDate, Description = x.Description, Name = x.Name, NumberOfTasks = 0, ThereAreTasks = false }).AsQueryable(); // Get the filtering Expression <Func <DTORequirementDataTable, bool> > filtering = getFilteringForReqDataTable(dataTableparms); // Get json var iqueryableSource = dataTableService.getIQueryableSource <DTORequirementDataTable> ( dataTableparms, requirementsDataTable, filtering ); // Get status var listWithStatus = getStatusInListDTORequirementDataTable(context, iqueryableSource); // Return json response return(dataTableService.getJsonResponse <DTORequirementDataTable>(listWithStatus)); }
/// <summary> /// Map DTO requiremnets to entity requirement. /// </summary> /// <param name="dtoRequirement">Entity requirement to map from.</param> /// <returns>A DTO requirement.</returns> public Requirement mapEntityRequirements(DTORequirements dtoRequirement) { return(map <Requirement>(dtoRequirement)); }
public ActionResult DeleteRequirement(DTORequirements requirement) { requirementService.deleteRequirement(requirement); return(Json(true)); }
public ActionResult Index(DTORequirements requirement) { return(View("Index", requirementService.getAllRequirements(requirement))); }
public ActionResult CreateRequirement([Bind(Exclude = "Id")] DTORequirements requirement) { int id = requirementService.insertRequirement(requirement); return(Json(id)); }
// Private Methods ===================================== private IQueryable <DTORequirementDataTable> getRequirementDataTableIQueryable(DTORequirements requirement) { // Get requirement as a list of DTORequirementDataTable var requirementsDataTable = Container.createIDbContext().Requirements.Where(x => x.ProjectId == requirement.ProjectId) .Select(x => new DTORequirementDataTable { RequirementId = x.Id, ProjectId = x.ProjectId, CreationDate = x.CreationDate, Description = x.Description, Name = x.Name, NumberOfTasks = 0, }).AsQueryable(); return(requirementsDataTable); }