// [ValidateAntiForgeryToken]
public async Task <IActionResult> PatchAsync([FromBody] JsonPatchDocument <UserDto> patch, CancellationToken cancellationToken = default(CancellationToken))
{
var patched = _mapper.Map <JsonPatchDocument <User> >(patch);
var username = HttpContext.User.Identity.Name;
if (string.IsNullOrEmpty(username))
{
return(Ok(ApiModel.AsError <AccountDto>(null, "no user claims in request, did you forget to set the auth header ?")));
}
var user = await _userManager.FindByNameAsync(username);
if (user == null)
{
return(Ok(ApiModel.AsError <AccountDto>(null, $"impossible to find a user with the username '{username}'")));
}
patched.ApplyTo(user);
await _userManager.UpdateAsync(user);
var dto = _mapper.Map <UserDto>(user);
return(Ok(ApiModel.AsSuccess(dto)));
}
public async Task <ActionResult> Subscribe([FromForm] SubscribeModel model)
{
// this.ValidateCsrfToken();
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState.AsApiModel(model)));
}
try
{
var emailGrain = this.clusterClient.GetGrain <IEmailGrain>(0);
await emailGrain.SendEmail(
new Email
{
To = new List <string> {
"*****@*****.**"
},
MessageBody = $"<p>Keep me informed: {model.Email}</p>",
Subject = $"Subscriber request: {model.Email}",
});
return(Ok(ApiModel.AsSuccess(model, "Registered!")));
}
catch (Exception e)
{
this.logger.LogError(e, $"An Exception of type {e.GetType().ToString()}: \"{e.Message}\" occurred in /subscribe.\r\n{e.StackTrace}");
return(StatusCode(StatusCodes.Status500InternalServerError, ApiModel.FromException(model, e, includeExceptions: this.env.IsDevelopment())));
}
}
public async Task <IActionResult> Contact([FromForm] ContactModel model)
{
if (!this.ModelState.IsValid) // it should be possible to do a complete server render of form including the error...
{
return(BadRequest(this.ModelState.AsApiModel(model)));
}
try
{
var message = $"<h2>Contact request: {model.FirstName} {model.LastName}</h2><p>Name: {model.FirstName} {model.LastName}</p><p>Email: {model.Email}</p><p>Phone: {model.Phone}</p><p>Message: {model.Message}</p>";
var emailGrain = this.clusterClient.GetGrain <IEmailGrain>(0);
await emailGrain.SendEmail(
new Email
{
To = new List <string> {
"*****@*****.**"
},
MessageBody = message,
Subject = $"Contact request: {model.Email}",
});
return(Ok(ApiModel.AsSuccess <ContactModel>(model, "Message received")));
}
catch (Exception e)
{
this.logger.LogError(e, $"An Exception of type {e.GetType().ToString()}: \"{e.Message}\" occurred in /subscribe.\r\n{e.StackTrace}");
return(StatusCode(StatusCodes.Status500InternalServerError, ApiModel.FromException(model, e, includeExceptions: this.env.IsDevelopment())));
}
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
await _signInManager.SignInAsync(user, isPersistent : true);
_logger.LogInformation(3, "User created a new account with password.");
return(Ok(ApiModel.AsSuccess())); // RedirectToLocal(returnUrl);
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(BadRequest(ApiModel.AsError("Error"))); // TODO: map modelerrors
}
public async Task <IActionResult> GetCurrentUserId()
{
if (!_userManager.Users.Any())
{
return(Ok(ApiModel.AsError <string>("setup", "no users in DB")));
}
var username = HttpContext.User.Identity.Name;
if (string.IsNullOrEmpty(username))
{
return(Ok(ApiModel.AsError <AccountDto>(null, "no user claims in request, did you forget to set the auth header ?")));
}
var user = await _userManager.FindByNameAsync(username);
if (user == null)
{
return(Ok(ApiModel.AsError <AccountDto>(null, $"impossible to find a user with the username '{username}'")));
}
var resultDto = _mapper.Map <AccountDto>(user);
resultDto.IsAuthenticated = true;
return(Ok(ApiModel.AsSuccess(resultDto)));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> ClientAsync(
[FromServices] IService <DocumentTemplate> templateService,
[FromServices] IService <Client> clientService,
[FromRoute] string id,
[FromRoute] string templateId,
[FromBody] JsonPatchDocument <ClientDto> patch,
CancellationToken cancellationToken = default(CancellationToken)
)
{
var patched = _mapper.Map <JsonPatchDocument <Client> >(patch);
var result = await clientService.GetByIdAsync(id, cancellationToken);
patched.ApplyTo(result);
var preview = await clientService.PreviewAsync(result);
var template = await templateService.GetByIdAsync(templateId, cancellationToken);
var compiled = Handlebars.Compile(template.Template);
var html = compiled(new { client = preview });
return(Ok(ApiModel.AsSuccess(new { html = html, styles = template.Styles })));
}
public async Task <IActionResult> UseStockAsync([FromBody] Dictionary <string, Dictionary <string, int> > bindings, CancellationToken cancellationToken = default(CancellationToken))
{
foreach (var sku in bindings.Keys)
{
var result = (await service.FindAsync(Filter.Eq("SKU", sku), cancellationToken: cancellationToken)).FirstOrDefault();
var units = bindings[sku];
if (result == null)
{
result = new StockUnit
{
SKU = sku,
Units = units.ToDictionary(kvp => kvp.Key, kvp => - kvp.Value)
};
await service.CreateAsync(result, cancellationToken : cancellationToken);
}
else
{
foreach (var warehouseId in units.Keys)
{
var stock = units[warehouseId];
if (!result.Units.ContainsKey(warehouseId))
{
result.Units.Add(warehouseId, 0);
}
result.Units[warehouseId] -= stock;
}
await service.UpdateAsync(result, cancellationToken : cancellationToken);
}
}
return(Ok(ApiModel.AsSuccess <StockUnit>(null)));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> Logout()
{
await _signInManager.SignOutAsync();
_logger.LogInformation("User logged out.");
return(Ok(ApiModel.AsSuccess <User>(null)));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> OrderAsync(
[FromServices] IService <DocumentTemplate> templateService,
[FromServices] IService <IOrder> orderService,
[FromServices] IService <Shop> shopService,
[FromRoute] string id,
[FromRoute] string templateId,
[FromBody] JsonPatchDocument <OrderDto> patch,
CancellationToken cancellationToken = default(CancellationToken)
)
{
var patched = _mapper.Map <JsonPatchDocument <IOrder> >(patch);
var result = await orderService.GetByIdAsync(id, cancellationToken);
patched.ApplyTo(result);
var preview = await orderService.PreviewAsync(result);
var template = await templateService.GetByIdAsync(templateId, cancellationToken);
var compiled = Handlebars.Compile(template.Template);
var prettyToday = DateTime.UtcNow.ToString("dd.MM.yyyy");
// find the invoice template ?
var shop = string.IsNullOrEmpty(preview.ShopId) ? null : await shopService.GetByIdAsync(preview.ShopId);
var html = compiled(new { order = preview, shop = shop, today = prettyToday });
return(Ok(ApiModel.AsSuccess(new { html = html, styles = template.Styles })));
}
public async Task <IActionResult> Login([FromBody] LoginModel model)
{
// Hack to work around rc1 bug
await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
if (!ModelState.IsValid)
{
return(BadRequest(this.ModelState.AsApiModel(model)));
}
var result = await this.signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberLogin, lockoutOnFailure : true);
if (result.Succeeded)
{
this.logger.LogInformation(1, "User logged in.");
return(Ok(ApiModel.AsSuccess(model)));
}
else
{
this.logger.LogWarning(2, "User login failed.");
model.IsLockedOut = result.IsLockedOut;
model.IsNotAllowed = result.IsNotAllowed;
model.RequiresTwoFactor = result.RequiresTwoFactor;
return(this.BadRequest(ApiModel.AsError(model, "Login failed")));
}
}
public async Task <IActionResult> PostAsync([FromBody] PostBindings bindings, CancellationToken cancellationToken = default(CancellationToken))
{
var items = new List <OrderItem>();
foreach (var selection in bindings.Selections)
{
var product = await _productService.GetByIdAsync(selection.ProductId, cancellationToken);
var item = _productService.ToOrderItem(bindings.Currency, product, selection);
var subitems = new List <OrderItem>();
if (selection.Products != null)
{
foreach (var subSelection in selection.Products)
{
var subproduct = product.Products?.FirstOrDefault(p => p.Id == subSelection.ProductId);
if (subproduct == null)
{
continue;
}
subitems.Add(_productService.ToOrderItem(bindings.Currency, subproduct, subSelection));
}
}
item.SKU = item.Option != null && !string.IsNullOrEmpty(item.Option.SKU) ? item.Option.SKU : product.SKU;
item.Items = subitems;
items.Add(item);
}
return(Ok(ApiModel.AsSuccess(items)));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> WarehouseAsync([FromRoute] string id, [FromRoute] int min, [FromRoute] int max, [FromBody] Filter filter = null, int start = 0, int take = 50, CancellationToken cancellationToken = default(CancellationToken))
{
// TODO: absurd max and negative start should be validated in the modelstate
var result = await service.FindAsync(filter, cancellationToken : cancellationToken);
// we go link because of lack of support of 'in' opreator in Repository
var values = result.Where(s => s.Units.ContainsKey(id)).Select((i) => new WarehouseResponse {
SKU = i.SKU, Stock = i.Units[id]
});
if (max >= 0)
{
values = values.Where(v => v.Stock <= max);
}
if (min >= 0)
{
values = values.Where(v => v.Stock >= min);
}
var count = result.Count();
var implementationType = this.GetType();
var controllerName = implementationType.Name.ToLowerInvariant().Replace("controller", "");
values = values.OrderBy(s => s.Stock).Skip(start).Take(take);
var listResult = new FindResult <WarehouseResponse>
{
Count = count,
Start = start,
Take = take,
Values = values
};
var hasnext = count > (start + take);
if (hasnext)
{
listResult.Next = Url.Action(
action: nameof(WarehouseAsync),
controller: controllerName,
values: new { filter = filter, start = start + take, take = take },
protocol: Request.Scheme,
host: Request.Host.Value);
}
var hasPrevious = start > 0;
if (hasPrevious)
{
listResult.Previous = Url.Action(
action: nameof(FindAsync),
controller: controllerName,
values: new { filter = filter, start = Math.Max(start - take, 0), take = Math.Min(start, take) },
protocol: Request.Scheme,
host: Request.Host.Value);
}
return(Ok(ApiModel.AsSuccess(listResult)));
}
public async Task <IActionResult> UseAsync(
[FromServices] OrderService orderService,
[FromServices] IService <Models.Voucher> voucherService,
[FromBody] UseBindings bindings,
CancellationToken cancellationToken = default(CancellationToken))
{
// var currency = bindings.Currency ?? _appSettings.Currencies.FirstOrDefault();
var orderId = bindings.OrderId;
var code = bindings.Code;
var order = await orderService.GetByIdAsync(orderId, cancellationToken);
if (order == null)
{
return(NotFound($"Order with id = {orderId} not found"));
}
var voucher = (await voucherService.FindAsync(Filter.Eq("Code", code), cancellationToken: cancellationToken)).FirstOrDefault();
if (voucher == null)
{
return(NotFound($"Voucher with code = {code} not found"));
}
if (voucher.Used)
{
return(BadRequest($"Voucher with code = {code} already used"));
}
if (voucher.Expired)
{
return(BadRequest($"Voucher with code = {code} expired on {voucher.Expiration}"));
}
var amount = Math.Min(voucher.Value, order.Total - order.PaidAmount);
voucher.Value -= amount;
voucher.Used = !voucher.MultipleUse || voucher.Value <= 0;
voucher.OrderIds = voucher.OrderIds.Concat(new[] { orderId });
await voucherService.UpdateAsync(voucher, cancellationToken);
var payment = new Payment()
{
Title = "Voucher Payment",
Provider = Name,
Reference = $"voucher",
Status = PaymentStatus.Paid,
Date = DateTime.UtcNow,
Method = PaymentMethod.Voucher,
Details = $"Payment Order #{order.Reference}",
Currency = voucher.Currency,
Amount = amount
};
await orderService.AddPayment(order, payment, cancellationToken);
return(Ok(ApiModel.AsSuccess(payment)));
}
// [ValidateAntiForgeryToken]
public virtual async Task <IActionResult> PatchEmptyAsync([FromBody] JsonPatchDocument <TModelDto> patch, CancellationToken cancellationToken = default(CancellationToken))
{
var empty = await GetEmptyAsync(patch, cancellationToken);
var dto = _mapper.Map <TModelDto>(empty);
return(Ok(ApiModel.AsSuccess(dto)));
}
// [ValidateAntiForgeryToken]
public virtual async Task <IActionResult> GetAsync(string id, CancellationToken cancellationToken = default(CancellationToken))
{
var result = await service.GetByIdAsync(id, cancellationToken);
var model = _mapper.Map <TModelDto>(result);
return(Ok(ApiModel.AsSuccess(model)));
}
public virtual async Task <IActionResult> CountAsync([FromBody] Filter filter = null, CancellationToken cancellationToken = default(CancellationToken))
{
// TODO: absurd max and negative start should be validated in the modelstate
var result = await service.CountAsync(filter, cancellationToken);
return(Ok(ApiModel.AsSuccess(result)));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> GetAsync(string id, CancellationToken cancellationToken = default(CancellationToken))
{
var result = await _userManager.FindByIdAsync(id);
var model = _mapper.Map <UserDto>(result);
return(Ok(ApiModel.AsSuccess(model)));
}
public IActionResult Get([FromServices] PaypalConfiguration configuration)
{
return(Ok(ApiModel.AsSuccess(new PaypalConfigurationBindings
{
sandbox = configuration.ClientIdSandbox,
production = configuration.ClientIdProduction,
Environment = configuration.Environment
})));
}
public Task <IActionResult> RegisterAsync([FromBody] SubscribeBindings bindings, CancellationToken cancellationToken = default(CancellationToken))
{
var name = $"{bindings.FirstName ?? ""} {bindings.LastName ?? ""}";
var auth = new ApiKeyAuthenticationDetails(this.configuration.ApiKey);
new Subscriber(auth, this.configuration.ListId).Add(bindings.Email, name, null, true);
return(Task.FromResult((IActionResult)Ok(ApiModel.AsSuccess("ok"))));
}
public IActionResult Get()
{
var configurationDto = _mapper.Map <ConfigurationDto>(configuration);
configurationDto.PaymentProviders = paymentProviders.Select(p => p.Name);
configurationDto.NewsletterProviders = newsletterProviders.Select(p => p.Name);
configurationDto.Path = _appSettings.Path;
return(Ok(ApiModel.AsSuccess(configurationDto)));
}
public async Task <IActionResult> PreviewAsync(string id, [FromBody] JsonPatchDocument <OrderDto> patch, CancellationToken cancellationToken = default(CancellationToken))
{
var patched = _mapper.Map <JsonPatchDocument <IOrder> >(patch);
var result = await service.GetByIdAsync(id, cancellationToken);
patched.ApplyTo(result);
var preview = await orderService.PreviewAsync(result);
return(Ok(ApiModel.AsSuccess(result)));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> PatchEmptyAsync([FromServices] User empty, [FromBody] JsonPatchDocument <UserDto> patch, CancellationToken cancellationToken = default(CancellationToken))
{
var patched = _mapper.Map <JsonPatchDocument <User> >(patch);
patched.ApplyTo(empty);
await _userManager.CreateAsync(empty);
var dto = _mapper.Map <UserDto>(empty);
return(Ok(ApiModel.AsSuccess(dto)));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> PatchAsync(string id, [FromBody] JsonPatchDocument <UserDto> patch, CancellationToken cancellationToken = default(CancellationToken))
{
var patched = _mapper.Map <JsonPatchDocument <User> >(patch);
var result = await _userManager.FindByIdAsync(id);
patched.ApplyTo(result);
await _userManager.UpdateAsync(result);
var dto = _mapper.Map <UserDto>(result);
return(Ok(ApiModel.AsSuccess(dto)));
}
public async Task <IActionResult> ValidateAsync(
[FromServices] OrderService orderService,
[FromServices] IService <Models.Voucher> voucherService,
[FromBody] UseBindings bindings,
CancellationToken cancellationToken = default(CancellationToken))
{
// var currency = bindings.Currency ?? _appSettings.Currencies.FirstOrDefault();
var orderId = bindings.OrderId;
var code = bindings.Code;
var order = await orderService.GetByIdAsync(orderId, cancellationToken);
if (order == null)
{
return(NotFound($"Order with id = {orderId} not found"));
}
var voucher = (await voucherService.FindAsync(Filter.Eq("Code", code), cancellationToken: cancellationToken)).FirstOrDefault();
if (voucher == null)
{
return(Ok(ApiModel.AsSuccess(new ValidateResponse {
Result = false, Reason = "notfound"
})));
}
if (voucher.Used)
{
return(Ok(ApiModel.AsSuccess(new ValidateResponse {
Result = false, Reason = "used"
})));
}
if (voucher.Expired)
{
return(Ok(ApiModel.AsSuccess(new ValidateResponse {
Result = false, Reason = "expired"
})));
}
if (voucher.Value <= 0)
{
return(Ok(ApiModel.AsSuccess(new ValidateResponse {
Result = false, Reason = "empty"
})));
}
return(Ok(ApiModel.AsSuccess(new ValidateResponse {
Result = true
})));
}
public async Task <IActionResult> GetChangeAsync([FromBody] RegisterBindings bindings, CancellationToken cancellationToken = default(CancellationToken))
{
var order = await this.orderService.GetByIdAsync(bindings.OrderID, cancellationToken);
var toPay = order.Total - order.PaidAmount;
var rate = order.Currency == bindings.AmountCurrency ? 1 : configuration.GetRate(bindings.AmountCurrency, order.Currency);
var amount = bindings.Amount * rate;
var change = amount - toPay;
return(Ok(ApiModel.AsSuccess(
change * configuration.GetRate(order.Currency, bindings.ChangeCurrency)
)));
}
public async Task <IActionResult> ChargeAsync([FromServices] PayPalPaymentProvider provider, [FromBody] PayPalChargeBindings bindings, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var order = await provider.ChargeAsync(bindings, cancellationToken);
return(Ok(ApiModel.AsSuccess(order.Payments)));
}
catch (AppException AppException)
{
return(Ok(ApiModel.AsError(AppException)));
}
}
public async Task <IActionResult> ImportCsvAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var results = new List <ClientDto>();
var headers = Request.Form.Where(p => p.Key == "headers").Select(p => p.Value.FirstOrDefault()).FirstOrDefault()?.DeSerialize <Dictionary <string, int> >();
var delimiter = Request.Form.Where(p => p.Key == "delimiter").Select(p => p.Value.FirstOrDefault()).FirstOrDefault()?.DeSerialize <string>();
var hasHeaderRecord = Request.Form.Where(p => p.Key == "hasHeaderRecord").Select(p => p.Value.FirstOrDefault())?.FirstOrDefault().DeSerialize <bool>();
foreach (var file in Request.Form.Files)
{
if (file.Length <= 0 || file.FileName == null)
{
continue;
}
using (var stream = file.OpenReadStream())
using (var reader = new StreamReader(stream))
using (var csv = new CsvReader(reader))
{
// we can and will miss fields
csv.Configuration.MissingFieldFound = null;
// csv.Configuration.Encoding = new System.Text.UTF8Encoding();
csv.Configuration.Delimiter = delimiter ?? ",";
csv.Configuration.HasHeaderRecord = hasHeaderRecord ?? true;
if (headers != null)
{
var map = new CsvHelper.Configuration.DefaultClassMap <ClientDto>();
var clientType = typeof(ClientDto);
foreach (var memberName in headers.Keys)
{
var member = clientType.GetMember(memberName).FirstOrDefault();
if (member == null)
{
continue;
}
map.Map(typeof(ClientDto), member).Index(headers[memberName]);
}
csv.Configuration.RegisterClassMap(map);
// csv.Configuration.PrepareHeaderForMatch = (string header, int index) => string.IsNullOrWhiteSpace(headers[index]) ? header : headers[index];
}
var records = csv.GetRecords <ClientDto>();
foreach (var clientDto in records)
{
var record = _mapper.Map <IClient>(clientDto);
var newClient = await service.CreateAsync(record, cancellationToken);
results.Add(_mapper.Map <ClientDto>(newClient));
}
}
}
return(Ok(ApiModel.AsSuccess(results)));
}
public override async Task <IActionResult> PatchEmptyAsync([FromBody] JsonPatchDocument <OrderDto> patch, CancellationToken cancellationToken = default(CancellationToken))
{
var empty = await GetEmptyAsync(patch, cancellationToken);
var user = await _GetCurrentUserAsync();
empty.OrderType = OrderType.Order;
empty.ShopId = user?.ShopId;
empty.UserId = user?.Id;
var dto = _mapper.Map <OrderDto>(empty);
return(Ok(ApiModel.AsSuccess(dto)));
}
public async Task <IActionResult> RegisterAsync([FromBody] SubscribeBindings bindings, CancellationToken cancellationToken = default(CancellationToken))
{
// Use the Status property if updating an existing member
var member = new Member {
EmailAddress = bindings.Email, StatusIfNew = Status.Subscribed
};
member.MergeFields.Add("FNAME", bindings.FirstName);
member.MergeFields.Add("LNAME", bindings.LastName);
var manager = new MailChimpManager(this.configuration.ApiKey); //if you have it in code
await manager.Members.AddOrUpdateAsync(this.configuration.ListId, member);
return(Ok(ApiModel.AsSuccess("ok")));
}
public async Task <IActionResult> ShippingsAsync([FromBody] OrderDto orderDto, int start = 0, int take = 50, CancellationToken cancellationToken = default(CancellationToken))
{
var order = _mapper.Map <IOrder>(orderDto);
var preview = await orderService.PreviewAsync(order);
var allTemplates = await orderService.GetShippingsAsync(preview, cancellationToken);
var templates = allTemplates.Where(t => t.Accepts(preview));
var count = templates.Count();
var values = templates.Skip(start).Take(take).Select((i) => _mapper.Map <ShippingTemplateDto>(i));
var listResult = new FindResult <ShippingTemplateDto>
{
Count = count,
Start = start,
Take = take,
Values = values
};
var controllerName = nameof(OrderController).Replace("controller", "");
var hasnext = count > (start + take);
if (hasnext)
{
listResult.Next = Url.Action(
action: nameof(ShippingsAsync),
controller: controllerName,
values: new { orderDto = orderDto, start = start + take, take = take },
protocol: Request.Scheme,
host: Request.Host.Value);
}
var hasPrevious = start > 0;
if (hasPrevious)
{
listResult.Previous = Url.Action(
action: nameof(ShippingsAsync),
controller: controllerName,
values: new { orderDto = orderDto, start = Math.Max(start - take, 0), take = Math.Min(start, take) },
protocol: Request.Scheme,
host: Request.Host.Value);
}
return(Ok(ApiModel.AsSuccess(listResult)));
}
