public async Task <IActionResult> Create([Bind("Name,Trainer")] Horse horse, int raceId, int laneId, int year) { ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User); Race race = await _context.Races.FindAsync(raceId, laneId, year); if (ModelState.IsValid) { Guid id = Guid.NewGuid(); horse.Id = id; horse.ApplicationUserId = user.Id; _context.Add(horse); try { race.HorseId = id; _context.Update(race); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!HorseExists(horse.Id)) { return(NotFound()); } else { throw; } } await _context.SaveChangesAsync(); return(RedirectToAction("Race", "Races", new { raceNbr = raceId })); } return(View(horse)); }
public async Task <IActionResult> AddMedication( [FromBody, Bind("AdviceIfDeclined", "AdviceIfTaken", "Dose", "ExclusionCriteria", "Form", "InclusionCriteria", "Indications", "Name", "Route", "SideEffects")] Medication medication) { var errors = new List <RequestError>(); errors.AddRange(ValidateMedication(medication)); if (await _dataContext.Medications.AnyAsync(m => m.Name == medication.Name)) { errors.Add(new RequestError { Error = RequestErrorType.IsInUse, Path = "name" }); } if (errors.Any()) { return(BadRequest(errors)); } medication.LastModified = DateTimeOffset.UtcNow; _dataContext.Medications.Add(medication); await _dataContext.SaveChangesAsync(); return(Created($"/api/get-medication/{medication.Id}", medication)); }
public async Task <IActionResult> CreateComuna([FromBody] Comuna nuevaComuna) { try { // Validar si el objecto viene vacio if (nuevaComuna == null) { return(BadRequest("Error: Modelo Comuna vacio")); } // Validar si no posee la misma id que otro objecto if (await _dataContext.Comunas.AsNoTracking().AnyAsync(comuna => comuna.Id == nuevaComuna.Id)) { return(BadRequest("Error: El id no es valido")); } // Validar si no posee el mismo nombre que otra comuna if (await _dataContext.Comunas.AsNoTracking().AnyAsync(comuna => comuna.Nombre.ToLower() == nuevaComuna.Nombre.ToLower())) { return(BadRequest("Error: Ya existe una comuna con el mismo nombre")); } // Pasa las validaciones y se guarda en la base de datos _dataContext.Add(nuevaComuna); await _dataContext.SaveChangesAsync(); return(Ok()); } catch { return(BadRequest("Error")); } }
public async Task <IActionResult> CreateSucursal([FromBody] Sucursal nuevaSucursal) { try { // Validar si el objecto viene vacio if (nuevaSucursal == null) { return(BadRequest("Error: Modelo de Sucursal está vacio")); } // Validar si no posee la misma id que otro objecto if (await _dataContext.Sucursales .AsNoTracking() .AnyAsync(s => s.IdSucursal == nuevaSucursal.IdSucursal)) { return(BadRequest("Error: El id no es valido")); } // Validar si no posee el mismo nombre que otra sucursal if (await _dataContext.Sucursales.AsNoTracking().AnyAsync(s => s.NombreSucursal.ToLower() == nuevaSucursal.NombreSucursal.ToLower())) { return(BadRequest("Error: Ya existe una sucursal con el mismo nombre")); } // Pasa las validaciones y se guarda en la base de datos _dataContext.Add(nuevaSucursal); await _dataContext.SaveChangesAsync(); return(Ok()); } catch { return(BadRequest("Error")); } }
public async Task <IActionResult> PutCovidTesting(int id, CovidTesting covidTesting) { if (id != covidTesting.Id) { return(BadRequest()); } _context.Entry(covidTesting).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CovidTestingExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutLogisticCompany(int Id, LogisticCompany logisticCompany) { if (Id != logisticCompany.Id) { return(BadRequest()); } _context.Entry(logisticCompany).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!LogisticCompanyExists(Id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task CheckComunasAsync() { // Verificar si no existen las comunas. if (!_dataContext.Comunas.Any()) { // Agregar data. // Para Santiago _dataContext.Comunas.Add(new Comuna { NombreComuna = "Antofagasta", Ciudad = new Ciudad { NombreCiudad = "Antofagasta", } }); _dataContext.Comunas.Add(new Comuna { NombreComuna = "Santiago", Ciudad = new Ciudad { NombreCiudad = "Santiago", } }); _dataContext.Comunas.Add(new Comuna { NombreComuna = "Calama", Ciudad = new Ciudad { NombreCiudad = "Calama", } }); // Para Antofagasta _dataContext.Comunas.Add(new Comuna { NombreComuna = "Mejillones", Ciudad = new Ciudad { NombreCiudad = "Antofagasta", } }); _dataContext.Comunas.Add(new Comuna { NombreComuna = "Taltal", Ciudad = new Ciudad { NombreCiudad = "Antofagasta", } }); } // Guardar cambios. await _dataContext.SaveChangesAsync(); }
public async Task <string> AddAsync(WalletGroupModel walletGroupModel) { var addResult = await applicationDataContext.WalletGroups.AddAsync(walletGroupModel); await applicationDataContext.SaveChangesAsync(); var walletGroupId = addResult.Entity.Id; return(walletGroupId); }
public async Task <ActionResult> Create([Bind(Include = "id,CreationDate,LastModificationDate,Name,Address,AddressInArabic,Email,EmployeeImage,Nationality,BirthDate,Sex,BirthPlace")] EmployeeProspect employeeprospect) { fillUserData(); if (ModelState.IsValid) { db.EmployeeProspects.Add(employeeprospect); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(employeeprospect)); }
public async Task <ActionResult <AppUser> > Register(AppUser appUser) { if (_context.AppUsers.Any(u => u.Email == appUser.Email)) { return(BadRequest("The Email is already registered.")); } appUser.RuleName = "User"; _context.AppUsers.Add(appUser); await _context.SaveChangesAsync(); return(CreatedAtAction("/", new { id = appUser.Id }, appUser)); }
public async Task <bool> Delete(Guid id) { var entity = await _context.Products.SingleOrDefaultAsync(p => p.Id == id); if (entity == null) { return(false); } _context.Products.Remove(entity); await _context.SaveChangesAsync(); return(true); }
public async Task <ActionResult> Create([Bind(Include = "id,CreationDate,LastModificationDate,From,To,Position,Description,EmployeeProspectId")] WorkExperience workexperience) { fillUserData(); if (ModelState.IsValid) { db.WorkExperiences.Add(workexperience); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } ViewBag.EmployeeProspectId = new SelectList(db.EmployeeProspects, "id", "Name", workexperience.EmployeeProspectId); return(View(workexperience)); }
public async Task MainAsync() { var db = new ApplicationDataContext(); var token = await db.Settings.FirstOrDefaultAsync(s => s.Id == "DISCORD_TOKEN"); if (token == null || token.Value == "") { Console.WriteLine("Please enter the discord token:"); if (token == null) { token = new Setting() { Id = "DISCORD_TOKEN" }; db.Add(token); } token.Value = Console.ReadLine(); await db.SaveChangesAsync(); } db.Dispose(); await _client.LoginAsync(Discord.TokenType.Bot, token.Value); await _client.StartAsync(); await Task.Delay(-1, MainThread.Token); }
public async Task <Unit> Handle(UpdateItemQuantityCommand request, CancellationToken cancellationToken) { if (request.Quantity < 0) { throw new ArgumentOutOfRangeException(); } var shoppingCartItem = await applicationDataContext.ShoppingCartItems .FirstOrDefaultAsync(sci => sci.Id == request.Id); if (shoppingCartItem == null) { throw new Exception(); } if (request.Quantity == 0) { applicationDataContext.ShoppingCartItems.Remove(shoppingCartItem); } else { shoppingCartItem.Quantity = request.Quantity; applicationDataContext.Update(shoppingCartItem); } await applicationDataContext.SaveChangesAsync(); return(Unit.Value); }
public async Task <IActionResult> UploadBlob([Bind("Title, VideoLink, Title, Description, DatePosted")] VideoModel VM) { CloudBlobContainer container = GetCloudBlobContainer(); CloudBlockBlob blob = container.GetBlockBlobReference(VM.Title); // Create the blob in blob storage var path = $@"{VM.VideoLink}"; var req = System.Net.WebRequest.Create(VM.VideoLink); using (Stream stream = req.GetResponse().GetResponseStream()) { blob.UploadFromStreamAsync(stream).Wait(); } var Wd = Directory.GetCurrentDirectory(); /* using (var fileStream = System.IO.File.OpenRead(path)) * { * blob.UploadFromStreamAsync(fileStream).Wait(); * }*/ VM.Owner = currentUser; // Add video meta data to the SQL DB if (ModelState.IsValid) { _context.Add(VM); await _context.SaveChangesAsync(); return(View("Home/Index")); } // if we got this far something went wrong return(View()); }
public async Task <int> Handle(CreateCategoryCommand request, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var item = mapper.Map <ProductCategory>(request); if (request.ParentCategoryId != null) { var parentCategory = await applicationDataContext.ProductCategories.FindAsync(request.ParentCategoryId); if (parentCategory == null) { throw new Exception(); } item.Parent = parentCategory; } else { item.Parent = await applicationDataContext.ProductCategories.FindAsync(0); } applicationDataContext.ProductCategories .Add(item); await applicationDataContext.SaveChangesAsync(); return(item.Id); }
public async Task <IActionResult> _GroupCreate(Group group) { ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User); if (ModelState.IsValid) { group.ApplicationUserId = user.Id; _context.Add(group); //foreach (var member in group.Members) //{ // member.GroupId = group.Id; // _context.Add(member); //} await _context.SaveChangesAsync(); return(RedirectToAction("UserCart", "ApplicationUser")); } return(View(group)); }
private async Task MessageDeletedAsync(Cacheable <IMessage, ulong> arg1, ISocketMessageChannel arg2) { using (var db = new ApplicationDataContext()) { var msg = await DiscordMessage.CreateOrGetAsync(await arg1.GetOrDownloadAsync()); db.Entry(msg); msg.IsDeleted = true; await db.SaveChangesAsync(); } }
private async Task GuildUserUpdatedAsync(SocketUser prevUser, SocketUser newUser) { var db = new ApplicationDataContext(); await Log.LogAsync(newUser, $"{newUser.Username} Status change {newUser.Status} {newUser.Activity.Name}"); db.Add(new DiscordUserEvent() { EventTime = DateTime.Now, Game = newUser.Activity.Name, Status = newUser.Status.ToString(), UserId = newUser.Id }); await db.SaveChangesAsync(); db.Dispose(); }
protected override async Task When() { using (var context = new ApplicationDataContext()) { try { context.Add(new Product { Id = Guid.NewGuid(), No = 1, Description = "Record 1" }); context.Add(new Product { Id = Guid.NewGuid(), No = 2, Description = "Record 2" }); context.Add(new Product { Id = Guid.NewGuid(), No = 3, Description = "Record 3" }); context.Add(new Product { Id = Guid.NewGuid(), No = 4, Description = "Record 4" }); context.Add(new Product { Id = Guid.NewGuid(), No = 5, Description = "Record 5" }); await context.SaveChangesAsync(); _result = await context.Products .OrderBy(e => e.No) .ToListAsync(); } catch (Exception e) { TestContext.WriteLine(e); throw; } } }
private static async Task Add(SocketMessage message, string[] parts) { if (message.MentionedUsers.Count() != 1) { await message.Channel.SendMessageAsync("Please include only one author with an @"); return; } await DiscordUser.CreateOrGetAsync(message.Author); await DiscordUser.CreateOrGetAsync(message.MentionedUsers.First()); var quoteText = parts.Skip(2).Where(s => !s.Contains(message.MentionedUsers.First().Mention)).SkipLast(1).Aggregate("", (c, n) => c + " " + n).Trim(); var quote = new Quote() { AddedById = message.Author.Id, AuthorId = message.MentionedUsers.First().Id, Created = DateTime.Now, QuoteText = quoteText }; _db.Add(quote); await _db.SaveChangesAsync(); await message.Channel.SendMessageAsync($"Quote {quote.Id} created!"); }
private async Task ReactionAddedAsync(Cacheable <IUserMessage, ulong> arg1, ISocketMessageChannel arg2, SocketReaction arg3) { Console.WriteLine($"Adding Reaction {arg3.Emote.Name}"); using (var db = new ApplicationDataContext()) { await DiscordMessage.CreateOrGetAsync(await arg1.GetOrDownloadAsync()); var reaction = new UserMessageReaction() { Created = DateTime.UtcNow, MessageId = arg3.MessageId, ReactorId = arg3.UserId, Reaction = arg3.Emote.Name }; db.Add(reaction); await db.SaveChangesAsync(); } }
private async Task ReactionRemovedAsync(Cacheable <IUserMessage, ulong> arg1, ISocketMessageChannel arg2, SocketReaction arg3) { Console.WriteLine($"Removing Reaction {arg3.Emote.Name}"); using (var db = new ApplicationDataContext()) { await DiscordMessage.CreateOrGetAsync(await arg1.GetOrDownloadAsync()); var reaction = db.UserMessageReactions.FirstOrDefault(r => r.MessageId == arg3.MessageId && r.ReactorId == arg3.UserId && r.Reaction == arg3.Emote.Name); if (reaction != null) { db.Remove(reaction); await db.SaveChangesAsync(); } } }
public async Task <Unit> Handle(ClearCommand request, CancellationToken cancellationToken) { var shoppingCart = await applicationDataContext .ShoppingCarts .Include(sc => sc.Items) .FirstAsync(); foreach (var item in shoppingCart.Items.ToArray()) { applicationDataContext.ShoppingCartItems.Remove(item); } await applicationDataContext.SaveChangesAsync(); return(await Unit.Task); }
public async Task <IActionResult> PayCash([FromBody] RouteValuesAmount amount) { ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User); //***CT***** Can convert to JSON -> Dictionary to avoid strongly type class //var json = JsonConvert.SerializeObject(amount); //var dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(json); //int balance = Convert.ToInt32(dictionary.GetValueOrDefault("Amount")); //user.Balance += balance; user.Balance += amount.Amount; _context.Update(user); await _context.SaveChangesAsync(); return(Ok(user)); }
public async Task <Unit> Handle(RemoveItemCommand request, CancellationToken cancellationToken) { var shoppingCartItem = await applicationDataContext.ShoppingCartItems .FirstOrDefaultAsync(sci => sci.Id == request.Id); if (shoppingCartItem == null) { throw new Exception(); } applicationDataContext.ShoppingCartItems.Remove(shoppingCartItem); await applicationDataContext.SaveChangesAsync(); return(Unit.Value); }
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken) { var department = new Department { Code = request.Code, Name = request.Name }; _context.Departments.Add(department); var success = await _context.SaveChangesAsync() > 0; if (success) { return(Unit.Value); } throw new RestException(HttpStatusCode.NotFound, "Problem saving changes"); }
private async void BotShuttingDown(object sender, EventArgs e) { Console.WriteLine("Shutting Down"); var db = new ApplicationDataContext(); foreach (var chan in db.DiscordVoiceChannel) { var c = _client.GetChannel(chan.Id); foreach (var u in c.Users) { await VoiceEventLog.Log(u, c, "Left"); } } await db.SaveChangesAsync(); _client.Dispose(); MainThread.Cancel(); Environment.Exit(0); }
public async Task <bool?> SaveAll() { try { int saveStatus = await _dataContext.SaveChangesAsync(); if (saveStatus > 0) { return(true); } else { return(false); } } catch (Exception) { return(null); } }
public async Task <Unit> Handle(UpdateCategoryCommand request, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var category = await applicationDataContext.ProductCategories.FindAsync(request.Id); if (category == null) { throw new Exception(); } category = mapper.Map(request, category); if (request.ParentCategoryId != null) { if (request.ParentCategoryId == category.Id) { throw new Exception("Cannot have itself as its parent."); } var parentCategory = await applicationDataContext.ProductCategories.FindAsync(request.ParentCategoryId); if (parentCategory == null) { throw new Exception(); } category.Parent = parentCategory; } applicationDataContext.ProductCategories .Update(category); await applicationDataContext.SaveChangesAsync(); return(Unit.Value); }