示例#1
0
 public DecisionDTO GetById(int id, string currentUser)
 {
     try
     {
         DecisionDTO decision    = new DecisionDTO();
         var         ListOfDepId = _departmentCoordinatorRepository.Query().SelectQueryable().Where(c => c.UserId == currentUser).Select(c => c.DepartmentId).ToList();
         Mapper.Map <Decision, DecisionDTO>(_repository
                                            .Query()
                                            .Include(c => c.Country)
                                            .Include(c => c.ActivitySectors)
                                            .Include(c => c.Companies)
                                            .Include(c => c.AgendaItem)
                                            .Include(c => c.AgendaDetail)
                                            .Include(c => c.Departments)
                                            .Include(c => c.ReferenceItems.Select(d => d.ReferenceType))
                                            .Include(c => c.ReferenceItems.Select(d => d.ReferenceDecision))
                                            .Include(c => c.DecisionExecutions.Select(d => d.Attachments))
                                            .Include(c => c.SubCategory.MainCategory.CouncilType)
                                            .SelectQueryable()
                                            .Where(c => c.Id == id).FirstOrDefault(), decision);
         decision.KeyWordList = !String.IsNullOrEmpty(decision.KeyWords) ? decision.KeyWords.Split(' ').ToList() : null;
         decision.DecisionExecutions.ToList().ForEach(c => c.NeedAction = ListOfDepId.Contains(c.DepartmentId) && c.ExecutionDate == null);
         return(decision);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
示例#2
0
        /// <inheritdoc />
        public async Task ChangeDecisionAsync(DecisionDTO decisionDto)
        {
            Decesion decision = await _repoWrapper.Decesion.GetFirstAsync(x => x.ID == decisionDto.ID);

            decision.Name        = decisionDto.Name;
            decision.Description = decisionDto.Description;
            _repoWrapper.Decesion.Update(decision);
            await _repoWrapper.SaveAsync();
        }
示例#3
0
        public DecisionDTO Create(DecisionDTO dto)
        {
            // Mapeamos el dto a la entidad, la añadimos al contexto, guardamos y devolvemos el dto mapeado
            var model = _mapper.Map <Decision>(dto);

            _context.Decisiones.Add(model);
            _context.SaveChanges();
            return(_mapper.Map <DecisionDTO>(model));
        }
示例#4
0
        public async Task <IActionResult> Update(int id, DecisionDTO decision)
        {
            if (id != decision.ID)
            {
                return(BadRequest());
            }
            await _decisionService.ChangeDecisionAsync(decision);

            return(NoContent());
        }
示例#5
0
        public async Task <IActionResult> Get(int id)
        {
            DecisionDTO decisionDto = await _decisionService.GetDecisionAsync(id);

            if (decisionDto == null)
            {
                return(NotFound());
            }

            return(Ok(decisionDto));
        }
 public IHttpActionResult PostDecision(DecisionDTO decision)
 {
     if (ModelState.IsValid)
     {
         decision.Id = _decisionBLL.Insert(decision, _appicationContext.GetUserId());
         return(Ok());
     }
     else
     {
         return(BadRequest(ModelState));
     }
 }
示例#7
0
        public async Task ChangeDecisionTest(string decisionNewName, string decisionNewDescription)
        {
            _decisionService = CreateDecisionService();
            _repository.Setup(rep => rep.Decesion.GetFirstAsync(It.IsAny <Expression <Func <Decesion, bool> > >(),
                                                                It.IsAny <Func <IQueryable <Decesion>, IIncludableQueryable <Decesion, object> > >()))
            .ReturnsAsync(GetTestDecesionQueryable().FirstOrDefault());
            var changingDecisionDto = new DecisionDTO();

            changingDecisionDto.Name        = decisionNewName;
            changingDecisionDto.Description = decisionNewDescription;
            await _decisionService.ChangeDecisionAsync(changingDecisionDto);

            _repository.Verify(rep => rep.Decesion.GetFirstAsync(It.IsAny <Expression <Func <Decesion, bool> > >(),
                                                                 It.IsAny <Func <IQueryable <Decesion>, IIncludableQueryable <Decesion, object> > >()), Times.Once);
        }
        public async Task Update_ReturnsOkObjectResult()
        {
            //Arrange
            var mockDecision = new DecisionDTO();

            _decisionService
            .Setup(x => x.ChangeDecisionAsync(mockDecision));

            //Act
            var result = await _decisionsController.Update(It.IsAny <int>(), mockDecision);

            //Assert
            _decisionService.Verify();
            Assert.IsInstanceOf <NoContentResult>(result);
        }
        public async Task Update_InvalidID()
        {
            //Arrange
            var expected     = 1;
            var mockDecision = new DecisionDTO();

            mockDecision.ID = 2;
            _decisionService
            .Setup(x => x.ChangeDecisionAsync(mockDecision));

            //Act
            var result = await _decisionsController.Update(expected, mockDecision);

            //Assert
            _decisionService.Verify();
            Assert.IsInstanceOf <BadRequestResult>(result);
        }
 public IHttpActionResult PutDecision(DecisionDTO decision)
 {
     try
     {
         if (ModelState.IsValid)
         {
             decision.Id = _decisionBLL.Update(decision, _appicationContext.GetUserId());
             return(Ok(decision));
         }
         else
         {
             return(BadRequest(ModelState));
         }
     }
     catch (Exception)
     {
         throw;
     }
 }
示例#11
0
 public ActionResult <Decision> PostDecision(DecisionDTO decision)
 {
     return(Ok(_repository.Create(decision)));
 }
示例#12
0
        public int Save(DecisionDTO obj, string currentuserId)
        {
            Decision decision;

            try
            {
                _unitOfWork.BeginTransaction();

                if (obj.Id == 0)
                {
                    decision = new Decision();
                    Mapper.Map <DecisionDTO, Decision>(obj, decision);
                    if (obj.SelectedSectors.Count > 0)
                    {
                        foreach (int sector in obj.SelectedSectors)
                        {
                            decision.ActivitySectors.Add(_activitySectorRepository.Find(sector));
                        }
                    }

                    if (obj.SelectedCompaniesIds.Count > 0)
                    {
                        foreach (int company in obj.SelectedCompaniesIds)
                        {
                            decision.Companies.Add(_companyRepository.Find(company));
                        }
                    }

                    if (obj.SelectedDepartmentIds.Count > 0)
                    {
                        foreach (int department in obj.SelectedDepartmentIds)
                        {
                            decision.Departments.Add(_departmentRepository.Find(department));
                            decision.DecisionExecutions.Add(new DecisionExecution()
                            {
                                CreateDate     = DateTime.Now,
                                CreatedBy      = currentuserId,
                                Department     = _departmentRepository.Find(department),
                                DecisionStatus = 0,
                                TrackingState  = TrackableEntities.TrackingState.Added
                            });
                        }
                    }

                    decision.CreateDate = DateTime.Now;
                    decision.CreatedBy  = currentuserId;
                    base.Insert(decision);
                }
                else
                {
                    decision = _repository
                               .Query()
                               .Include(c => c.ActivitySectors)
                               .Include(c => c.Companies)
                               .Include(c => c.Departments)
                               .Include(c => c.DecisionExecutions)
                               .SelectQueryable().Where(c => c.Id == obj.Id).FirstOrDefault();
                    Mapper.Map <DecisionDTO, Decision>(obj, decision);
                    foreach (var s in decision.ActivitySectors)
                    {
                        decision.ActivitySectors.Remove(s);
                    }
                    foreach (var s in decision.Companies)
                    {
                        decision.Companies.Remove(s);
                    }
                    foreach (var s in decision.Departments)
                    {
                        decision.Departments.Remove(s);
                    }
                    foreach (var s in decision.DecisionExecutions)
                    {
                        if (!obj.SelectedDepartmentIds.Contains(s.DepartmentId))
                        {
                            s.TrackingState = TrackableEntities.TrackingState.Deleted;
                        }
                    }
                    _unitOfWork.SaveChanges();
                    if (obj.SelectedSectors.Count > 0)
                    {
                        foreach (int sector in obj.SelectedSectors)
                        {
                            decision.ActivitySectors.Add(_activitySectorRepository.Find(sector));
                        }
                    }


                    if (obj.SelectedCompaniesIds.Count > 0)
                    {
                        foreach (int company in obj.SelectedCompaniesIds)
                        {
                            decision.Companies.Add(_companyRepository.Find(company));
                        }
                    }

                    if (obj.SelectedDepartmentIds.Count > 0)
                    {
                        foreach (int department in obj.SelectedDepartmentIds)
                        {
                            decision.Departments.Add(_departmentRepository.Find(department));
                        }
                    }

                    if (obj.SelectedDepartmentIds.Count > 0)
                    {
                        foreach (int department in obj.SelectedDepartmentIds)
                        {
                            if (!decision.DecisionExecutions.Select(c => c.DepartmentId).Contains(department))
                            {
                                decision.DecisionExecutions.Add(new DecisionExecution()
                                {
                                    CreateDate     = DateTime.Now,
                                    CreatedBy      = currentuserId,
                                    Department     = _departmentRepository.Find(department),
                                    DecisionStatus = 0,
                                    TrackingState  = TrackableEntities.TrackingState.Added
                                });
                            }
                        }
                    }


                    decision.LastUpdateDate = DateTime.Now;
                    decision.LastUpdateBy   = currentuserId;
                    base.Update(decision);
                }
                _unitOfWork.SaveChanges();
                _unitOfWork.Commit();
                return(decision.Id);
            }
            catch (Exception)
            {
                throw;
            }
        }
示例#13
0
        public int Update(DecisionDTO objDTO, string currentuserId)
        {
            var decId = objDTO.Id;

            objDTO.DecisionExecutions.ToList().ForEach(c => c.DepartmentName = _departmentService.Find(c.DepartmentId).Name);
            Decision decision = new Decision();

            try
            {
                var isValid = !(_repository.Query().SelectQueryable().Where(c => c.DecisionNumber == objDTO.DecisionNumber && c.ConferenceYear != 0 && c.ConferenceYear == objDTO.ConferenceYear && c.Id != objDTO.Id).Any());
                if (isValid)
                {
                    _unitOfWork.BeginTransaction();
                    decision = _repository
                               .Query()
                               .SelectQueryable().Where(c => c.Id == objDTO.Id).FirstOrDefault();

                    var referenceItems = _referenceItemRepository.Query().SelectQueryable().Where(c => c.DecisionId == decision.Id).Select(c => c.Id).ToList();
                    foreach (var referenceItem in referenceItems)
                    {
                        if (!objDTO.ReferenceItems.Select(c => c.Id).ToList().Contains(referenceItem))
                        {
                            _referenceItemRepository.Delete(referenceItem);
                        }
                    }
                    _unitOfWork.SaveChanges();

                    var decisionExecutions = _decisionExecutionRepository.Query().SelectQueryable().Where(c => c.DecisionId == decision.Id).Select(c => c.Id).ToList();
                    foreach (var decisionExecution in decisionExecutions)
                    {
                        if (!objDTO.DecisionExecutions.Select(c => c.Id).ToList().Contains(decisionExecution))
                        {
                            _decisionExecutionRepository.Delete(decisionExecution);
                        }
                    }
                    _unitOfWork.SaveChanges();

                    Mapper.Map <DecisionDTO, Decision>(objDTO, decision);
                    decision.TrackingState = TrackableEntities.TrackingState.Modified;

                    foreach (var referenceItem in decision.ReferenceItems)
                    {
                        if (referenceItem.Id == 0)
                        {
                            referenceItem.TrackingState = TrackableEntities.TrackingState.Added;
                        }
                        else
                        {
                            referenceItem.TrackingState = TrackableEntities.TrackingState.Modified;
                        }
                    }

                    foreach (var decisionExecution in decision.DecisionExecutions)
                    {
                        if (decisionExecution.Id == 0)
                        {
                            decisionExecution.TrackingState = TrackableEntities.TrackingState.Added;
                        }
                        else
                        {
                            decisionExecution.TrackingState = TrackableEntities.TrackingState.Modified;
                        }
                    }

                    base.InsertOrUpdateGraph(decision);

                    if (_unitOfWork.SaveChanges() > 0)
                    {
                        ///decision File
                        var    decisionPath = ConfigurationManager.AppSettings["DecisionPath"] + "//" + decision.Id;
                        string fileToCopy   = String.Format("{0}//{1}//{2}", ConfigurationManager.AppSettings["TempDecisonPath"], currentuserId, objDTO.DecisionPath.Replace("\"", ""));
                        if (File.Exists(fileToCopy))
                        {
                            if (!Directory.Exists(decisionPath))
                            {
                                Directory.CreateDirectory(decisionPath);
                            }
                            File.Copy(fileToCopy, decisionPath + "//" + Path.GetFileName(fileToCopy));
                            File.Delete(fileToCopy);
                            Directory.Delete(Path.GetDirectoryName(fileToCopy));
                            decision.DecisionPath = String.Format("{0}//{1}", decision.Id, Path.GetFileName(fileToCopy));
                        }
                        decId = decision.Id;
                        _unitOfWork.SaveChanges();
                        var attachmentNotRequirdIds = _referenceTypeRepository.Query().SelectQueryable().Where(c => c.IsReferenceDecision).Select(c => c.Id).ToList();
                        objDTO.ReferenceItems.Where(c => !attachmentNotRequirdIds.Contains(c.ReferenceTypeId)).Where(c => c.Path != "").ToList().ForEach(c =>
                        {
                            decision
                            .ReferenceItems
                            .Where(d => d.RefereceItemNo == c.RefereceItemNo).FirstOrDefault()
                            .Path = CopyAttachment(
                                currentuserId,
                                c.Path,
                                decision.Id,
                                decision.ReferenceItems.Where(d => d.RefereceItemNo == c.RefereceItemNo).FirstOrDefault().Id);

                            _unitOfWork.SaveChanges();
                        });
                    }

                    foreach (DecisionExecutionDTO execution in objDTO.DecisionExecutions)
                    {
                        List <int> enumForinfoList = new List <int>()
                        {
                            (int)EnumActionType.Inform, (int)EnumActionType.Save, (int)EnumActionType.Review
                        };
                        var          emp = _employeeService.GetByUserId(_departmentCoordinatorRepository.Query().SelectQueryable().Where(c => c.DepartmentId == execution.DepartmentId).FirstOrDefault().UserId);
                        Notification generatedNotification;
                        if (!enumForinfoList.Contains(execution.ActionType))
                        {
                            generatedNotification = _notificationBLL.AddNotification(emp, null, EnumerationExtension.Description(EnumNotificationType.DecisionExecution), objDTO.Subject, objDTO.ExecutionDate.Value, (int)EnumNotificationType.DecisionExecution);
                        }
                        else
                        {
                            generatedNotification = _notificationBLL.AddNotification(emp, null, EnumerationExtension.Description(EnumNotificationType.DecsionForInform), objDTO.Subject, objDTO.ExecutionDate.Value, (int)EnumNotificationType.DecsionForInform);
                        }
                        generatedNotification.DecisionId = decId;
                        _unitOfWork.SaveChanges();
                        if (execution.Id == 0)
                        {
                            if (Mail.SendEmail(_notificationBLL.GetById(generatedNotification.Id), EnumerationExtension.Description((EnumActionType)execution.ActionType), emp.Email))
                            {
                                _notificationBLL.NotificationIsSend(generatedNotification.Id);
                                generatedNotification.DecisionId = decId;
                                _unitOfWork.SaveChanges();
                            }
                        }
                    }
                    _unitOfWork.Commit();
                    return(decision.Id);
                }
                else
                {
                    throw new ValidationException("dublicate Decision Number");
                }
            }

            catch (Exception ex)
            {
                throw ex;
            }
        }