public async Task<ApiResponse<PCalcResultInfo>> UpdateWeight(UpdateRequest updateWeightRequest)
        {
            RestRequest request = GetNewRequest();
            request.Resource = "UpdateWeight";
            request.Method = Method.POST;
            request.AddBody(updateWeightRequest);

            return await Execute<PCalcResultInfo>(request, m_Api, string.Empty);
        }
        public async Task<ApiResponse<PCalcResultInfo>> StepBack(UpdateRequest stepBackRequest)
        {
            RestRequest request = GetNewRequest();
            request.Resource = "Back";
            request.Method = Method.POST;
            request.AddBody(stepBackRequest);

            return await Execute<PCalcResultInfo>(request, m_Api, string.Empty);
        }
        public async Task<ActionResult> UpdateWeight([Bind(Include = "WeightValueInGram,WeightValueInOunces,CultureIsMetric,ProductCalculationFinished")]UpdateWeightViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return HandleGeneralError("Index", ProductCalculationViewModel.Create(EQueryType.None), "Unspecified error");
            }
            PCalcResultInfo lastResult = GetLastPcalcResult();
            if (null == lastResult)
            {
                return HandleGeneralError("Index", ProductCalculationViewModel.Create(EQueryType.None), "Unable to retrieve last result");
            }
            UpdateRequest request = new UpdateRequest();
            EnvironmentInfo environment = GetEnvironment();
            if (null == environment)
            {
                return HandleGeneralError("Index", ProductCalculationViewModel.Create(EQueryType.None), "Unable to create environment");
            }
            request.Environment = environment;
            request.ProductDescription = lastResult.ProductDescription;
            int weightValue = (int)(model.WeightValue * 10);
            request.ProductDescription.Weight = new WeightInfo()
            {
                WeightValue = weightValue,
                WeightUnit = model.CultureIsMetric ? EWeightUnit.TenthGram : EWeightUnit.TenthOunce
            };

            ApiResponse<PCalcResultInfo> response = await m_Repository.UpdateWeight(request);
            if(IsApiError(response))
            {
                return HandleGeneralPcalcError("Index", ProductCalculationViewModel.Create(EQueryType.None), response.ApiResult);
            }

            //update weight will only update the product description if the weight is valid
            response.ApiResult.QueryDescription = response.ApiResult.QueryDescription == null ? 
                lastResult.QueryDescription : response.ApiResult.QueryDescription;
            response.ApiResult.QueryType = response.ApiResult.QueryType == EQueryType.None ? 
                lastResult.QueryType : response.ApiResult.QueryType;
            if (PcalcResultIsValid(response.ApiResult) == false)
            {
                return HandleGeneralPcalcError("Index", ProductCalculationViewModel.Create(EQueryType.None), response.ApiResult);
            }
            AddOrUpdateTempData(response.ApiResult, request.Environment);
            AddViewData(response.ApiResult, environment);
            ProductCalculationViewModel newModel = ProductCalculationViewModel.Create(response.ApiResult.QueryType);
            newModel.ProductCalculationFinished = model.ProductCalculationFinished;
            return View("Index", newModel);            
        }
        public async Task<ActionResult> StepBack()
        {
            PCalcResultInfo lastResult = GetLastPcalcResult();
            if (null == lastResult)
            {
                return HandleGeneralError("Index", ProductCalculationViewModel.Create(EQueryType.None), "Unable to retrieve last result");
            }
            UpdateRequest request = new UpdateRequest();
            EnvironmentInfo environment = GetEnvironment();
            if (null == environment)
            {
                return HandleGeneralError("Index", ProductCalculationViewModel.Create(EQueryType.None), "Unable to create environment");
            }
            request.Environment = environment;
            request.ProductDescription = lastResult.ProductDescription;
            ApiResponse<PCalcResultInfo> response = await m_Repository.StepBack(request);
            if (IsApiError(response) || PcalcResultIsValid(response.ApiResult) == false)
            {
                return HandleGeneralPcalcError("Index", ProductCalculationViewModel.Create(EQueryType.None), response.ApiResult);
            }

            AddOrUpdateTempData(response.ApiResult, request.Environment);
            AddViewData(response.ApiResult, environment);
            return View("Index", ProductCalculationViewModel.Create(response.ApiResult.QueryType));
        }
 public async Task<IHttpActionResult> UpdateWeight(UpdateRequest updateRequest)
 {
     if (!ModelState.IsValid)
     {
         return BadRequest(ModelState);
     }
     PCalcResultInfo result = await m_Calculator.UpdateWeight(updateRequest.Environment, updateRequest.ProductDescription);
     return CreateProductCalculationResponse(result);
 }