public async Task <ActionResult <string> > PutBlockchain([FromRoute] long id, Blockchain blockchain)
{
if (id != blockchain.id)
{
return(BadRequest());
}
if (blockchain.nodeName == "ProjectOffice" || blockchain.nodeName == "MaterialProvider" || blockchain.nodeName == "SolutionManufacturing" || blockchain.nodeName == "QualitySecurity")
{
Blockchain blockchainFound = await _context.blockchains.FindAsync(id);
blockchainFound.address = blockchain.address;
try
{
await _context.SaveChangesAsync();
return(blockchain.nodeName);
}
catch (DbUpdateConcurrencyException)
{
if (!blockchainExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Content("Valid status: ProjectOffice, MaterialProvider, SolutionManufacturing, QualitySecurity . Try again! "));
}
public async Task <IActionResult> PutIntervention(long id, Intervention intervention)
{
if (id != intervention.id)
{
return(BadRequest());
}
Intervention interventionFound = await _context.interventions.FindAsync(id);
interventionFound.status = intervention.status;
interventionFound.start_date_intervention = DateTime.Now;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InterventionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutElevator([FromRoute] long id, Elevator elevator)
{
if (id != elevator.id)
{
return(BadRequest());
}
if (elevator.status == "Active" || elevator.status == "Inactive" || elevator.status == "Intervention")
{
Elevator elevatorFound = await _context.elevators.FindAsync(id);
elevatorFound.status = elevator.status;
try
{
await _context.SaveChangesAsync();
return(Content("Elevator: " + elevator.id + ", status as been change to: " + elevator.status));
}
catch (DbUpdateConcurrencyException)
{
if (!ElevatorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Content("Valid status: Intervention, Inactive, Active. Try again! "));
}
public async Task <IActionResult> PutBattery([FromRoute] long id, Battery battery)
{
if (id != battery.id)
{
return(BadRequest());
}
if (battery.status == "Active" || battery.status == "Inactive" || battery.status == "Intervention")
{
Battery batteryFound = await _context.batteries.FindAsync(id);
batteryFound.status = battery.status;
try
{
await _context.SaveChangesAsync();
return(Content("Battery: " + battery.id + ", status as been change to: " + battery.status));
}
catch (DbUpdateConcurrencyException)
{
if (!BatteryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Content("Valid status: Intervention, Inactive, Active. Try again! "));
}
public async Task <IActionResult> PutColumn([FromRoute] long id, Column column)
{
if (id != column.id)
{
return(BadRequest());
}
if (column.status == "Active" || column.status == "Inactive" || column.status == "Intervention")
{
Column columnFound = await _context.columns.FindAsync(id);
columnFound.status = column.status;
try
{
await _context.SaveChangesAsync();
return(Content("Column: " + column.id + ", status as been change to: " + column.status));
}
catch (DbUpdateConcurrencyException)
{
if (!ColumnExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Content("Valid status: Intervention, Inactive, Active. Try again! "));
}
public async Task<ActionResult<string>> PutElevator([FromRoute] long id, Elevator elevator)
{
if (id != elevator.id)
{
return BadRequest();
}
if (elevator.status == "active" || elevator.status == "inactive" || elevator.status == "intervention")
{
Elevator elevatorFound = await _context.elevators.FindAsync(id);
elevatorFound.status = elevator.status;
try
{
await _context.SaveChangesAsync();
return elevator.status;
}
catch (DbUpdateConcurrencyException)
{
if (!ElevatorExists(id))
{
return NotFound();
}
else
{
throw;
}
}
}
return Content("Valid status: Intervention, Inactive, Active. Try again! ");
}
public async Task <AssignTaskVM> AddTask(AssignTaskVM task)
{
var user = _db.Users.Find(task.UserId);
AssignTask assignTask = new AssignTask
{
TaskId = 0,
Name = task.Name,
Description = task.Description,
StartDate = task.StartDate,
EndDate = task.EndDate,
AssignTo = user
};
_db.AssignTasks.Add(assignTask);
await _db.SaveChangesAsync();
task.TaskId = assignTask.TaskId;
return(task);
}
public async Task <IActionResult> ChangeInterventionStatus(long id)
{
var findIntervention = await _context.interventions.FindAsync(id);
if (findIntervention == null)
{
return(NotFound());
}
if (findIntervention.status == "InProgress")
{
ModelState.AddModelError("Status", "This status is in progress.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
findIntervention.status = "InProgress";
findIntervention.start_date = DateTime.Today;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InterventionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Address> > PutAddress(Address address)
{
var addressUpdate = await _context.addresses
.Where(add => add.postal_code == address.postal_code)
.FirstOrDefaultAsync();
if (addressUpdate == null)
{
return(NotFound());
}
addressUpdate.number_and_street = address.number_and_street;
addressUpdate.city = address.city;
addressUpdate.postal_code = address.postal_code;
addressUpdate.country = address.country;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <Customer> > PutCustomer(Customer customer)
{
var customerToUpdate = await _context.customers
.Where(c => c.email_of_company_contact == customer.email_of_company_contact)
.FirstOrDefaultAsync();
if (customerToUpdate == null)
{
return(NotFound());
}
customerToUpdate.company_name = customer.company_name;
customerToUpdate.full_name_of_company_contact = customer.full_name_of_company_contact;
customerToUpdate.company_contact_phone = customer.company_contact_phone;
customerToUpdate.email_of_company_contact = customer.email_of_company_contact;
customerToUpdate.company_description = customer.company_description;
customerToUpdate.full_name_of_service_technical_authority = customer.full_name_of_service_technical_authority;
customerToUpdate.technical_authority_phone_for_service_ = customer.technical_authority_phone_for_service_;
customerToUpdate.technical_manager_email_for_service = customer.technical_manager_email_for_service;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <bool> AddUser(User user)
{
db.Users.Add(user);
return(await db.SaveChangesAsync() > 0);
}