Example #1
0
        public async Task <ActionResult> AddEditPrePlanning(string id)
        {
            try
            {
                PrePlanningModel model = await PrepareEditingDataAsync(id);
                await FillLookUpsAsync(model, id);

                return(View(model));
            }
            catch (BusinessRuleException ex)
            {
                AddError(ex.Message);
                PrePlanningModel model = await PrepareEditingDataAsync(id);
                await FillLookUpsAsync(model, id);

                return(View(model));
            }
            catch (AuthorizationException ex)
            {
                AddError(ex.Message);
                return(RedirectToAction(nameof(Index)));
            }
            catch (UnHandledAccessException ex)
            {
                AddError(ex.Message);
                return(RedirectToAction(nameof(Index)));
            }
            catch (Exception e)
            {
                AddError(Resources.TenderResources.ErrorMessages.UnexpectedError);
                return(RedirectToAction(nameof(Index)));
            }
        }
Example #2
0
        public async Task <PrePlanningModel> CreateAsync(PrePlanningModel model)
        {
            Check.ArgumentNotNull(nameof(model), model);
            PrePlanning planning;
            await _prePlanningDomainService.CheckNameExist(model.ProjectName, model.BranchId, model.YearQuarterId, model.AgencyCode, model.PrePlanningId);

            if (model.PrePlanningId == 0)
            {
                planning = new PrePlanning(model.PrePlanningId, model.AgencyCode, model.BranchId, model.ProjectName, model.ProjectNature, model.ProjectTypeId, model.ProjectDescription, model.InsideKSA, (int)Enums.PrePlanningStatus.UnderUpdate, model.Duration, model.DurationInDays, model.DurationInMonths, model.DurationInYears, model.YearQuarterId);
                planning.IsDurationValid();
                planning.AddtAreasCountriesTypes(model.PrePlanningAreaIDs, model.InsideKSA, model.PrePlanningCountriesIDs, model.ProjectTypesIDs);
                planning = await _genericCommandRepository.CreateAsync <PrePlanning>(planning);
            }
            else
            {
                planning = await _prePlanningQueries.FindByIdForEdit(model.PrePlanningId);

                if (planning.StatusId == (int)Enums.PrePlanningStatus.Pending || planning.StatusId == (int)Enums.PrePlanningStatus.Rejected)
                {
                    throw new UnHandledAccessException();
                }
                planning.Update(model.AgencyCode, model.ProjectName, model.ProjectNature, model.ProjectDescription, model.InsideKSA, (int)Enums.PrePlanningStatus.UnderUpdate, model.Duration, model.DurationInDays, model.DurationInMonths, model.DurationInYears, model.YearQuarterId);
                planning.IsDurationValid();
                planning = planning.UpdatetAreasCountriesTypes(model.PrePlanningAreaIDs, model.InsideKSA, model.PrePlanningCountriesIDs, model.ProjectTypesIDs);
                _genericCommandRepository.Update <PrePlanning>(planning);
            }
            await _genericCommandRepository.SaveAsync();

            model.PrePlanningId = planning.PrePlanningId;
            return(model);
        }
        public async Task <PrePlanningModel> Add([FromBody] PrePlanningModel model)
        {
            model.AgencyCode = User.UserAgency();
            model.BranchId   = User.UserBranch();
            PrePlanningModel PreplanningModel = await _prePlanningAppService.CreateAsync(model);

            return(PreplanningModel);
        }
Example #4
0
        public async Task <PrePlanningModel> SetPrePlanningLookUps()
        {
            PrePlanningModel preplanning = await _prePlanningQueries.SetPrePlanningLookUps();

            if (preplanning == null)
            {
                throw new UnHandledAccessException();
            }
            return(preplanning);
        }
Example #5
0
        public async Task <PrePlanningModel> GetPrePlanningDetailsById(int id)
        {
            PrePlanningModel preplanning = await _prePlanningQueries.GetPrePlanningDetailsById(id);

            if (preplanning == null)
            {
                throw new UnHandledAccessException();
            }
            return(preplanning);
        }
Example #6
0
 public async Task ShouldCreateAsyncThrowException_When_DurationInDaysLessThanZero()
 {
     PrePlanningModel model = new PrePlanningModel()
     {
         PrePlanningId = 0,
         BranchId      = 1,
         YearQuarterId = 1,
         ProjectName   = "ProjectName",
         AgencyCode    = "1"
     };
     await Assert.ThrowsAsync <BusinessRuleException>(async() => await _sut.CreateAsync(model));
 }
