Exemplo n.º 1
0
        public async Task <IActionResult> GetActiveRateCategory([FromBody] int hotelId)
        {
            BaseResult <List <RateCategoryViewModel> > responseResult = new BaseResult <List <RateCategoryViewModel> >();

            if (hotelId <= default(int))
            {
                responseResult.IsError = true;
                responseResult.Message = string.Format(coreHelper.Constants.ErrorMessage.InvalidId, hotelId);
                return(BadRequest(responseResult));
            }
            BaseResult <List <RateCategory> > activeRateCategoryResult = new BaseResult <List <RateCategory> >();

            activeRateCategoryResult = await iRatesCategory.GetActiveRateCategory(hotelId);

            if (activeRateCategoryResult.IsError && activeRateCategoryResult.ExceptionMessage != null)
            {
                return(new StatusCodeResult(500));
            }
            else if (activeRateCategoryResult.Result == null || !activeRateCategoryResult.Result.Any())
            {
                return(NoContent()); //204
            }
            responseResult.Result = RatesCategoryResponseMapper.MapToRateCategoryViewModel(activeRateCategoryResult.Result);
            return(Ok(responseResult));
        }
        /// <summary>
        /// Return the list of Markets
        /// </summary>
        /// <returns></returns>
        public async Task <IActionResult> GetMarkets()
        {
            BaseResult <List <MarketViewModel> > marketResultFromCache = new BaseResult <List <MarketViewModel> >
            {
                Result = RedisCacheHelper.Instance.Get <List <MarketViewModel> >(Constants.CacheKeys.MarketList)
            };

            if (marketResultFromCache.Result == null || marketResultFromCache.Result.Count == 0)
            {
                BaseResult <List <Market> > marketResult = await iRatesCategory.GetMarkets().ConfigureAwait(false);

                if (marketResult.IsError && marketResult.ExceptionMessage != null)
                {
                    return(new StatusCodeResult(500));
                }
                else if (marketResult.Result == null || marketResult.Result.Count == 0)
                {
                    return(NoContent()); //204
                }
                else
                {
                    var result = RatesCategoryResponseMapper.MapMarket(marketResult);
                    RedisCacheHelper.Instance.Set <List <MarketViewModel> >(Constants.CacheKeys.MarketList, result.Result);
                    return(Ok(result)); //200
                }
            }
            return(Ok(marketResultFromCache)); //200
        }
Exemplo n.º 3
0
        /// <summary>
        /// Return the list of Markets
        /// </summary>
        /// <returns></returns>
        public async Task <IActionResult> GetMarkets()
        {
            BaseResult <List <Market> > marketResult = await iRatesCategory.GetMarkets().ConfigureAwait(false);

            if (marketResult.IsError && marketResult.ExceptionMessage != null)
            {
                return(new StatusCodeResult(500));
            }
            else if (marketResult.Result == null || marketResult.Result.Count == 0)
            {
                return(NoContent()); //204
            }
            var result = RatesCategoryResponseMapper.MapMarket(marketResult);

            return(Ok(result)); //200
        }
        public async Task <IActionResult> GetRateCategoryById([FromBody] int rateCategoryId)
        {
            BaseResult <RateCategoryViewModel> rateCategoryViewModelResult = new BaseResult <RateCategoryViewModel>();
            BaseResult <List <RateCategory> >  rateCategoryResult          = new BaseResult <List <RateCategory> >();
            BaseResult <List <RatePlans> >     ratePlansResult             = new BaseResult <List <RatePlans> >();
            RateCategory rateCategoryRequest = new RateCategory();

            if (rateCategoryId <= default(int))
            {
                rateCategoryResult.IsError = true;
                rateCategoryResult.Message = string.Format(coreHelper.Constants.ErrorMessage.InvalidId, rateCategoryId);
                return(BadRequest(rateCategoryResult));
            }

            rateCategoryResult = await iRatesCategory.GetRateCategoryById(rateCategoryId).ConfigureAwait(false);

            if (rateCategoryResult.IsError && rateCategoryResult.ExceptionMessage != null)
            {
                return(new StatusCodeResult(500));
            }
            else if (rateCategoryResult.Result == null)
            {
                return(new NoContentResult()); //204
            }

            ratePlansResult = await iRatesCategory.GetRatePlansById(rateCategoryId).ConfigureAwait(false);

            if (ratePlansResult.IsError && ratePlansResult.ExceptionMessage != null)
            {
                return(new StatusCodeResult(500));
            }

            rateCategoryRequest = rateCategoryResult.Result.First();

            var result = RatesCategoryResponseMapper.MapToRateCategoryViewModel(rateCategoryRequest, ratePlansResult.Result);

            rateCategoryViewModelResult.Result = result;
            return(Ok(rateCategoryViewModelResult));
        }
        public async Task <IActionResult> GetRateCategory([FromBody] int hotelId)
        {
            if (hotelId <= default(int))
            {
                return(BadRequest());
            }
            BaseResult <List <RateCategoryList> > rateCategoryResult = new BaseResult <List <RateCategoryList> >();

            rateCategoryResult = await iRatesCategory.GetRateCategory(hotelId);

            if (rateCategoryResult.IsError && rateCategoryResult.ExceptionMessage != null)
            {
                return(new StatusCodeResult(500));
            }
            else if (!rateCategoryResult.Result.Any())
            {
                return(NoContent()); //204
            }
            var responseResult = RatesCategoryResponseMapper.MapRateCategoryList(rateCategoryResult.Result);

            return(Ok(responseResult));
        }