public async Task <IActionResult> PutAlbum(Guid id, Album album)
{
if (id != album.Id)
{
return(BadRequest());
}
_context.Entry(album).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlbumExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutAfetado(int id, Afetado afetado)
{
if (id != afetado.AfetadoId)
{
return(BadRequest());
}
_context.Entry(afetado).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AfetadoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutMedia(Guid id, MediaItem media)
{
if (id != media.Id)
{
return(BadRequest());
}
_context.Entry(media).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MediaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutFriendship(int id, Friendship friendship)
{
if (id != friendship.Id)
{
return(BadRequest());
}
_context.Entry(friendship).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FriendshipExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutEmployee([FromRoute] long id, [FromBody] Employee employee)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != employee.employeeId)
{
return(BadRequest());
}
_context.Entry(employee).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutBrewery([FromRoute] int id, [FromBody] Brewery brewery)
{
if (id != brewery.BreweryId)
{
return(BadRequest());
}
_context.Entry(brewery).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Brewery.Any(e => e.BreweryId == id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutSensor(int id, Sensor sensor)
{
if (id != sensor.SensorId)
{
return(BadRequest());
}
_context.Entry(sensor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SensorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutPaises(int id, Paises paises)
{
if (id != paises.Id)
{
return(BadRequest());
}
_context.Entry(paises).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaisesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutIncidente(int id, Incidente incidente)
{
if (id != incidente.IncidenteId)
{
return(BadRequest());
}
_context.Entry(incidente).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IncidenteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create([Bind("Order,CategoryId,BrandId,ImageUrl,Price,ProductionDate,Manufacturer,Name,Id")] Product product)
{
if (ModelState.IsValid)
{
_context.Add(product);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["BrandId"] = new SelectList(_context.Brands, "Id", "Id", product.BrandId);
ViewData["CategoryId"] = new SelectList(_context.Categories, "Id", "Id", product.CategoryId);
return(View(product));
}
public async Task <ActionResult <T> > Delete(long id)
{
var entity = await _table.FindAsync(id);
if (entity == null)
{
return(NotFound());
}
_table.Remove(entity);
await _context.SaveChangesAsync(new System.Threading.CancellationToken());
return(Ok(entity));
}
public virtual async Task <T> InsertAsync(T item)
{
DbSet.Add(item);
await Context.SaveChangesAsync();
return(item);
}
public async Task <GameSummaryViewModel> Handle(CreateGameCommand request)
{
if (_context.Games.Any(x => x.Name == request.GameConfig.GameName))
{
throw new ValidationException(new[] { new ValidationFailure("Name", $"A game named \"{request.GameConfig.GameName}\" already exist. Please choose a different name.") });
}
var output = new Game
{
GameGuid = Guid.NewGuid(),
Name = request.GameConfig.GameName,
Rules = request.GameConfig.Rules,
ProgressionMode = (int)request.GameConfig.ProgressionMode,
Description = request.GameConfig.Description,
GameType = (int)request.GameConfig.GameType,
HostId = request.HostId,
Status = (int)GameStatus.WaitingForPlayers
};
output.Actions.Add(new GameAction {
UserId = request.HostId,
Action = (int)Actions.Created,
DateTime = DateTime.Now,
ActionValue = $"Created game with the name \"{request.GameConfig.GameName}\""
});
_context.Games.Add(output);
await _context.SaveChangesAsync();
var gameList = _context.Games.AsNoTracking().Where(x => x.GameId == output.GameId);
return(gameList.ProjectTo <GameSummaryViewModel>().Single());
}
public async Task <GameActionViewModel[]> Handle(HostChosePlayerCommand request)
{
var game = _context.Games
.Include(x => x.Players.Select(p => p.User))
.FirstOrDefault(x => x.GameId == request.GameId);
if (game.HostId != request.UserId)
{
throw new ValidationException(new[] { new ValidationFailure("HostId", $"User with Id of \"{request.UserId}\" is not the host.") });
}
// chose player game
var nextPlayer = game.Players.Single(x => x.UserId == request.NextPlayerId);
var gameActionList = new List <GameAction>();
game.CurrentGamePlayerId = nextPlayer.GamePlayerId;
var gameAction = new GameAction
{
GameId = request.GameId,
UserId = request.UserId,
DateTime = DateTime.Now,
Action = (int)Actions.StatusChanged,
ActionValue = $"has selected the next player \"{nextPlayer.User.DisplayName}\"."
};
_context.GameActions.Add(gameAction);
game.Status = (int)GameStatus.WaitingForPlayer;
gameActionList.Add(gameAction);
await _context.SaveChangesAsync();
return(GameHelpers.ProcessNextPlayerResults(gameActionList, nextPlayer, gameAction, _context));
}
public async Task <ViewModels.User.UserViewModel> Handle(CreateUserCommand request)
{
// TODO: lame validation, make it better
var existAlready = _context.Users.Any(x => x.DisplayName == request.UserConfig.DisplayName || x.Email == request.UserConfig.Email);
if (existAlready)
{
throw new ArgumentException("Display name or username already exist or something else bad happened.");
}
// create user in shanespace.auth
var userCreateRequest = await _userWebProxy.RegisterAsync(ConfigurationManager.AppSettings["ShaneSpaceAuthSiteKey"], new RegisterUser
{
Email = request.UserConfig.Email,
Password = request.UserConfig.Password
});
// create user in shanespace.gamesite
var output = new User
{
AuthId = userCreateRequest.Id,
DisplayName = request.UserConfig.DisplayName,
Email = request.UserConfig.Email
};
_context.Users.Add(output);
await _context.SaveChangesAsync();
return(_context.Users
.AsNoTracking()
.Where(x => x.Id == output.Id)
.ProjectTo <ViewModels.User.UserViewModel>()
.Single());
}
public async Task <GameActionViewModel[]> Handle(StartGameCommand request)
{
var game = _context.Games
.Include(x => x.Players.Select(p => p.User))
.FirstOrDefault(x => x.GameId == request.GameId);
if (game.HostId != request.UserId)
{
throw new ValidationException(new[] { new ValidationFailure("HostId", $"User with Id of \"{request.UserId}\" is not the host.") });
}
// Start game
var gameActionList = new List <GameAction>();
var gameAction = new GameAction
{
GameId = request.GameId,
UserId = request.UserId,
DateTime = DateTime.Now,
Action = (int)Actions.StartedGame,
ActionValue = "has started the game."
};
_context.GameActions.Add(gameAction);
gameActionList.Add(gameAction);
// set next player
GamePlayer nextPlayer;
GameAction nextPlayerAction;
GameHelpers.GetNexPlayer(request, game, gameActionList, out nextPlayer, out nextPlayerAction, _context);
await _context.SaveChangesAsync();
return(GameHelpers.ProcessNextPlayerResults(gameActionList, nextPlayer, nextPlayerAction, _context));
}
public async Task <TMdl> ExecuteAsync(TMdl entity)
{
await _dbset.AddAsync(entity);
await _context.SaveChangesAsync();
return(entity);
}
public async Task <IActionResult> Student()
{
db.teacher.Add(new Teacher()
{
name = "pgb"
});
await db.SaveChangesAsync();
return(Content(""));
}
public async Task <FeedbackViewModel> Handle(AddFeedbackCommand message)
{
var newFeedback = new Models.Feedback
{
UserId = message.UserId,
FeedbackType = (int)message.FeedbackBody.FeedbackType,
FeedbackText = message.FeedbackBody.FeedbackText
};
_context.Feedback.Add(newFeedback);
await _context.SaveChangesAsync();
return(_context.Feedback.Where(x => x.FeedbackId == newFeedback.FeedbackId).ProjectTo <FeedbackViewModel>().Single());
}
public UserRepository(CoreContext context)
{
_context = context;
if (!_context.Users.Any())
{
_context.Users.AddAsync(new User
(
"admin",
"admin",
"Qwerty1234!",
"Admin",
"Admin"
));
}
_context.SaveChangesAsync();
}
public async Task SaveCustomer(EditCustomer customer)
{
using (var db = new CoreContext())
{
var dbCustomer = await db.Customers.FirstAsync(x => x.Id == customer.Id);
// AutoMapper
dbCustomer.City = customer.City;
dbCustomer.CompanyName = customer.CompanyName;
dbCustomer.FirstName = customer.FirstName;
dbCustomer.PostalCode = customer.PostalCode;
dbCustomer.Street = customer.Street;
// 2 SQL Statements
//UPDATE abhängig aus der Änderung zwischen Datenbankwerten (!) <--> customer
await db.SaveChangesAsync();
}
}
public async Task <GameActionViewModel> Handle(JoinGameCommand request)
{
_context.GamePlayers.Add(new GamePlayer {
UserId = request.UserId, GameId = request.GameId
});
var gameAction = new GameAction
{
GameId = request.GameId,
UserId = request.UserId,
DateTime = DateTime.Now,
Action = (int)Actions.Joined,
ActionValue = "has joined the game."
};
_context.GameActions.Add(gameAction);
await _context.SaveChangesAsync();
return(_context.GameActions.Where(x => x.GameActionId == gameAction.GameActionId).ProjectTo <GameActionViewModel>().Single());
}
public async Task <MessageViewModel> Handle(CreateGameMessageCommand request)
{
var game = _context.Games.Single(x => x.GameId == request.GameId);
var message = new Message
{
ComposeDate = DateTime.Now,
GameId = request.GameId,
ComposerId = request.ComposerId,
MessageContents = request.MessageContents
};
game.Messages.Add(message);
await _context.SaveChangesAsync();
var newMessage = _context.Messages.Where(x => x.MessageId == message.MessageId)
.ProjectTo <MessageViewModel>().Single();
return(newMessage);
}
public async Task <IActionResult> Send([FromBody] EmailSurveyToClient emailSurveyToClient)
{
var clientTask = _context.Clients.Where(e => e.Email == emailSurveyToClient.Email).FirstOrDefaultAsync();
var surveyTask = _context.Surveys.Where(e => e.Id == emailSurveyToClient.SurveyId).FirstOrDefaultAsync();
await Task.WhenAll(clientTask, surveyTask);
var client = await clientTask;
var survey = await surveyTask;
var clientSurvey = new ClientSurveys
{
Client = client,
Survey = survey,
ClientSurveyKey = Guid.NewGuid()
};
await _context.ClientSurveys.AddAsync(clientSurvey);
await _context.SaveChangesAsync();
try
{
var email = new MailMessage(
from: "*****@*****.**",
to: clientSurvey.Client.Email,
subject: "New Questionnaire!",
body: $"Hello {clientSurvey.Client.FirstName} {clientSurvey.Client.LastName}, please complete the following survey: <a href='https://localhost:44331/{clientSurvey.Client.Email}/{clientSurvey.ClientSurveyKey}' target='_blank'>{clientSurvey.Survey.Title}</a>"
)
{
IsBodyHtml = true
};
// TODO: add environment var for email
await _smtp.SendMailAsync(email);
}
catch (Exception)
{
throw;
}
return(Ok());
}
public async Task <GameActionViewModel> Handle(LeaveGameCommand request)
{
var game = _context.Games.Include(x => x.Players).Single(x => x.GameId == request.GameId);
var gamePlayer = game.Players.Single(x => x.GameId == request.GameId && x.UserId == request.UserId);
_context.GamePlayers.Remove(gamePlayer);
var leaveGameAction = new GameAction
{
GameId = request.GameId,
UserId = request.UserId,
DateTime = DateTime.Now,
Action = (int)Actions.Exited,
ActionValue = "has left the game."
};
_context.GameActions.Add(leaveGameAction);
await _context.SaveChangesAsync();
return(_context.GameActions.Where(x => x.GameActionId == leaveGameAction.GameActionId).ProjectTo <GameActionViewModel>().Single());
}
public async Task <GameActionViewModel[]> Handle(PlayerRolledDieCommand request)
{
var game = _context.Games
.Include(x => x.Players.Select(p => p.User))
.FirstOrDefault(x => x.GameId == request.GameId);
// wait 5 seconds so you can see a nice spinning animation in UI...
await Task.Delay(5000);
// calculate roll
List <Die> dieList = request.Die.ToObject <List <Die> >();
var dieCount = dieList.Count;
foreach (var die in dieList)
{
die.DieValue = _random.Next(1, die.DieSideCount);
}
// build game action
var gameActionList = new List <GameAction>();
var gameAction = new GameAction
{
GameId = request.GameId,
UserId = request.UserId,
DateTime = DateTime.Now,
Action = (int)Actions.Moved,
ActionValue = $"has rolled {dieCount} die and got the following values: {string.Join(", ", dieList.Select(x => $"D{x.DieSideCount}:{x.DieValue}"))}"
};
_context.GameActions.Add(gameAction);
gameActionList.Add(gameAction);
// set next player
GamePlayer nextPlayer;
GameAction nextPlayerAction;
GameHelpers.GetNexPlayer(request, game, gameActionList, out nextPlayer, out nextPlayerAction, _context);
await _context.SaveChangesAsync();
return(GameHelpers.ProcessNextPlayerResults(gameActionList, nextPlayer, nextPlayerAction, _context));
}
public async Task <GameActionViewModel> Handle(AutoStatusChangeCommand request)
{
var game = _context.Games.Single(x => x.GameId == request.GameId);
game.Status = (int)GameStatus.WaitingForPlayers;
var leaveGameAction = new GameAction
{
UserId = Constants.SystemUser,
DateTime = DateTime.Now,
Action = (int)Actions.StatusChanged,
ActionValue = "has automatically changed the game status to \"Waiting For Players\" because too many players have left the game."
};
game.Actions.Add(leaveGameAction);
await _context.SaveChangesAsync();
var viewModel = _context.GameActions.Where(x => x.GameActionId == leaveGameAction.GameActionId).ProjectTo <GameActionViewModel>().Single();
viewModel.AdditionalInfo = new { Status = GameStatus.WaitingForPlayers };
return(viewModel);
}
public async Task SaveCustomer(EditCustomerEntry originalCustomer, EditCustomer customer)
{
using (var db = new CoreContext())
{
var dbCustomer = new Customers();
dbCustomer.Id = originalCustomer.Id;
dbCustomer.City = originalCustomer.City;
dbCustomer.CompanyName = originalCustomer.CompanyName;
dbCustomer.FirstName = originalCustomer.FirstName;
dbCustomer.PostalCode = originalCustomer.PostalCode;
dbCustomer.Street = originalCustomer.Street;
db.Customers.Attach(dbCustomer);
dbCustomer.City = customer.City;
dbCustomer.CompanyName = customer.CompanyName;
dbCustomer.FirstName = customer.FirstName;
dbCustomer.PostalCode = customer.PostalCode;
dbCustomer.Street = customer.Street;
// NUR 1 SQL Statement!
// UPDATE abhängig aus der Änderung zwischen orignalCustomer <--> customer
await db.SaveChangesAsync();
}
}
public async Task Create(Student std)
{
_context.Students.Add(std);
await _context.SaveChangesAsync();
}
public async Task <bool> Commit()
{
return(await _context.SaveChangesAsync() > 0);
}
