public ApiResponse Add(Guid communityId, MaintenanceSetup maintenanceSetup)
        {
            var validationError = ValidateCreate(maintenanceSetup);

            if (validationError.Count() == 0)
            {
                maintenanceSetup.Id          = Guid.NewGuid();
                maintenanceSetup.CommunityId = communityId;
                if (maintenanceSetup.CalculationMethod == 1)
                {
                    maintenanceSetup.SquareFeetRate = null;
                    maintenanceSetup.SFTRoundOff    = null;
                }
                if (maintenanceSetup.CalculationMethod == 2)
                {
                    maintenanceSetup.FixedRate = null;
                }
                if (maintenanceSetup.CalculationMethod == 3)
                {
                    maintenanceSetup.SquareFeetRate = null;
                    maintenanceSetup.SFTRoundOff    = null;
                    maintenanceSetup.FixedRate      = null;
                }
                _faciTechDbContext.MaintenanceSetup.Add(maintenanceSetup);
                _faciTechDbContext.SaveChanges();
                return(new ApiResponse(new { Id = maintenanceSetup.Id }));
            }
            return(new ApiResponse(validationError));
        }
        private List <ErrorInfo> ValidateCreate(MaintenanceSetup maintenanceSetup)
        {
            List <ErrorInfo> errorInfos = new List <ErrorInfo>();

            if (maintenanceSetup.PaymentFrequency < 0)
            {
                errorInfos.Add(new ErrorInfo()
                {
                    Key         = "PaymentFrequency",
                    Code        = "INVALID_VALUE_ERROR",
                    Description = "Invalid value for payment frequency"
                });
            }
            if (maintenanceSetup.CalculationMethod < 0)
            {
                errorInfos.Add(new ErrorInfo()
                {
                    Key         = "CalculationMethod",
                    Code        = "INVALID_VALUE_ERROR",
                    Description = "Invalid value for calculation method"
                });
            }
            if (maintenanceSetup.CalculationMethod == 1 && !maintenanceSetup.FixedRate.HasValue)
            {
                errorInfos.Add(new ErrorInfo()
                {
                    Key         = "FixedRate",
                    Code        = "MISSING_VALUE",
                    Description = "Missing value for Fixed Rate"
                });
            }
            if (maintenanceSetup.CalculationMethod == 2)
            {
                if (!maintenanceSetup.SquareFeetRate.HasValue)
                {
                    errorInfos.Add(new ErrorInfo()
                    {
                        Key         = "SquareFeetRate",
                        Code        = "MISSING_VALUE",
                        Description = "Missing value for Square feet rate"
                    });
                }
                if (!maintenanceSetup.SFTRoundOff.HasValue)
                {
                    errorInfos.Add(new ErrorInfo()
                    {
                        Key         = "SFTRoundOff",
                        Code        = "MISSING_VALUE",
                        Description = "Missing value for Round off"
                    });
                }
            }
            return(errorInfos);
        }
 public ActionResult GetSingle(Guid id)
 {
     try
     {
         ApiResponse      apiResponse      = this._maintenanceSetupService.GetSingle(id);
         MaintenanceSetup maintenanceSetup = apiResponse.GetData <MaintenanceSetup>();
         var maintenanceSetupApiModel      = _maintenanceSetupMapper.Map(maintenanceSetup);
         return(Ok(maintenanceSetupApiModel));
     }
     catch (Exception ex)
     {
         return(new UnknownErrorResult(ex, base._errorEnabled));
     }
 }
        public MaintenanceSetup Map(MaintenanceSetupApiModel maintenanceSetupApiModel, MaintenanceSetup maintenanceSetup = null)
        {
            if (maintenanceSetup == null)
            {
                maintenanceSetup = new MaintenanceSetup();
            }
            var paymentFrequency  = GetPaymentFrequencyValue(maintenanceSetupApiModel.PaymentFrequency);
            var calculationMethod = GetCalculationMethodValue(maintenanceSetupApiModel.CalculationMethod);

            maintenanceSetup.PaymentFrequency  = paymentFrequency.HasValue?paymentFrequency.Value:-1;
            maintenanceSetup.CalculationMethod = calculationMethod.HasValue? calculationMethod.Value:-1;
            maintenanceSetup.FixedRate         = maintenanceSetupApiModel.FixedRate;
            maintenanceSetup.SquareFeetRate    = maintenanceSetupApiModel.SquareFeetRate;
            maintenanceSetup.SFTRoundOff       = GetRoundOffValue(maintenanceSetupApiModel.SFTRoundOffMethod);

            return(maintenanceSetup);
        }
 public MaintenanceSetupApiModel Map(MaintenanceSetup maintenanceSetup, MaintenanceSetupApiModel maintenanceSetupApiModel = null)
 {
     if (maintenanceSetupApiModel == null)
     {
         maintenanceSetupApiModel = new MaintenanceSetupApiModel();
     }
     maintenanceSetupApiModel.PaymentFrequency  = GetPaymentFrequencyName(maintenanceSetup.PaymentFrequency);
     maintenanceSetupApiModel.CalculationMethod = GetCalculationMethodName(maintenanceSetup.CalculationMethod);
     maintenanceSetupApiModel.FixedRate         = maintenanceSetup.FixedRate;
     maintenanceSetupApiModel.SquareFeetRate    = maintenanceSetup.SquareFeetRate;
     if (maintenanceSetup.SFTRoundOff.HasValue)
     {
         maintenanceSetupApiModel.SFTRoundOffMethod = GetRoundOffName(maintenanceSetup.SFTRoundOff.Value);
     }
     maintenanceSetupApiModel.Id          = maintenanceSetup.Id.ToString();
     maintenanceSetupApiModel.CommunityId = maintenanceSetup.CommunityId;
     return(maintenanceSetupApiModel);
 }
        public ActionResult Update(Guid id, MaintenanceSetupApiModel maintenanceSetupApiModel)
        {
            try
            {
                ApiResponse serviceResponse = this._maintenanceSetupService.GetSingle(id);
                if (serviceResponse.IsSuccess() == false)
                {
                    return(new ObjectNotFoundResult(serviceResponse));
                }

                MaintenanceSetup maintenanceSetup = serviceResponse.GetData <MaintenanceSetup>();
                _maintenanceSetupMapper.Map(maintenanceSetupApiModel, maintenanceSetup);
                serviceResponse = this._maintenanceSetupService.Update(maintenanceSetup);
                return(SendResponse(serviceResponse));
            }
            catch (Exception ex)
            {
                return(new UnknownErrorResult(ex, base._errorEnabled));
            }
        }
        public ApiResponse Update(MaintenanceSetup maintenanceSetup)
        {
            var validationError = ValidateUpdate(maintenanceSetup);

            if (validationError.Count() == 0)
            {
                if (maintenanceSetup.CalculationMethod != 3)
                {
                    var rates = _faciTechDbContext
                                .MaintenanceRate
                                .Where(c => c.MaintenanceSetupId == maintenanceSetup.Id);
                    foreach (var item in rates)
                    {
                        _faciTechDbContext.MaintenanceRate.Remove(item);
                    }
                }
                _faciTechDbContext.SaveChanges();
                return(new ApiResponse(new { Id = maintenanceSetup.Id }));
            }
            return(new ApiResponse(validationError));
        }
        public decimal Calculate(Unit unit)
        {
            var squareFeetArea = unit.Area.HasValue ? unit.Area.Value : 0;

            if (maintenanceSetup == null)
            {
                maintenanceSetup = _faciTechDbContext
                                   .MaintenanceSetup
                                   .Include("MaintenanceRate")
                                   .Where(e => e.CommunityId == _communityId)
                                   .FirstOrDefault();
            }
            switch (maintenanceSetup.CalculationMethod)
            {
            case 0:
            {
                return(maintenanceSetup.FixedRate.HasValue ? maintenanceSetup.FixedRate.Value : 0);
            }

            case 1:
            {
                var rate = maintenanceSetup.SquareFeetRate.HasValue ? maintenanceSetup.SquareFeetRate.Value : 0;
                return(rate * squareFeetArea);
            }

            case 2:
            {
                var rateRange = maintenanceSetup.MaintenanceRate
                                .Where(e => squareFeetArea >= e.SqureFeetFrom && squareFeetArea <= e.SqureFeetTo)
                                .FirstOrDefault();
                if (rateRange != null)
                {
                    return(rateRange.MaintenanceAmount * squareFeetArea);
                }
                return(0);
            }
            }
            return(0);
        }
        private List <ErrorInfo> ValidateUpdate(MaintenanceSetup maintenanceSetup)
        {
            List <ErrorInfo> errorInfos = new List <ErrorInfo>();

            return(errorInfos);
        }