public async Task <IActionResult> PutLabel(int id, Label label)
{
if (id != label.Id)
{
return(BadRequest());
}
_context.Entry(label).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LabelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutMovieStudio(int id, MovieStudio movieStudio)
{
if (id != movieStudio.Id)
{
return(BadRequest());
}
_context.Entry(movieStudio).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieStudioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutRentedMovies(int id, RentedMovies rentedMovies)
{
if (id != rentedMovies.Id)
{
return(BadRequest());
}
_context.Entry(rentedMovies).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RentedMoviesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Movie> > ChangeMaxRentAmount(int id, Movie movie)
{
var movieToChange = await _context.Movies.FindAsync(id);
Console.WriteLine("Insert chosen string here.");
movieToChange.MaxAmount = movie.MaxAmount;
if (movieToChange.MaxAmount > 10)
{
return(BadRequest());
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(movieToChange);
}
public GroupSpace CreateGroupSpace(GroupSpace groupSpace)
{
var newGroupSpace = _context.GroupSpaces.Add(groupSpace).Entity;
_context.SaveChangesAsync();
return(newGroupSpace);
}
public User Create(User user)
{
var newUser = _context.Users.Add(user).Entity;
_context.SaveChangesAsync();
return(newUser);
}
public async Task <ActionResult <Movie> > RentMovieToStudio(int studioId, int movieId, int alternative)
{
if (alternative == 1)
{
var movieStudio = await _context.MovieStudios.Where(m => m.Id == studioId).FirstOrDefaultAsync();
var movie = await _context.Movies.Where(m => m.Id == movieId).FirstOrDefaultAsync();
movieStudio.AddMovie(movie);
await _context.SaveChangesAsync();
return(StatusCode(201));
}
else if (alternative == 0)
{
var movieToReturn = await _context.MovieStudios.Where(movie => movie.Id == studioId)
.Include(x => x.RentedMovies)
.ThenInclude(x => x.Movie)
.FirstOrDefaultAsync();
movieToReturn.ReturnRentedMovie(movieId);
await _context.SaveChangesAsync();
return(StatusCode(201));
}
else
{
return(BadRequest());
}
}
public async Task <ActionResult <Movie> > ChangeRentQuote(int id, Movie movie)
{
var movieToChange = _context.Movies.Find(id);
movieToChange.MaxAmount = movie.MaxAmount;
if (movieToChange.MaxAmount > 20)
{
return(BadRequest());
}
await _context.SaveChangesAsync();
return(movieToChange);
}
public async Task<Response> Handle(Request request, CancellationToken cancellationToken)
{
var id = request.Id;
var name = request.Name;
// Load tenant
var data = await _db.Tenants.SingleOrDefaultAsync(x => x.Id == id);
if (data == null)
{
throw new NotFoundException("tenant", "id", id);
}
// Check new name is unique
var exists = await _db.Tenants.AnyAsync(x => x.Name == name && x.Id != id);
if (exists)
{
throw new NotUniqueException("tenant", "name", name);
}
// Save tenant
data.Name = name;
_db.Tenants.Update(data);
await _db.SaveChangesAsync();
// Load tenant
var tenant = await _db.Tenants.SingleAsync(x => x.Id == data.Id);
return new Response
{
Tenant = _map.Map<TenantModel>(tenant)
};
}
public async Task <IActionResult> UpdateVehicle([FromBody] Vehicle vehicle)
{
using (var context = new GlobalDbContext())
{
context.Vehicles.Update(vehicle);
await context.SaveChangesAsync();
return(Ok());
}
}
public async Task <IActionResult> UpdateCustomer([FromBody] Customer customer)
{
using (var context = new GlobalDbContext())
{
context.Customers.Update(customer);
await context.SaveChangesAsync();
return(Ok());
}
}
public UserGroupSpace CreateGroupSpaceReference(GroupSpace groupSpace, int creatorUserId)
{
var reference = new UserGroupSpace()
{
GroupSpaceId = groupSpace.Id,
UserId = creatorUserId
};
var newUserGroupSpaceReference = _context.UserGroupSpaces.Add(reference).Entity;
_context.SaveChangesAsync();
return newUserGroupSpaceReference;
}
public async Task <IActionResult> DeleteVehicle([FromQuery] int id)
{
using (var context = new GlobalDbContext())
{
var vehicle = await context.Vehicles.FirstOrDefaultAsync(x => x.Id == id);
if (vehicle != null)
{
context.Vehicles.Remove(vehicle);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <IActionResult> DeleteCustomer([FromQuery] int id)
{
using (var context = new GlobalDbContext())
{
var customer = await context.Customers.FirstOrDefaultAsync(x => x.Id == id);
if (customer != null)
{
context.Customers.Remove(customer);
await context.SaveChangesAsync();
}
return(Ok());
}
}
public async Task <Result> Handle(Request request, CancellationToken cancellationToken)
{
var id = request.Id;
// Load
var data = await _db.Tenants.SingleOrDefaultAsync(x => x.Id == id);
if (data == null)
{
throw new NotFoundException("tenant", "id", id);
}
// Delete
_db.Tenants.Remove(data);
await _db.SaveChangesAsync();
return(new Result());
}
private async Task <Response> ProvisionTenant(Request request)
{
using (var transaction = await _db.Database.BeginTransactionAsync())
{
var tenant = new Tenant
{
Name = request.Name,
Host = request.Host
};
await _db.Tenants.AddAsync(tenant);
await _db.SaveChangesAsync();
var user = new User
{
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
Password = request.Password,
TenantId = tenant.Id
};
await _db.Users.AddAsync(user);
var team = new Team
{
Name = Constants.Teams.DefaultAdministratorsTeam,
TenantId = tenant.Id
};
await _db.Teams.AddAsync(team);
var role = new Role
{
Name = Constants.Teams.DefaultAdministratorsTeam,
TenantId = tenant.Id
};
await _db.Roles.AddAsync(role);
var permissions = PermissionHelper.AllPermissions.Select(name => new RolePermission
{
Role = role,
Name = name
});
await _db.RolePermissions.AddRangeAsync(permissions);
await _db.SaveChangesAsync();
await _db.TeamRoles.AddAsync(new TeamRole
{
Role = role,
Team = team,
TenantId = tenant.Id
});
await _db.UserTeams.AddAsync(new UserTeam
{
User = user,
Team = team,
TenantId = tenant.Id
});
await _db.SaveChangesAsync();
transaction.Commit();
return(new Response
{
Tenant = _map.Map <Tenant, TenantModel>(tenant),
User = _map.Map <User, UserModel>(user)
});
}
}
