public async Task <ActionResult <StudentDto> > GetAsync(Guid?id)
{
if (id is null)
{
return(BadRequest("Corrupted Id"));
}
return((await _studentCrudService.GetByIdAsync(id.Value)).ToDto());
}
public virtual async Task <ActionResult <T2> > GetById(T1 id)
{
try
{
return(Ok(await _service.GetByIdAsync(id)));
}
catch (EntityNotFoundException)
{
return(NotFound());
}
}
/// <summary>
/// 创建，调用范例：POST URL(/api/customers) BODY({name:'a',age:2})
/// </summary>
/// <param name="dto">数据传输对象</param>
/// <returns></returns>
public virtual async Task <IActionResult> CreateAsync([FromBody] TDto dto)
{
if (dto == null)
{
return(Fail("请求参数不能为空"));
}
CreateBefore(dto);
await _service.CreateAsync(dto);
var result = await _service.GetByIdAsync(dto.Id);
return(Success(result));
}
private async Task <IRatingCalculator> GetCalculatorAsync(string storeId)
{
var store = await _storeService.GetByIdAsync(storeId, StoreResponseGroup.Full.ToString());
if (store == null)
{
throw new KeyNotFoundException($"Store not found, storeId: {storeId}");
}
var calculatorName = store.Settings.GetSettingValue(
ModuleConstants.Settings.General.CalculationMethod.Name,
ModuleConstants.Settings.General.CalculationMethod.DefaultValue.ToString());
if (string.IsNullOrWhiteSpace(calculatorName))
{
throw new KeyNotFoundException($"Store settings not found: {ModuleConstants.Settings.General.CalculationMethod.Name}");
}
var ratingCalculator = _ratingCalculators.FirstOrDefault(c => c.Name == calculatorName);
if (ratingCalculator == null)
{
throw new KeyNotFoundException($"{calculatorName} not found in DI container");
}
return(ratingCalculator);
}
public async Task NotifyAsync(int notificationId, CancellationToken cancellationToken)
{
var notification = await _eventNotificationService.GetByIdAsync(notificationId);
if (notification == null)
{
_logger.LogError($"Scheduled notification with Id {notificationId} is not found in database");
return;
}
try
{
var chatId = new ChatId(notification.UserTelegramId);
var msg = await _botClient.SendTextMessageAsync(chatId, notification.Subject, cancellationToken : cancellationToken);
_logger.LogDebug($"Sended scheduled notification {notificationId}");
await _eventNotificationService.DeleteAsync(notificationId);
_logger.LogDebug($"Deleted scheduled notification {notificationId}");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error sending notification {notificationId}");
throw;
}
}
public static async Task <TModel> UpdateAndGetAsync <TModel>(this ICrudService <TModel> service, TModel data)
where TModel : class, IBaseModel
{
await service.UpdateAsync(data);
return(await service.GetByIdAsync(data.Id));
}
public async Task <CartAggregate> GetCartByIdAsync(string cartId, string language = null)
{
var cart = await _shoppingCartService.GetByIdAsync(cartId);
if (cart != null)
{
return(await InnerGetCartAggregateFromCartAsync(cart, language ?? Language.InvariantLanguage.CultureName));
}
return(null);
}
public async Task <IActionResult> GetByIdAsync(int id)
{
var result = await _service.GetByIdAsync(id);
if (result == default)
{
return(NotFound());
}
return(Ok(_mapper.Map <UserModel>(result)));
}
public async Task <IActionResult> GetById(Guid id)
{
try
{
return(Ok(await _service.GetByIdAsync(id)));
}
catch (EntityNotFoundException ex)
{
return(NotFound());
}
}
public async Task <ActionResult> GetById(string id)
{
var estudiante = await service.GetByIdAsync(id);
if (estudiante == null)
{
return(NotFound());
}
return(Ok(estudiante));
}
/// <summary>
/// Updates the asynchronous.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public virtual async Task <T2> UpdateAsync(T1 id, T2 entity)
{
var originalEntity = await _service.GetByIdAsync(id);
var historicalEvent = new HistoricalEvent
{
Action = HistoricalActions.Update.ToString(),
Changeset = new HistoricalChangeset()
{
ObjectData = JsonConvert.SerializeObject(originalEntity),
ObjectDelta = originalEntity.DetailedCompare(entity)
},
EntityId = originalEntity.Id.ToString(),
EntityName = entity.GetType().FullName
};
var modifiedEntity = await _service.UpdateAsync(id, entity);
await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent);
await _repository.SaveChangesAsync();
return(modifiedEntity);
}
protected async Task <PaymentInfo> GetPaymentInfo(PaymentCommandBase command)
{
var result = new PaymentInfo();
if (!string.IsNullOrEmpty(command.OrderId))
{
result.CustomerOrder = await _customerOrderService.GetByIdAsync(command.OrderId, CustomerOrderResponseGroup.Full.ToString());
result.Payment = result.CustomerOrder?.InPayments?.FirstOrDefault(x => x.Id == command.PaymentId);
}
else if (!string.IsNullOrEmpty(command.PaymentId))
{
result.Payment = await _paymentService.GetByIdAsync(command.PaymentId);
result.CustomerOrder = await _customerOrderService.GetByIdAsync(result.Payment?.OrderId, CustomerOrderResponseGroup.Full.ToString());
// take payment from order since Order payment contains instanced PaymentMethod (payment taken from service doesn't)
result.Payment = result.CustomerOrder?.InPayments?.FirstOrDefault(x => x.Id == command.PaymentId);
}
result.Store = await _storeService.GetByIdAsync(result.CustomerOrder?.StoreId, StoreResponseGroup.StoreInfo.ToString());
return(result);
}
public virtual async Task <CustomerOrderAggregate> Handle(CreateOrderFromCartCommand request, CancellationToken cancellationToken)
{
var cart = await _cartService.GetByIdAsync(request.CartId);
await ValidateCart(cart);
var result = await _customerOrderAggregateRepository.CreateOrderFromCart(cart);
await _cartService.DeleteAsync(new List <string> {
request.CartId
}, softDelete : true);
// Remark: There is potential bug, because there is no transaction thru two actions above. If a cart deletion fails, the order remains. That causes data inconsistency.
// Unfortunately, current architecture does not allow us to support such scenarios in a transactional manner.
return(result);
}
protected virtual async Task SetNotificationParametersAsync(Notification pNotification, CustomerOrder pOrder, Member pCustomer)
{
var store = await _storeService.GetByIdAsync(pOrder.StoreId, StoreResponseGroup.StoreInfo.ToString());
if (pNotification is EmailNotification emailNotification)
{
emailNotification.From = store.EmailWithName;
emailNotification.To = GetOrderRecipientEmail(pOrder, pCustomer);
}
// Allow to filter notification log either by customer order or by subscription
if (string.IsNullOrEmpty(pOrder.SubscriptionId))
{
pNotification.TenantIdentity = new TenantIdentity(pOrder.Id, nameof(CustomerOrder));
}
else
{
pNotification.TenantIdentity = new TenantIdentity(pOrder.SubscriptionId, "Subscription");
}
}
public TeamQueries(ICrudService <Team> teamService, ILogger <TeamQueries> logger)
{
FieldAsync <ListGraphType <TeamQueryViewModel> >(
"getAll",
"Use this to get all the teams",
new QueryArguments(),
async context =>
{
try
{
return(await teamService.GetAllAsync());
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
FieldAsync <TeamQueryViewModel>(
"getById",
"Use this to get team info",
new QueryArguments(new QueryArgument <GuidGraphTypeCustom> {
Name = "teamId"
}),
async context =>
{
try
{
var teamId = context.GetArgument <Guid>("teamId");
return(await teamService.GetByIdAsync(teamId));
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
}
public PlanetQueries(ICrudService <Planet> planetService, ILogger <PlanetQueries> logger)
{
FieldAsync <ListGraphType <PlanetQueryViewModel> >(
"getAll",
"Use this to get all the planets",
new QueryArguments(),
async context =>
{
try
{
return(await planetService.GetAllAsync());
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
FieldAsync <PlanetQueryViewModel>(
"getById",
"Use this to get planet info",
new QueryArguments(new QueryArgument <GuidGraphTypeCustom> {
Name = "planetId"
}),
async context =>
{
try
{
var planetId = context.GetArgument <Guid>("planetId");
return(await planetService.GetByIdAsync(planetId));
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
}
public ShuttleQueries(ICrudService <Shuttle> shuttleService, ILogger <ShuttleQueries> logger)
{
FieldAsync <ListGraphType <ShuttleQueryViewModel> >(
"getAll",
"Use this to get all the shuttles",
new QueryArguments(),
async context =>
{
try
{
return(await shuttleService.GetAllAsync());
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
FieldAsync <ShuttleQueryViewModel>(
"getById",
"Use this to get shuttle info",
new QueryArguments(new QueryArgument <GuidGraphTypeCustom> {
Name = "shuttleId"
}),
async context =>
{
try
{
var shuttleId = context.GetArgument <Guid>("shuttleId");
return(await shuttleService.GetByIdAsync(shuttleId));
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
}
public ExplorationQueries(ICrudService <Exploration> explorationService, ILogger <ExplorationQueries> logger)
{
FieldAsync <ListGraphType <ExplorationQueryViewModel> >(
"getAll",
"Use this to get all the explorations",
new QueryArguments(),
async context =>
{
try
{
return(await explorationService.GetAllAsync());
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
FieldAsync <ExplorationQueryViewModel>(
"getById",
"Use this to get exploration info",
new QueryArguments(new QueryArgument <GuidGraphTypeCustom> {
Name = "explorationId"
}),
async context =>
{
try
{
var explorationId = context.GetArgument <Guid>("explorationId");
return(await explorationService.GetByIdAsync(explorationId));
}
catch (Exception ex)
{
logger.LogCritical(ex.Message, ex);
return(null);
}
});
}
public async Task <ActionResult <GroupDto> > UpdateAsync(GroupDto dto)
{
var entry = await _groupCrudService.GetByIdAsync(dto.Id);
if (entry is null)
{
return(NotFound());
}
var validator = new DefaultGroupValidator();
entry.SelectValidator(validator);
entry.SetName(dto.Name);
if (entry.HasErrors)
{
return(BadRequest(entry.ErrorsStrings));
}
await _groupCrudService.UpdateAsync(entry);
return(Ok(entry.ToDto()));
}
public async Task <IHttpActionResult> GetAsync([FromUri] Guid id) => await ExecuteAsync(async() => await _crudService.GetByIdAsync(id));
//página de detalhes da entidade
public virtual async Task <IActionResult> Details(long id)
{
var entity = await _service.GetByIdAsync(id);
return(View(_mapper.Map <TViewModel>(entity)));
}
public virtual async Task <TDto> GetByIdAsync(TId id) => _mapper.Map <TDto>(await _service.GetByIdAsync(id));
public async Task <T2> GetByIdAsync(T1 id) => await _service.GetByIdAsync(id);
public virtual async Task <IActionResult> GetAsync(string id)
{
var result = await _service.GetByIdAsync(id);
return(Success(result));
}
public async Task <ActionResult <PaymentMethod> > GetPaymentMethodById(string id)
{
var result = await _paymentMethodCrudService.GetByIdAsync(id, null);
return(Ok(result));
}
public virtual async Task <T> GetByIdAsync(Guid id) => await _service.GetByIdAsync(id);
public virtual async Task <SearchProductResponse> Handle(SearchProductQuery request, CancellationToken cancellationToken)
{
var allStoreCurrencies = await _storeCurrencyResolver.GetAllStoreCurrenciesAsync(request.StoreId, request.CultureName);
var currency = await _storeCurrencyResolver.GetStoreCurrencyAsync(request.CurrencyCode, request.StoreId, request.CultureName);
var store = await _storeService.GetByIdAsync(request.StoreId);
var responseGroup = EnumUtility.SafeParse(request.GetResponseGroup(), ExpProductResponseGroup.None);
var builder = new IndexSearchRequestBuilder()
.WithCurrency(currency.Code)
.WithFuzzy(request.Fuzzy, request.FuzzyLevel)
.ParseFilters(_phraseParser, request.Filter)
.WithSearchPhrase(request.Query)
.WithPaging(request.Skip, request.Take)
.AddObjectIds(request.ObjectIds)
.AddSorting(request.Sort)
.WithIncludeFields(IndexFieldsMapper.MapToIndexIncludes(request.IncludeFields).ToArray());
if (request.ObjectIds.IsNullOrEmpty())
{
AddDefaultTerms(builder, store.Catalog);
}
var criteria = new ProductIndexedSearchCriteria
{
StoreId = request.StoreId,
Currency = request.CurrencyCode ?? store.DefaultCurrency,
LanguageCode = store.Languages.Contains(request.CultureName) ? request.CultureName : store.DefaultLanguage,
CatalogId = store.Catalog
};
//Use predefined facets for store if the facet filter expression is not set
if (responseGroup.HasFlag(ExpProductResponseGroup.LoadFacets))
{
var predefinedAggregations = await _aggregationConverter.GetAggregationRequestsAsync(criteria, new FiltersContainer());
builder.WithCultureName(criteria.LanguageCode);
builder.ParseFacets(_phraseParser, request.Facet, predefinedAggregations)
.ApplyMultiSelectFacetSearch();
}
var searchRequest = builder.Build();
var searchResult = await _searchProvider.SearchAsync(KnownDocumentTypes.Product, searchRequest);
var resultAggregations = await ConvertResultAggregations(criteria, searchRequest, searchResult);
searchRequest.SetAppliedAggregations(resultAggregations.ToArray());
var products = searchResult.Documents?.Select(x => _mapper.Map <ExpProduct>(x)).ToList() ?? new List <ExpProduct>();
var result = new SearchProductResponse
{
Query = request,
AllStoreCurrencies = allStoreCurrencies,
Currency = currency,
Store = store,
Results = products,
Facets = resultAggregations?.ApplyLanguageSpecificFacetResult(criteria.LanguageCode)
.Select(x => _mapper.Map <FacetResult>(x, options =>
{
options.Items["cultureName"] = criteria.LanguageCode;
})).ToList(),
TotalCount = (int)searchResult.TotalCount
};
await _pipeline.Execute(result);
return(result);
async Task <Aggregation[]> ConvertResultAggregations(ProductIndexedSearchCriteria criteria, SearchRequest searchRequest, SearchResponse searchResult)
{
// Preconvert resulting aggregations to be properly understandable by catalog module
var preconvertedAggregations = new List <AggregationResponse>();
//Remember term facet ids to distinguish the resulting aggregations are range or term
var termsInRequest = new List <string>(searchRequest.Aggregations.Where(x => x is TermAggregationRequest).Select(x => x.Id ?? x.FieldName));
foreach (var aggregation in searchResult.Aggregations)
{
if (!termsInRequest.Contains(aggregation.Id))
{
// There we'll go converting range facet result
var fieldName = new Regex(@"^(?<fieldName>[A-Za-z0-9]+)(-.+)*$", RegexOptions.IgnoreCase).Match(aggregation.Id).Groups["fieldName"].Value;
if (!fieldName.IsNullOrEmpty())
{
preconvertedAggregations.AddRange(aggregation.Values.Select(x =>
{
var matchId = new Regex(@"^(?<left>[0-9*]+)-(?<right>[0-9*]+)$", RegexOptions.IgnoreCase).Match(x.Id);
var left = matchId.Groups["left"].Value;
var right = matchId.Groups["right"].Value;
x.Id = left == "*" ? $@"under-{right}" : x.Id;
x.Id = right == "*" ? $@"over-{left}" : x.Id;
return(new AggregationResponse()
{
Id = $@"{fieldName}-{x.Id}", Values = new List <AggregationResponseValue> {
x
}
});
}
));
}
}
else
{
// This is term aggregation, should skip converting and put resulting aggregation as is
preconvertedAggregations.Add(aggregation);
}
}
//Call the catalog aggregation converter service to convert AggregationResponse to proper Aggregation type (term, range, filter)
return(await _aggregationConverter.ConvertAggregationsAsync(preconvertedAggregations, criteria));
}
}
public virtual async Task <ActionResult <TDto> > GetAsync(int id, CancellationToken cancellationToken = default)
{
var entity = await _crudService.GetByIdAsync(id);
return(entity == null?NotFound() : Ok(Mapper.Map <TDto>(entity)));
}
public async Task <ActionResult <ShippingMethod> > GetShippingMethodById(string id)
{
var result = await _shippingMethodsService.GetByIdAsync(id, null);
return(Ok(result));
}
public async Task <ActionResult <TaxProviderSearchResult> > GetTaxProviderById(string id)
{
var result = await _taxProviderService.GetByIdAsync(id, null);
return(Ok(result));
}
