// [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))); }