Example #7
0
        private async Task FillLookUpsAsync(PrePlanningModel model, string id)
        {
            PrePlanningLookUpsModels lookUps = await _cache.GetOrCreateAsync(CacheKeys.PrePlanningCache /* + "_" + HttpContext.Session.Id*/, async entry =>
            {
                int minutes             = int.Parse(_rootConfiguration.CachingConfiguration.CachingMinutes /*_configuration.GetSection("Chaching:CachingMinutes").Value*/);
                entry.SlidingExpiration = TimeSpan.FromMinutes(minutes);
                return(await _ApiClient.GetAsync <PrePlanningLookUpsModels>("Lookup/GetPrePlanningLookups", null));
            });

            List <SelectListItem> activitiesItems = new List <SelectListItem>();

            foreach (var item in lookUps.ProjectTypes)
            {
                var group = new SelectListGroup {
                    Name = item.Name
                };
                foreach (var sub in item.SubActivities)
                {
                    activitiesItems.Add(new SelectListItem {
                        Value = sub.ActivityId.ToString(), Text = sub.Name, Group = group
                    });
                }
            }
            List <LookupModel> yearQuarter = new List <LookupModel>(lookUps.YearQuarters);;

            model.ProjectTypesList      = activitiesItems;
            model.YearQuarters          = yearQuarter;
            model.Areas                 = lookUps.Areas;
            model.Countries             = lookUps.Countries;
            model.EncyptedPrePlanningId = id;

            if (DateTime.Now.Month == 4 || DateTime.Now.Month == 5 || DateTime.Now.Month == 6)
            {
                model.YearQuarters.Remove(model.YearQuarters[0]);
            }
            else if (DateTime.Now.Month == 7 || DateTime.Now.Month == 8 || DateTime.Now.Month == 9)
            {
                model.YearQuarters.Remove(model.YearQuarters[0]);
                model.YearQuarters.Remove(model.YearQuarters[0]);
            }
            else if (DateTime.Now.Month == 10 || DateTime.Now.Month == 11 || DateTime.Now.Month == 12)
            {
                model.YearQuarters.Remove(model.YearQuarters[0]);
                model.YearQuarters.Remove(model.YearQuarters[0]);
                model.YearQuarters.Remove(model.YearQuarters[0]);
            }
        }
Example #8
0
        public async Task <PrePlanningModel> SetPrePlanningLookUps()
        {
            var result = new PrePlanningModel
            {
                PrePlanningAreaIDs      = new List <int>(),
                PrePlanningCountriesIDs = new List <int>(),
                ProjectTypesIDs         = new List <int>(),
                Countries = _context.Countries.Select(r => new CountryModel {
                    CountryId = r.CountryId, Name = r.NameAr
                }).ToList(),
                Areas = _context.Areas.Select(r => new LookupModel {
                    Id = r.AreaId, Name = r.NameAr
                }).ToList(),
            };

            return(result);
        }
Example #9
0
 public async Task ShouldCreateAsyncThrowException()
 {
     _moqPrePlanningQueries.Setup(x => x.FindByIdForEdit(It.IsAny <int>(), It.IsAny <int>()))
     .Returns(() =>
     {
         return(Task.FromResult <Core.Entities.PrePlanning>(prePlanningDefaults.GetPrePlanningDataForReOpen()));
     });
     PrePlanningModel model = new PrePlanningModel()
     {
         PrePlanningId  = 1,
         BranchId       = 1,
         YearQuarterId  = 1,
         ProjectName    = "ProjectName",
         AgencyCode     = "1",
         DurationInDays = 1
     };
     await Assert.ThrowsAsync <UnHandledAccessException>(async() => await _sut.CreateAsync(model));
 }
Example #10
0
        private async Task <PrePlanningModel> PrepareEditingDataAsync(string id, PrePlanningModel model = null)
        {
            model = model ?? new PrePlanningModel();
            if (!string.IsNullOrEmpty(id))
            {
                model = await _ApiClient.GetAsync <PrePlanningModel>("PrePlanning/GetPrePlanningModelById/" + Util.Decrypt(id), null);

                if (model.StatusId == (int)Enums.PrePlanningStatus.Pending || model.StatusId == (int)Enums.PrePlanningStatus.Rejected)
                {
                    throw new BusinessRuleException(Resources.SharedResources.ErrorMessages.NotAddedAuthorized);
                }
            }
            else
            {
                model = await _ApiClient.GetAsync <PrePlanningModel>("PrePlanning/SetPrePlanningLookUps", null);
            }
            return(model);
        }
