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