public IActionResult Update(int id, Organization organization)
{
if (ModelState.IsValid)
{
var existingOrganization = _context.Organizations
.Include(or => or.Addresses)
.Single(or => or.Id == id);
if (existingOrganization == null)
{
return(NotFound());
}
// Update Existing Organization
existingOrganization.ModifiedDate = DateTime.Now;
_context.Entry(existingOrganization).CurrentValues.SetValues(organization);
// Delete Addresses
foreach (var existingAddress in existingOrganization.Addresses.ToList())
{
if (!organization.Addresses.Any(o => o.Id == existingAddress.Id))
{
_context.Addresses.Remove(existingAddress);
}
}
// Update and Insert Addresses
foreach (var addressModel in organization.Addresses)
{
var existingAddress = existingOrganization.Addresses
.Where(a => a.Id == addressModel.Id)
.SingleOrDefault();
if (existingAddress != null)
{
_context.Entry(existingAddress).CurrentValues.SetValues(addressModel);
}
else
{
var newAddress = new Address
{
Id = addressModel.Id,
Street = addressModel.Street,
City = addressModel.City,
State = addressModel.State
};
existingOrganization.Addresses.Add(newAddress);
}
}
_context.SaveChanges();
return(NoContent());
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> PutEmployee(int id, Employee employee)
{
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 Update(Document updatedDocument, int documentId)
{
var currentDocument = await Get(documentId);
_context.Entry(currentDocument).CurrentValues.SetValues(updatedDocument);
await SaveChanges();
}
public ActionResult Edit([Bind(Include = "TrainingID,Name,TrainingDate,Location,TrainingEnd,NumberOfMeetings,Duration,ExpireDate,ExpirationDate,QualificationID")] Training training, int[] subsectors)
{
if (ModelState.IsValid)
{
db.Entry(training).State = EntityState.Modified;
// training.TrainingSubSectors.Clear();
var SubSectorToTrainingList = db.TrainingSubSectors.Where(t => t.TrainingID == training.TrainingID).ToList();
foreach (var train in SubSectorToTrainingList)
{
db.TrainingSubSectors.Remove(train);
}
foreach (var id in subsectors)
{
SubSector sub = db.SubSectors.Find(id);
training.AddSubSector(sub);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
var sectorlist = (from s in training.TrainingSubSectors
select s.SubSector.SectorID).ToArray();
var subsectorlist = (from s in training.TrainingSubSectors
select s.SubSectorID).ToArray();
ViewBag.Sectors = new MultiSelectList(db.Sectors, "SectorID", "SectorType", sectorlist);
ViewBag.subSectors = new MultiSelectList(db.SubSectors, "SubSectorID", "SubSectortype", subsectorlist);
ViewBag.QualificationID = new MultiSelectList(db.Qualification, "QualificationID", "Name");
return(View(training));
}
public async Task Update(Meeting updatedMeeting, int meetingId, List <IFormFile> files)
{
var currentMeeting = await Get(meetingId);
if (currentMeeting.Documents == null)
{
currentMeeting.Documents = new List <Document>();
}
foreach (var file in files)
{
string organizationName = CodeList.Organizations[updatedMeeting.OrganizationNumber].ToString();
Document meetingDocument = new Document();
meetingDocument.Name = Path.GetFileNameWithoutExtension(file.FileName);
meetingDocument.Date = DateTime.Today;
meetingDocument.OrganizationNumber = updatedMeeting.OrganizationNumber;
meetingDocument.FileName = Helper.CreateFileName(Helper.GetFileExtension(file.FileName), meetingDocument.Name, meetingDocument.Date, organizationName);
currentMeeting.Documents.Add(meetingDocument);
await SaveFile(meetingDocument, file);
}
_context.Entry(currentMeeting).CurrentValues.SetValues(updatedMeeting);
await SaveChanges();
}
public ActionResult Edit([Bind(Include = "DepartmentID,Name")] Department department)
{
if (ModelState.IsValid)
{
db.Entry(department).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(department));
}
public ActionResult Edit([Bind(Include = "SectorID,SectorType")] Sector sector)
{
if (ModelState.IsValid)
{
db.Entry(sector).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(sector));
}
public ActionResult Edit(User user)
{
if (ModelState.IsValid)
{
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(user));
}
public ActionResult Edit([Bind(Include = "RankingID,Name")] Ranking ranking)
{
if (ModelState.IsValid)
{
db.Entry(ranking).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(ranking));
}
public ActionResult Edit([Bind(Include = "ExternalTrainingID,Name,type,TrainingDate,NumberOfMeetings,Duration,TrainingEnd,Location,Cost")] ExternalTraining externalTraining)
{
if (ModelState.IsValid)
{
db.Entry(externalTraining).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(externalTraining));
}
public ActionResult Edit([Bind(Include = "RoleID,Champion,KDA")] Role role)
{
if (ModelState.IsValid)
{
db.Entry(role).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(role));
}
public async Task <ActionResult> Edit([Bind(Include = "ID,LastName,FirstMidName,HireDate")] Coach coach)
{
if (ModelState.IsValid)
{
db.Entry(coach).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(coach));
}
public async Task <ActionResult> Edit([Bind(Include = "RegionID,Name,Budget,StartDate,CoachID")] Region region)
{
if (ModelState.IsValid)
{
db.Entry(region).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.CoachID = new SelectList(db.Coaches, "ID", "LastName", region.CoachID);
return(View(region));
}
public ActionResult Edit(EmployeeInExternalTraining employeeInTraining)
{
if (ModelState.IsValid)
{
if (employeeInTraining.TrainingStatus == EmployeeInExternalTraining.TrainingStatuses.אושר)
{
var employee = db.Employees.Find(employeeInTraining.EmployeeID);
var training = db.ExternalTrainings.Find(employeeInTraining.ExternalTrainingID);
employee.RemainingBudget -= Convert.ToInt32(training.Cost.Value);
employee.RemainingTrainings -= 1;
db.Entry(employee).State = EntityState.Modified;
}
db.Entry(employeeInTraining).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("EmployeesInExternalTraining", new { id = employeeInTraining.ExternalTrainingID }));
}
ViewBag.EmployeeID = new SelectList(db.Employees, "EmployeeID", "LastName", employeeInTraining.EmployeeID);
ViewBag.ExternalTrainingID = new SelectList(db.ExternalTrainings, "ExternalTrainingID", "Name", employeeInTraining.ExternalTrainingID);
return(View(employeeInTraining));
}
public ActionResult Edit(Employee employee)
{
if (ModelState.IsValid)
{
db.Entry(employee).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.DepartmentID = new SelectList(db.Departments, "DepartmentID", "Name", employee.DepartmentID);
ViewBag.RankingID = new SelectList(db.Rankings, "RankingID", "Name", employee.RankingID);
ViewBag.Sectors = new SelectList(db.Sectors, "SectorID", "SectorType");
ViewBag.SubSectorID = new SelectList(db.SubSectors, "SubSectorID", "SubSectorType", employee.SubSectorID);
return(View(employee));
}
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
Employee employee = new Employee {
Id = id.Value
};
context.Entry(employee).State = EntityState.Deleted;
await context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
User user = new User {
Id = id.Value
};
context.Entry(user).State = EntityState.Deleted;
await context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public ActionResult Edit([Bind(Include = "ID, LastName, FirstMidName, JoinDate")] Player player)
{
try
{
if (ModelState.IsValid)
{
db.Entry(player).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (DataException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(player));
}
public ActionResult Edit([Bind(Include = "EmployeeInTrainingID,EmployeeID,TrainingID,IfPass")] EmployeeInTraining employeeInTraining)
{
if (ModelState.IsValid)
{
if (employeeInTraining.IfPass)
{
var training = db.Trainings.Find(employeeInTraining.TrainingID);
// Find employee qualification
var empQualification = db.EmployeeQualification.Where(empQual => empQual.EmployeeID == employeeInTraining.EmployeeID && empQual.QualificationID == training.QualificationID).FirstOrDefault();
if (empQualification == null)
{
empQualification = new EmployeeQualification()
{
EmployeeID = employeeInTraining.EmployeeID,
QualificationID = training.QualificationID,
ExpirationDate = training.ExpirationDate
};
db.EmployeeQualification.Add(empQualification);
}
else
{
if (empQualification.ExpirationDate < training.ExpirationDate)
{
empQualification.ExpirationDate = training.ExpirationDate;
}
}
}
db.Entry(employeeInTraining).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("EmployeesInTraining", new { id = employeeInTraining.TrainingID }));
}
ViewBag.EmployeeID = new SelectList(db.Employees, "EmployeeID", "LastName", employeeInTraining.EmployeeID);
ViewBag.TrainingID = new SelectList(db.Trainings, "TrainingID", "Name", employeeInTraining.TrainingID);
return(View(employeeInTraining));
}
public ActionResult Edit(Client client)
{
_db.Entry(client).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(Employee employee)
{
_db.Entry(employee).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index"));
}