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);