Example #11
0
        public async Task GetPrePlanningDetailsById_Returns_Data()
        {
            var _id = 1;
            var _prePlanningModel = new PrePlanningModel()
            {
                AgencyCode = "018001000000",
                BranchId   = 5,
                InsideKSA  = true,
            };
            var result = await _prePlanningController.GetPrePlanningDetailsById(_id);

            Assert.NotNull(result);
            Assert.IsType <PrePlanningModel>(result);
            Assert.Equal(_prePlanningModel.AgencyCode, result.AgencyCode);
            Assert.NotEmpty(result.PrePlanningAreaIDs);
            Assert.NotEmpty(result.ProjectTypesIDs);
            Assert.True(result.InsideKSA);
        }
Example #12
0
        public async Task ShouldCreateAsyncSuccess()
        {
            _moqPrePlanningQueries.Setup(x => x.FindByIdForEdit(It.IsAny <int>(), It.IsAny <int>()))
            .Returns(() =>
            {
                return(Task.FromResult <Core.Entities.PrePlanning>(prePlanningDefaults.ReturnPrePlanningDefaults()));
            });
            PrePlanningModel model = new PrePlanningModel()
            {
                PrePlanningId  = 1,
                BranchId       = 1,
                YearQuarterId  = 1,
                ProjectName    = "ProjectName",
                AgencyCode     = "1",
                DurationInDays = 1
            };
            await _sut.CreateAsync(model);

            _moqCommandRepository.Verify(g => g.SaveAsync());
        }
Example #13
0
        public async Task <ActionResult> AddEditPrePlanning(PrePlanningModel model)
        {
            if (!ModelState.IsValid)
            {
                AddError(Resources.TenderResources.ErrorMessages.ModelDataError);
                await FillLookUpsAsync(model, model.EncyptedPrePlanningId);

                return(View(model));
            }
            try
            {
                if (!string.IsNullOrEmpty(model.EncyptedPrePlanningId))
                {
                    model.PrePlanningId = Util.Decrypt(model.EncyptedPrePlanningId);
                }
                PrePlanningModel prePlanningModel = await _ApiClient.PostAsync <PrePlanningModel>("PrePlanning/Add", null, model);

                AddMessage(Resources.TenderResources.Messages.DataSaved);
                return(RedirectToAction("Details", new { id = Util.Encrypt(prePlanningModel.PrePlanningId) }));
            }
            catch (BusinessRuleException ex)
            {
                AddError(ex.Message);
            }
            catch (AuthorizationException ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                AddError(Resources.TenderResources.ErrorMessages.UnexpectedError);
            }
            var myModel = PrepareEditingDataAsync(model.EncyptedPrePlanningId, model);

            await FillLookUpsAsync(model, model.EncyptedPrePlanningId);

            return(View(model));
        }
Example #14
0
        public async Task Add_Success()
        {
            var _prePlanningModel = new PrePlanningModel()
            {
                AgencyCode         = "022001000000",
                BranchId           = 1,
                InsideKSA          = true,
                ProjectName        = "Functional Test" + DateTime.Now.Day + DateTime.Now.Hour + DateTime.Now.Millisecond,
                ProjectNature      = "Testing",
                ProjectDescription = "API Functional Test",
                Duration           = "1",
                YearQuarterId      = 4,
                DurationInDays     = 1,
                DurationInMonths   = 2,
                DurationInYears    = 3
            };

            _claims = new Claim[3] {
                new Claim(IdentityConfigs.Claims.BranchId, "1"),
                new Claim(IdentityConfigs.Claims.isSemiGovAgency, "1"),
                new Claim(IdentityConfigs.Claims.SelectedCR, "022001000000")
            };
            _prePlanningController = _prePlanningController.WithIdentity(_claims);

            var result = await _prePlanningController.Add(_prePlanningModel);

            Assert.NotNull(result);
            Assert.IsType <PrePlanningModel>(result);
            Assert.Equal(_prePlanningModel.AgencyCode, result.AgencyCode);
            Assert.Equal(_prePlanningModel.ProjectName, result.ProjectName);
            Assert.Equal(_prePlanningModel.ProjectNature, result.ProjectNature);
            Assert.Equal(_prePlanningModel.ProjectDescription, result.ProjectDescription);
            Assert.Equal(_prePlanningModel.Duration, result.Duration);
            Assert.Equal(_prePlanningModel.YearQuarterId, result.YearQuarterId);
            Assert.True(result.InsideKSA);
        }