public async Task <AOResult> CreateAsync(DishModel dish) { var result = new AOResult(); try { var content = new { Name = dish.Name, DishCategory = dish.CategoryType }; var response = await _baseService.PostAsync <ResponseModel>(NameController, content); if (response != null) { if (response.IsSuccess) { result.SetSuccess(); } else { result.SetFailure(); } } } catch (Exception ex) { result.SetError(nameof(CreateAsync), ex.Message, ex); } return(result); }
protected async Task <AOResult <T> > BaseInvokeAsync <T>(Func <AOResult <T>, Task> func, object request = null, [CallerMemberName] string callerName = null, [CallerFilePath] string callerFile = null, [CallerLineNumber] int callerLineNumber = 0) { AOResult <T> aoResult = new AOResult <T>(callerName, callerFile, callerLineNumber); try { List <ValidationResult> checkModelAOResult = CheckRequest(request); if (checkModelAOResult.Any()) { aoResult.SetError(ModelIsNotValidErrorMessage, checkModelAOResult.Select(x => new Error { Key = x.MemberNames.FirstOrDefault(), Message = x.ErrorMessage })); } else { await func(aoResult); } } catch (DbUpdateException dbException) { aoResult.SetError(dbException.Message, ex: dbException); } catch (Exception ex) { aoResult.SetError(ex.Message, ex: ex); } return(aoResult); }
/// <summary> /// Bases the invoke. /// </summary> /// <returns>The invoke.</returns> /// <param name="func">Func.</param> /// <param name="request">Request.</param> /// <typeparam name="TReturn">The 1st type parameter.</typeparam> protected AOResult <TReturn> BaseInvokeWithTransaction <TReturn>(Func <AOResult <TReturn> > func, object request = null) { using (var transaction = _myHelperDbContext.Database.BeginTransaction()) { try { if (request != null) { AOResult <TReturn> checkModelResult = CheckModel <TReturn>(request); if (!checkModelResult.IsSuccess) { return(checkModelResult); } } AOResult <TReturn> result = func(); transaction.Commit(); return(result); } catch (Exception ex) { transaction.Rollback(); return(AOBuilder.SetError <TReturn>(ex.Message)); } } }
public void UpdateProductPrice(object state) => BaseInvoke <object>((aoResult) => { AOResult <IEnumerable <ProductFullModel> > resultParse = _htmlParserService.GetProductsFromShopHtmlAsync().Result; if (resultParse.IsSuccess) { var optionsBuilder = new DbContextOptionsBuilder <InternetShopDbContext>(); optionsBuilder.UseNpgsql(ConnectionString); using (var _dbContext = new InternetShopDbContext(optionsBuilder.Options)) { var productList = _dbContext.Products.ToList(); foreach (var productModel in resultParse.Result) { var product = productList.FirstOrDefault(x => x.Name.Contains(productModel.Name)); if (product != null && product.Price != productModel.Price) { product.Price = productModel.Price; _dbContext.ProductUpdetePrices.Add(new ProductUpdetePrice() { DateUpdate = _dateTimeProvider.UtcNow, PriceUpdate = product.Price, Product = product }); } } _dbContext.SaveChanges(); } } });
private async Task <AOResult <T> > RequestAsync <T>(RequstType requestType, string resource, object requestBody, TimeSpan experation, StorageType storageType, string callMethodName) { var aoResult = new AOResult <T>(); T result = default(T); try { switch (requestType) { case RequstType.Post: result = await RestService.PostAsync <T>(resource, requestBody); break; case RequstType.Get: result = await RestService.GetAsync <T>(resource); break; case RequstType.GetWithCache: result = await RestService.GetAsyncWithCashe <T>(resource, experation, storageType); break; case RequstType.Put: result = await RestService.PutAsync <T>(resource, requestBody); break; case RequstType.Delete: result = await RestService.DeleteAsync <T>(resource, requestBody); break; default: throw new InvalidOperationException("Wrong request type"); } aoResult.SetSuccess(result); } catch (WebException ex) { ErrorsTracker.TrackError(ex, ex.Message); aoResult.SetError(callMethodName + "_exception", ex.Message, ex); Debug.WriteLine("## Error rest service || " + callMethodName + " **** " + resource); } catch (HttpRequestException ex) { ErrorsTracker.TrackError(ex, ex.Message); aoResult.SetError(callMethodName + "_exception", ex.Message, ex); Debug.WriteLine("## Error rest service || " + callMethodName + " **** " + resource); } catch (Exception ex) { ErrorsTracker.TrackError(ex, ex.Message); throw; } return(aoResult); }
/// <summary> /// AOResult to server response. /// </summary> /// <returns>Ther esult to server response.</returns> /// <param name="aoResult">Ao result.</param> protected ServerResponse AOResultToServerResponse(AOResult aoResult) { return(new ServerResponse() { IsSuccess = aoResult.IsSuccess, Message = aoResult.Message, ErrorId = aoResult.ErrorId, Errors = aoResult.Errors?.ToDictionary(x => x.Key, x => x.Value) }); }
private ServerResponse <TOut> AoResultToServerResponse <TIn, TOut>(AOResult <TIn> aoResult) { var serverResponse = new ServerResponse <TOut> { Ok = aoResult.IsSuccess, Message = aoResult.Message, Errors = aoResult.Errors, Code = aoResult.Code, Result = _mapper.Map <TOut>(aoResult.Result), }; return(serverResponse); }
protected async Task <AOResult <T> > BaseInvokeAsync <T>(Func <AOResult <T>, Task> action) { AOResult <T> aoResult = new AOResult <T>(); try { await action(aoResult); } catch (Exception ex) { aoResult.SetError(null, ex.Message, ex); } return(aoResult); }
protected AOResult <T> BaseInvoke <T>(Action <AOResult <T> > action) { AOResult <T> aoResult = new AOResult <T>(); try { action(aoResult); } catch (Exception ex) { aoResult.SetError(null, ex.Message, ex); } return(aoResult); }
public async Task <AOResult <IEnumerable <ProductFullModel> > > GetProductsFromShopHtmlAsync() => await BaseInvokeAsync <IEnumerable <ProductFullModel> >(async (aoResult) => { List <ProductFullModel> productList = new List <ProductFullModel>(); for (int i = _storeParserProvider.GetStartPage(); i <= _storeParserProvider.GetEndPage(); i++) { AOResult <string> sourceHtml = await _sourceHtmlLoaderService.GetSourcePageAsync(i); if (sourceHtml.IsSuccess) { IHtmlDocument htmlDocument = await GetHtmlDocumentFromSourceAsync(sourceHtml.Result); productList.AddRange(Parse(htmlDocument)); } } aoResult.SetSuccess(productList); });
/// <summary> /// Bases the invoke. /// </summary> /// <returns>The invoke.</returns> /// <param name="func">Func.</param> /// <param name="request">Request.</param> /// <typeparam name="TReturn">The 1st type parameter.</typeparam> protected AOResult <TReturn> BaseInvokeWithTransactionPassModel <TReturn>(Func <AOResult <TReturn>, AOResult <TReturn> > func, object request) { using (var transaction = _myHelperDbContext.Database.BeginTransaction()) { try { AOResult <TReturn> result = func(CheckModel <TReturn>(request)); transaction.Commit(); return(result); } catch (Exception ex) { transaction.Rollback(); return(AOBuilder.SetError <TReturn>(ex.Message)); } } }
public async Task <AOResult> LogoutAsync() { var res = new AOResult(); try { //Implement logout logic await Task.Delay(500); res.SetSuccess(); } catch (Exception ex) { res.SetError(nameof(LogoutAsync), ex.Message, ex); } return(res); }
public TokenResponseModel Post([FromBody] CreateHeroRequest createHeroRequest) { TokenResponseModel token = null; try { AOResult <HeroUnitModel> heroResult = _heroService.CreateHero(createHeroRequest); if (heroResult.IsSuccess) { token = _tokenService.CreateTokenAsync(heroResult.Result.Name); } } catch (Exception ex) { throw new Exception(ex.Message + " hero not created"); } return(token); }
/// <summary> /// Bases the invoke. /// </summary> /// <returns>The invoke.</returns> /// <param name="func">Func.</param> /// <param name="request">Request.</param> /// <typeparam name="TReturn">The 1st type parameter.</typeparam> protected AOResult <TReturn> BaseInvoke <TReturn>(Func <AOResult <TReturn> > func, object request = null) { try { if (request != null) { AOResult <TReturn> checkModelResult = CheckModel <TReturn>(request); if (!checkModelResult.IsSuccess) { return(checkModelResult); } } return(func()); } catch (Exception ex) { return(AOBuilder.SetError <TReturn>(ex.Message)); } }
/// <summary> /// Bases the invoke. /// </summary> /// <returns>The invoke.</returns> /// <param name="func">Func.</param> /// <param name="request">Request.</param> protected async Task <AOResult> BaseInvoke(Func <Task <AOResult> > func, object request = null) { try { if (request != null) { AOResult checkModelResult = CheckModel(request); if (!checkModelResult.IsSuccess) { return(checkModelResult); } } return(await func()); } catch (Exception ex) { return(AOBuilder.SetError(ex.Message)); } }
public ServerResponse <object> Map(AOResult <object> aoResult) => AoResultToServerResponse <object, object>(aoResult);
public ServerResponse <ProductFullView> Map(AOResult <ProductFullModel> aoResult) => AoResultToServerResponse <ProductFullModel, ProductFullView>(aoResult);
public ServerResponse <ProductUpdetePriceSearchView> Map(AOResult <ProductUpdetePriceSearchModel> aoResult) => AoResultToServerResponse <ProductUpdetePriceSearchModel, ProductUpdetePriceSearchView>(aoResult);