public async Task <IActionResult> PutBuilding(int id, Buildings building)
{
if (id != building.Id)
{
return(BadRequest());
}
_context.Entry(building).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BuildingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutmodifyElevatorStatus(long id, string status)
{
if (status == null)
{
return(BadRequest());
}
var elevator = await _context.Elevators.FindAsync(id);
elevator.Status = status;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElevatorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Intervention> > PutInProgress(long id, string status)
{
if (status == "InProgress")
{
var intervention = await _context.Interventions.FindAsync(id);
intervention.StartDate = System.DateTime.Now;
intervention.Status = status;
await _context.SaveChangesAsync();
return(intervention);
}
else if (status == "Completed")
{
var intervention = await _context.Interventions.FindAsync(id);
intervention.Status = status;
intervention.EndDate = System.DateTime.Now;
await _context.SaveChangesAsync();
return(intervention);
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> PutIntervention(long id, Intervention intervention)
{
if (id != intervention.Id)
{
return(BadRequest());
}
_context.Entry(intervention).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InterventionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> ChangeInterventionStatus(long id, [FromBody] Interventions Intervention)
{
var findIntervention = await _context.Interventions.FindAsync(id);
if (Intervention == null)
{
return(BadRequest());
}
if (findIntervention == null)
{
return(NotFound());
}
if (Intervention.Status == findIntervention.Status)
{
ModelState.AddModelError("Status", "Looks like you didn't change the status.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
findIntervention.Status = Intervention.Status;
if (Intervention.Start_date == findIntervention.Start_date)
{
ModelState.AddModelError("Start date", "Looks like you didn't change the start date.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
findIntervention.Start_date = Intervention.Start_date;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InterventionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
Patch(int id, [FromBody] JsonPatchDocument <Elevators> info)
{
var elevator = await _context.Elevators.FindAsync(id);
info.ApplyTo(elevator);
await _context.SaveChangesAsync();
return(elevator);
}
public async Task <ActionResult <Batteries> > Patch(int id, [FromBody] JsonPatchDocument <Batteries> info)
{
var battery = await _context.Batteries.FindAsync(id);
info.ApplyTo(battery);
await _context.SaveChangesAsync();
return(battery);
}
public async Task <ActionResult <Columns> > Patch(int id, [FromBody] JsonPatchDocument <Columns> info)
{
var column = await _context.Columns.FindAsync(id);
info.ApplyTo(column);
await _context.SaveChangesAsync();
return(column);
}
public async Task <ActionResult <IEnumerable <Interventions> > > PostInterventions(Interventions intervention)
{
Interventions interventionForm = intervention;
interventionForm.Author = 1;
interventionForm.Result = "Incomplete";
interventionForm.Status = "Pending";
_context.Interventions.Add(interventionForm);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetInterventions), new { id = intervention.Id }, intervention));
}
public async Task <ActionResult <Column> > PostColumn(Column column)
{
_context.Columns.Add(column);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetColumns", new { id = column.Id }, column));
}
public async Task <ActionResult <Building> > PostBuilding(Building building)
{
_context.Buildings.Add(building);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBuilding", new { id = building.Id }, building));
}
public async Task <ActionResult <Contract> > PostContract(Contract contract)
{
_context.Contracts.Add(contract);
await _context.SaveChangesAsync();
return(Content("Contract with address: " + contract.Address + " added to database."));
}
public async Task <IActionResult> PutmodifyElevatorsStatus(long id, [FromBody] Elevator body)
{
//check body
if (body.Status == null)
{
return(BadRequest());
}
//find corresponding elevator
var elevator = await _context.Elevators.FindAsync(id);
//change status
elevator.Status = body.Status;
try
{
//save change
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//catch error - elevetor doesn't exist
if (!ElevatorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
//return succeed message
return(new OkObjectResult("success"));
}
public async Task <IActionResult> PutElevator(long id, Elevator elevator)
{
if (id != elevator.Id)
{
return(BadRequest());
}
else if (elevator.Status == "active" || elevator.Status == "inactive" || elevator.Status == "intervention")
{
_context.Entry(elevator).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Content("Elevator Id: " + elevator.Id + " status has been changed to: " + elevator.Status));
}
return(Content("Please enter a valid status."));
}
public async Task <ActionResult <Interventions> > PostIntervention(Interventions newIntervention)
{
newIntervention.StartDateIntervention = DateTime.Now;
newIntervention.UpdatedAt = DateTime.Now;
newIntervention.Status = "InProgress";
newIntervention.Result = "Incomplete";
newIntervention.EmployeeId = null;
_context.Interventions.Add(newIntervention);
await _context.SaveChangesAsync();
return(newIntervention);
}
public async Task <IActionResult> PutBattery(long id, Battery battery)
{
if (id != battery.Id)
{
return(BadRequest());
}
else if (battery.Status == "active" || battery.Status == "inactive" || battery.Status == "intervention")
{
_context.Entry(battery).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Content("Battery Id: " + battery.Id + " status has been changed to: " + battery.Status));
}
return(Content("Please enter a valid status."));
}
public async Task <IActionResult> PutColumn(long id, Column column)
{
if (id != column.Id)
{
return(BadRequest());
}
else if (column.Status == "active" || column.Status == "inactive" || column.Status == "intervention")
{
_context.Entry(column).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Content("Column Id: " + column.Id + " status has been changed to: " + column.Status));
}
return(Content("Please enter a valid status."));
}
public async Task <IActionResult> ChangeElevatorStatus(long id, [FromBody] Elevators elevator)
{
var findElevator = await _context.Elevators.FindAsync(id);
if (elevator == null)
{
return(BadRequest());
}
if (findElevator == null)
{
return(NotFound());
}
if (elevator.Status == findElevator.Status)
{
ModelState.AddModelError("Status", "Looks like you didn't change the status.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
findElevator.Status = elevator.Status;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ElevatorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Customers> > PutCustomer(Customers customer)
{
var customerToUpdate = await _context.Customers
.Where(c => c.EmailOfCompanyContact == customer.EmailOfCompanyContact)
.FirstOrDefaultAsync();
if (customerToUpdate == null)
{
return(NotFound());
}
customerToUpdate.CompanyName = customer.CompanyName;
customerToUpdate.FullNameOfCompanyContact = customer.FullNameOfCompanyContact;
customerToUpdate.CompanyContactPhone = customer.CompanyContactPhone;
customerToUpdate.FullNameOfServiceTechnicalAuthority = customer.FullNameOfServiceTechnicalAuthority;
customerToUpdate.TechnicalAuthorityPhoneForService = customer.TechnicalAuthorityPhoneForService;
customerToUpdate.TechnicalManagerEmailForService = customer.TechnicalManagerEmailForService;
customerToUpdate.CompanyDescription = customer.CompanyDescription;
await _context.SaveChangesAsync();
return(customerToUpdate);
}
