public async Task <SpendRulesListResponseModel> GetSpendRulesAsync([FromQuery] PaginationRequestModel pagination)
{
var spendRules = await _campaignClient.Mobile.GetSpendRulesAsync(Localization.En, _mapper.Map <BasePaginationRequestModel>(pagination));
var result = _mapper.Map <SpendRulesListResponseModel>(spendRules);
foreach (var spendRule in result.SpendRules)
{
if (spendRule.BusinessVertical != BusinessVertical.Retail)
{
continue;
}
var report = await _vouchersClient.Reports.GetSpendRuleVouchersAsync(spendRule.Id);
spendRule.StockCount = report.InStock;
spendRule.SoldCount = report.Total - report.InStock;
var rate = await _eligibilityEngineClient.ConversionRate.GetAmountBySpendRuleAsync(
new ConvertAmountBySpendRuleRequest()
{
Amount = Money18.Create(Math.Abs(spendRule.Price ?? 0)),
CustomerId = Guid.Parse(_requestContext.UserId),
SpendRuleId = spendRule.Id,
FromCurrency = _settingsService.GetBaseCurrencyCode(),
ToCurrency = _settingsService.GetTokenName(),
}
);
spendRule.PriceInToken = rate.Amount.ToDisplayString();
}
return(result);
}
public async Task <PaginatedAdminUserResponseModel> GetPaginatedAsync(
[FromBody] PaginationRequestModel pagingInfo)
{
var result = await _adminUserService.GetPaginatedAsync(pagingInfo.CurrentPage, pagingInfo.PageSize, pagingInfo.Active);
return(_mapper.Map <PaginatedAdminUserResponseModel>(result));
}
public async Task <IActionResult> GetUsers([FromQuery] PaginationRequestModel model)
{
var userQuery = _userManager.Users;
if (model.Sort.HasValue && !string.IsNullOrWhiteSpace(model.Column))
{
userQuery = SortUsers(userQuery, model.Column, ascending: model.Sort.Value);
}
var items = await model.GetPageAsync(userQuery);
return(Ok(new
{
model.TotalItemCount,
Items = items.Select(user => new
{
user.Id,
user.FirstName,
user.LastName,
user.Email,
user.PhoneNumber,
user.AgeRange,
user.FavouriteColor,
user.FavouriteWorkingDay,
user.TwoFactorEnabled,
})
}));
}
public PaginationResponseModel <UserTableRowResponseModel> GetAll(PaginationRequestModel <UserTableColumn> model, bool getAdmins = false)
{
if (!_isUserSuperAdmin && !_isUserAdmin)
{
throw new MethodAccessException("");
}
List <UserTableRowResponseModel> response = new List <UserTableRowResponseModel>();
var search = !string.IsNullOrEmpty(model.Search) && model.Search.Length > 1;
//!x.UserRoles.Any(w => (_userIsSuperAdmin && w.Role.Name != Role.Admin) && w.Role.Name != Role.SuperAdmin)
var users = _unitOfWork.Repository <ApplicationUser>().Get(x => !x.IsDeleted &&
!x.UserRoles.Any(w => w.Role.Name == Role.SuperAdmin) &&
(!search || (x.Email.Contains(model.Search) || x.Profile.FirstName.Contains(model.Search) || x.Profile.LastName.Contains(model.Search))) &&
(getAdmins ? x.UserRoles.Any(w => w.Role.Name == Role.Admin) : x.UserRoles.Any(w => w.Role.Name == Role.User)) &&
(_isUserSuperAdmin || !x.UserRoles.Any(w => (w.Role.Name == Role.Admin))))
.TagWith(nameof(GetAll) + "_GetUsers")
.Include(w => w.UserRoles)
.ThenInclude(w => w.Role)
.Select(x => new
{
Email = x.Email,
FirstName = x.Profile.FirstName,
LastName = x.Profile.LastName,
IsBlocked = !x.IsActive,
RegisteredAt = x.RegistratedAt,
Id = x.Id
});
if (search)
{
users = users.Where(x => x.Email.Contains(model.Search) || x.FirstName.Contains(model.Search) || x.LastName.Contains(model.Search));
}
int count = users.Count();
if (model.Order != null)
{
users = users.OrderBy(model.Order.Key.ToString(), model.Order.Direction == Models.Enums.SortingDirection.Asc);
}
users = users.Skip(model.Offset).Take(model.Limit);
response = users.Select(x => new UserTableRowResponseModel
{
Email = x.Email,
FirstName = x.FirstName,
LastName = x.LastName,
IsBlocked = x.IsBlocked,
RegisteredAt = x.RegisteredAt.ToISO(),
Id = x.Id
}).ToList();
return(new PaginationResponseModel <UserTableRowResponseModel>(response, count));
}
public async Task <PaginatedNotificationMessagesResponse> GetCustomerNotificationMessagesAsync(
[FromQuery] PaginationRequestModel request)
{
var customerId = _requestContext.UserId;
var result = await _notificationMessagesService.GetAsync(customerId, request.CurrentPage, request.PageSize);
return(_mapper.Map <PaginatedNotificationMessagesResponse>(result));
}
public async Task <EarnRulesListResponseModel> GetEarnRulesAsync(
[FromQuery] Models.EarnRules.CampaignStatus[] statuses,
[FromQuery] PaginationRequestModel pagination)
{
var earnRules = await _campaignClient.Mobile.GetEarnRulesAsync(Localization.En,
_mapper.Map <MAVN.Service.Campaign.Client.Models.Enums.CampaignStatus[]>(statuses),
_mapper.Map <BasePaginationRequestModel>(pagination));
return(_mapper.Map <EarnRulesListResponseModel>(earnRules));
}
public async Task <IHttpActionResult> GetAll(PaginationRequestModel model)
{
var mappedModel = Mapper.Map <PaginationRequestDto>(model);
var result = await storyManager.GetAll(mappedModel);
if (result == null)
{
return(InternalServerError());
}
return(Ok(Mapper.Map <BaseStoryModel>(result)));
}
private async Task <List <UserTableRowResponseModel> > GetUsers(OrderingRequestModel <UserTableColumn, SortingDirection> order)
{
var usersRequestModel = new PaginationRequestModel <UserTableColumn>()
{
Search = null,
Order = order,
Limit = int.MaxValue,
Offset = 0
};
return(_userService.GetAll(usersRequestModel).Data);
}
public async Task <PaginatedOperationsHistoryResponseModel> GetCustomerOperationsHistoryAsync([FromQuery] PaginationRequestModel request)
{
var result = await _operationsHistoryService.GetAsync(
_requestContext.UserId,
request.CurrentPage,
request.PageSize);
return(_mapper.Map <PaginatedOperationsHistoryResponseModel>(result));
}
public async Task <VoucherListModel> GetVouchersAsync([FromQuery] PaginationRequestModel request)
{
var customerId = Guid.Parse(_requestContext.UserId);
var vouchers = await _vouchersClient.Vouchers.GetByCustomerIdAsync(customerId);
vouchers = vouchers
.Skip((request.CurrentPage - 1) * request.PageSize)
.Take(request.PageSize)
.ToList();
var spendRuleIdentifiers = vouchers
.Select(o => o.SpendRuleId)
.Distinct()
.ToList();
var localizedSpendRules = new List <BurnRuleLocalizedResponse>();
foreach (var group in spendRuleIdentifiers.Batch(5))
{
var tasks = group
.Select(o => _campaignClient.Mobile.GetSpendRuleAsync(o, Localization.En, true))
.ToList();
await tasks.WhenAll();
var responses = tasks
.Where(o => o.Result != null)
.Select(o => o.Result);
localizedSpendRules.AddRange(responses);
}
var spendRulePartnerMap = localizedSpendRules
.Where(o => o.PartnerIds?.Length > 0)
.ToDictionary(o => o.Id, o => o.PartnerIds.First());
var partnersIdentifiers = spendRulePartnerMap.Values
.Distinct()
.ToArray();
var partners = await _partnerManagementClient.Partners.GetByIdsAsync(partnersIdentifiers);
var model = new List <VoucherListDetailsModel>();
foreach (var voucher in vouchers)
{
var spendRule = localizedSpendRules.First(o => o.Id == voucher.SpendRuleId);
PartnerListDetailsModel partner = null;
if (spendRulePartnerMap.TryGetValue(spendRule.Id, out var partnerId))
{
partner = partners.First(o => o.Id == partnerId);
}
model.Add(new VoucherListDetailsModel
{
Code = voucher.Code,
SpendRuleName = spendRule.Title,
PartnerName = partner?.Name,
PriceToken = voucher.AmountInTokens.ToDisplayString(),
PriceBaseCurrency = voucher.AmountInBaseCurrency,
PurchaseDate = voucher.PurchaseDate
});
}
return(new VoucherListModel {
Vouchers = model, TotalCount = vouchers.Count
});
}
