public async Task <IActionResult> PostTask([FromBody] TaskDto taskDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Plug plug = await _context.Plugs.FindAsync(taskDto.DeviceMac);
if (plug == null)
{
return(NotFound(Error.PlugDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, plug, _context))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
Models.Task task = _mapper.Map <Models.Task>(taskDto);
plug.AddTask(task, _context);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTasks", new { mac = task.DeviceMac }, task));
}
public async Task <IActionResult> DeleteTask([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var task = await _context.Tasks.FindAsync(id);
if (task == null)
{
return(NotFound());
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, task, _context))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
_context.Tasks.Remove(task);
task.Delete(); // cancel actual Hangfire job
await _context.SaveChangesAsync();
return(Ok(task));
}
public async Task <ActionResult <IEnumerable <PowerUsageSampleDto> > > GetPowerUsageSamples([FromBody] DateRangeDto dateRange)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string mac = dateRange.Mac;
Plug plug = await _context.Plugs.Include(p => p.Samples).SingleOrDefaultAsync(p => p.Mac == mac);
if (plug == null)
{
return(NotFound(Error.PlugDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, plug, _context))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
return(Ok(_mapper.Map <List <PowerUsageSampleDto> >(plug.Samples
.Where(s => s.SampleDate >= dateRange.EarlierDate && s.SampleDate <= dateRange.LaterDate)
.OrderBy(s => s.SampleDate))));
}
public async Task <IActionResult> ChangePassword(string username, [FromBody] PasswordChangeRequestDto request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = await _context.Users.FindAsync(username);
if (user == null)
{
return(NotFound(Error.UserDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, user))
{
return(Unauthorized(Error.UnauthorizedUser));
}
if (user.Password != request.OldPassword)
{
return(BadRequest(Error.IncorrectOldPassword));
}
var appUser = await _userManager.FindByNameAsync(username);
await _userManager.ChangePasswordAsync(appUser, request.OldPassword, request.NewPassword);
user.Password = request.NewPassword;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(username))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <IEnumerable <TaskDto> > > GetTasks(string mac)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Plug plug = await _context.Plugs.Include(p => p.Tasks).SingleOrDefaultAsync(p => p.Mac == mac);
if (plug == null)
{
return(NotFound(Error.PlugDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, plug, _context))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
return(Ok(_mapper.Map <List <TaskDto> >(plug.Tasks)));
}
public async Task <ActionResult <IEnumerable <PlugDto> > > GetUserPlugs([FromRoute] string username)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = await _context.Users.Include(u => u.Plugs).SingleOrDefaultAsync(u => u.Username == username);
if (user == null)
{
return(NotFound(Error.UserDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, user))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
return(Ok(_mapper.Map <List <PlugDto> >(user.Plugs.Where(p => p.IsDeleted == false))));
}
public async Task <ActionResult <PlugDto> > GetPlug([FromRoute] string mac)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var plug = await _context.Plugs.FindAsync(mac);
if (plug == null)
{
return(NotFound(Error.PlugDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, plug, _context))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
return(Ok(_mapper.Map <PlugDto>(plug)));
}
public async Task <IActionResult> PutPlug([FromBody] PlugDtoIn plugDtoIn)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Plug plug = await _context.Plugs.FindAsync(plugDtoIn.Mac);
if (plug == null)
{
return(NotFound(Error.PlugDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, plug, _context))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
_mapper.Map(plugDtoIn, plug);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlugExists(plugDtoIn.Mac))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> TurnApproveOrDenyPlug(string mac, [FromQuery] Models.Task.Operations?op, [FromQuery] bool?approved)
{
Plug plug = await _context.Plugs.FindAsync(mac);
if (plug == null)
{
return(NotFound(Error.PlugDoesNotExist));
}
if (UserOwnershipValidator.IsNotValidated(_currentUsername, plug, _context))
{
return(Unauthorized(Error.UnauthorizedOwner));
}
if (approved != null)
{
plug.Approved = (bool)approved;
if (!plug.Approved)
{
plug.IsDeleted = true;
}
}
await _context.SaveChangesAsync();
if (op != null)
{
try
{
Models.Task.Execute((Models.Task.Operations)op, plug, _context);
}
catch (PlugNotConnectedException)
{
return(BadRequest(Error.PlugNotConnected));
}
}
return(NoContent());
}
