public async Task <IActionResult> PutTheme([FromRoute] int id, [FromBody] Theme theme)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != theme.themeId)
{
return(BadRequest());
}
_context.Entry(theme).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ThemeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
APIReturn re = new APIReturn();
re.Status = "success";
return(Ok(re));
}
// POST: api/Employments
public async Task <ViewEmployments> PostEmployments(ViewEmployments employments)
{
var employmentToAdd = db.Employments.Add(factory.CreateEmploymentsModelFromDb(employments)).Entity;
await db.SaveChangesAsync();
return(factory.CreateEmploymentsViewModel(employmentToAdd));
}
public async Task <IActionResult> PutCategory([FromRoute] int id, [FromBody] Category category)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != category.CategoryId)
{
return(BadRequest());
}
_context.Entry(category).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create([Bind("studentAdmin,studentName,projectId,studentYear")] Student student)
{
if (ModelState.IsValid)
{
//var project = await _context.Projects.SingleOrDefaultAsync(m => m.projectId == student.projectId);
// project.noOfStudents += 1;
// _context.Update(project);
// await _context.SaveChangesAsync();
var check = await _context.Student.SingleOrDefaultAsync(s => s.studentAdmin == student.studentAdmin);
if (check == null)
{
student.dateCreated = DateTime.Now;
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
ViewBag.error = "The student Admin already exists!";
var projectlist = _context.Projects.ToList();
var projectSelect = new SelectList(projectlist, "projectId", "projectName");
ViewBag.projectselect = projectSelect;
return(View());
}
}
return(View(student));
}
public async Task AddToInventoryAsync(int productId)
{
var product = await this._db.Product.FirstOrDefaultAsync(p => p.ProductId == productId);
if (product == null)
{
return;
}
var inventory = await _db.Inventory.FirstOrDefaultAsync(c => c.ProductId == productId);
if (inventory != null)
{
inventory.Quantity++;
}
else
{
inventory = new InventoryModel
{
ProductId = productId,
Quantity = 1,
CreatedOn = DateTime.Now
};
_db.Inventory.Add(inventory);
}
SetTotalPrice(inventory);
await _db.SaveChangesAsync();
}
public async Task <bool> AddPageAsync(Page newPage)
{
await _context.Pages.AddAsync(newPage);
await _context.SaveChangesAsync();
return(true);
}
public async Task <ViewSchedules> PutSchedules(int id, ViewSchedules viewSchedules)
{
var schedulesInDb = await db.Schedules.FirstOrDefaultAsync(x => x.ScheduleId == id);
db.Schedules.Attach(schedulesInDb);
factory.ScedulePutMaker(schedulesInDb, viewSchedules);
await db.SaveChangesAsync();
return(factory.CreateViewSchedules(schedulesInDb));
}
public async Task <IActionResult> Create(VisitType visitType2)
{
if (ModelState.IsValid)
{
_context.Add(visitType2);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(visitType2));
}
public async Task <ActionResult> Edit([Bind(Include = "ID,FirstName,LastName,EmailAddress,Birthdate,NumberOfComputers")] Contact contact)
{
if (ModelState.IsValid)
{
db.Entry(contact).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(contact));
}
// PUT: api/Customers/5
public async Task <ViewCustomer> PutCustomers(int id, ViewCustomer viewCustomer)
{
var customerDb = factory.CreateCustumerModelFromViewModel(viewCustomer);
var customerLoadDb = await db.Customers.FirstOrDefaultAsync(x => x.Id == id);
db.Customers.Attach(customerLoadDb);
factory.CustomerPutMaker(customerDb, customerLoadDb);
await db.SaveChangesAsync();
return(factory.CreateViewCustumerModelFromDb(customerLoadDb));
}
public async Task <IActionResult> Create([Bind("courseId,courseName,courseSubject,courseInstructor,courseVenue")] ShortCourses shortCourses)
{
if (ModelState.IsValid)
{
shortCourses.dateCreated = DateTime.Now;
_context.Add(shortCourses);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(shortCourses));
}
public async Task <ActionResult> Create([Bind(Include = "LocationID,LAT,LONG,Name")] Location location)
{
if (ModelState.IsValid)
{
db.Locations.Add(location);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(location));
}
public async Task <ActionResult> Create([Bind(Include = "ID,ContactID,AddressType,AddressLine1,AddressLine2,City,StateCode,Zip")] Address address)
{
if (ModelState.IsValid)
{
db.Addresses.Add(address);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(address));
}
public async Task <IActionResult> Create([Bind("awardId,awardName,awardLevel,noOfRecipients,awardType")] Awards awards)
{
if (ModelState.IsValid)
{
awards.dateCreated = DateTime.Now;
_context.Add(awards);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(awards));
}
public async Task <IActionResult> Create([Bind("themeId,themeName,dateCreated,backgroundColor,fontStyle")] Theme theme)
{
if (ModelState.IsValid)
{
theme.dateCreated = DateTime.Now;
_context.Add(theme);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(theme));
}
public async Task <ActionResult> Create([Bind(Include = "DeviceID,LocationID,Build")] Device device)
{
if (ModelState.IsValid)
{
db.Devices.Add(device);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.LocationID = new SelectList(db.Locations, "LocationID", "Name", device.LocationID);
return(View(device));
}
public async Task <IActionResult> Create([Bind("projectId,projectName,projectState")] Projects projects)
{
if (ModelState.IsValid)
{
projects.noOfStudents = 0;
projects.dateCreated = DateTime.Now;
_context.Add(projects);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(projects));
}
public async Task <IActionResult> PutVisits([FromRoute] int id, [FromBody] Visits visits)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//if (id != visits.visitId)
//{
// return BadRequest();
//}
//_context.Entry(visits).State = EntityState.Modified;
var list = await _context.Visits.AsNoTracking().ToListAsync();
//list.Where(s => s.visitId == id);
foreach (Visits v in list)
{
if (v.visitId == id)
{
visits.dateCreated = v.dateCreated;
visits.visitDate = v.visitDate;
break;
}
}
try
{
visits.visitId = id;
//return Ok("开始更新" + visits.dateCreated + " " + visits.GetType()+" "+visits.visitId);
_context.Update(visits);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
if (!VisitsExists(id))
{
return(NotFound());
}
else
{
return(BadRequest(e.Message.ToString()));
}
}
APIReturn re = new APIReturn();
re.Status = "success";
return(Ok(re));
}
public async Task AcceptCompanyManagementInvite(UserInfo userInfo)
{
using (var db = new CMSContext())
{
var companyManagementInvite = await db.CompanyManagementInvites.SingleOrDefaultAsync(c => c.Email == userInfo.Email && c.CompanyId == Dto.CompanyId);
if (companyManagementInvite == null)
{
throw new Exception("Company Management Invite for this User doesn't exist!");
}
db.CompanyManagementInvites.Remove(companyManagementInvite);
var companyManagement = new CompanyManagement
{
Id = Guid.NewGuid(),
CompanyId = Dto.CompanyId,
UserId = userInfo.UserId,
IsAdmin = companyManagementInvite.IsInviteForAdmin,
CreatedBy = userInfo.UserId,
CreatedOn = DateTime.UtcNow
};
db.CompanyManagements.Add(companyManagement);
await db.SaveChangesAsync();
}
}
public async Task <ActionResult <Branch> > PutBranchItem(int branchId, Branch Branch)
{
if (branchId != Branch.BranchId)
{
return(BadRequest());
}
_context.Entry(Branch).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//if (!Branch(branchId))
//{
// return NotFound();
//}
//else
//{
// throw;
//}
}
return(NoContent());
}
public async Task <GetCandidateDto> CreateCandidate(UserInfo userInfo)
{
if (!userInfo.IsCandidateLogin || userInfo.UserId != Dto.UserId)
{
throw new Exception("You do not have access to perform this action!");
}
using (var db = new CMSContext())
{
var checkExistingCandidate = db.Candidates.Any(c => c.UserId == Dto.UserId && c.JobOpeningId == Dto.JobOpeningId);
if (checkExistingCandidate)
{
throw new Exception("Candidate has already applied for this Job Position!");
}
var candidate = new Candidate
{
Id = Guid.NewGuid(),
UserId = Dto.UserId,
CompanyId = Dto.CompanyId,
JobOpeningId = Dto.JobOpeningId,
CreatedBy = userInfo.UserId,
CreatedOn = DateTime.UtcNow
};
db.Candidates.Add(candidate);
await db.SaveChangesAsync();
return((await new GetCandidatesInternalQuery(candidateId: candidate.Id, userId: userInfo.UserId).GetAllCandidates()).SingleOrDefault());
}
}
public async Task DeleteCompanyManagement(UserInfo userInfo)
{
using (var db = new CMSContext())
{
if (userInfo.IsCandidateLogin || userInfo.CompanyId != Dto.CompanyId)
{
throw new Exception("You do not have access to perform this action!");
}
var company = await db.Companies.Include(c => c.JobOpenings).Include(c => c.CompanyManagements).SingleOrDefaultAsync(c => c.Id == Dto.CompanyId);
if (company == null)
{
throw new Exception("Company with Id not found!");
}
var companyManagerAccess = company.CompanyManagements.Any(c => c.CompanyId == Dto.CompanyId && c.UserId == userInfo.UserId && c.IsAdmin);
if (!companyManagerAccess)
{
throw new Exception("You do not have access to perform this action!");
}
var companyManagement = company.CompanyManagements.SingleOrDefault(c => c.CompanyId == Dto.CompanyId && c.UserId == Dto.UserId);
if (companyManagement == null)
{
throw new Exception("This User is not a part of this Company!");
}
db.CompanyManagements.Remove(companyManagement);
await db.SaveChangesAsync();
}
}
public async Task DeleteCandidate(UserInfo userInfo)
{
using (var db = new CMSContext())
{
var candidate = await db.Candidates.SingleOrDefaultAsync(c => c.Id == CandidateId);
if (candidate == null)
{
throw new Exception("Candidate with Id not found!");
}
if ((!userInfo.IsCandidateLogin && userInfo.CompanyId != candidate.CompanyId) || (userInfo.IsCandidateLogin && userInfo.UserId != candidate.UserId))
{
throw new Exception("You do not have access to perform this action!");
}
var candidateTests = await db.CandidateTests
.Include(ct => ct.CandidateTestScores)
.Where(ct => ct.CandidateId == CandidateId).ToListAsync();
db.CandidateTestScores.RemoveRange(candidateTests.SelectMany(ct => ct.CandidateTestScores));
db.CandidateTests.RemoveRange(candidateTests);
db.Candidates.Remove(candidate);
await db.SaveChangesAsync();
}
}
public async Task <GetTestDto> CreateTest(UserInfo userInfo)
{
if (userInfo.IsCandidateLogin)
{
throw new Exception("You do not have access to perform this action!");
}
using (var db = new CMSContext())
{
var checkExistingTest = db.Tests.Any(c => c.Title == Dto.Title.Trim() && c.CompanyId == userInfo.CompanyId);
if (checkExistingTest)
{
throw new Exception("Test with this name already exists!");
}
var test = new Test
{
Id = Guid.NewGuid(),
Title = Dto.Title.Trim(),
Description = Dto.Description.Trim(),
CompanyId = (Guid)userInfo.CompanyId,
CreatedBy = userInfo.UserId,
CreatedOn = DateTime.UtcNow,
};
db.Tests.Add(test);
await db.SaveChangesAsync();
return(await new GetTestAsCompanyManagerQuery(test.Id).GetTestAsCompanyManager(userInfo));
}
}
public async Task UpdatePassword(UserInfo userInfo)
{
using (var db = new CMSContext())
{
var user = await db.Users.SingleOrDefaultAsync(u => u.Id == userInfo.UserId);
// User doesn't exist
if (user == null)
{
throw new Exception("User with this email already exists!");
}
byte[] passwordHash, passwordSalt;
PasswordService.CreatePasswordHash(Dto.Password, out passwordHash, out passwordSalt);
user.PasswordSalt = passwordSalt;
user.PasswordHash = passwordHash;
try
{
await db.SaveChangesAsync();
}
catch (Exception e)
{
throw e;
}
}
}
public async Task RevokeCompanyManagementInvite(UserInfo userInfo)
{
using (var db = new CMSContext())
{
var companyManagerAccess = await db.CompanyManagements.AnyAsync(c => c.CompanyId == Dto.CompanyId && c.UserId == userInfo.UserId && c.IsAdmin);
if (!companyManagerAccess)
{
throw new Exception("You do not have access to perform this action!");
}
var companyManagementInvite = await db.CompanyManagementInvites.SingleAsync(c => c.Email == Dto.Email.Trim() && c.CompanyId == Dto.CompanyId);
if (companyManagementInvite == null)
{
throw new Exception("Company Management Invite for this Email doesn't exist!");
}
var checkExistingManagement = await(from cm in db.CompanyManagements
join usr in db.Users on cm.UserId equals usr.Id
where
cm.CompanyId == Dto.CompanyId &&
usr.Email == Dto.Email.Trim()
select cm).AnyAsync();
if (checkExistingManagement)
{
throw new Exception("This User is already a part of this company!");
}
db.CompanyManagementInvites.Remove(companyManagementInvite);
await db.SaveChangesAsync();
}
}
public async Task <GetTestDto> UpdateTest(UserInfo userInfo)
{
if (userInfo.IsCandidateLogin)
{
throw new Exception("You do not have access to perform this action!");
}
using (var db = new CMSContext())
{
var test = await db.Tests.SingleOrDefaultAsync(c => c.Id == Dto.Id && c.CompanyId == userInfo.CompanyId);
if (test == null)
{
throw new Exception("Test with Id not found!");
}
var checkExistingTest = db.Tests.Any(c => c.Title == Dto.Title.Trim() && c.CompanyId == userInfo.CompanyId && c.Id != Dto.Id);
if (checkExistingTest)
{
throw new Exception("Test with this title already exists!");
}
test.Title = Dto.Title;
test.Description = Dto.Description;
await db.SaveChangesAsync();
return(await new GetTestAsCompanyManagerQuery(test.Id).GetTestAsCompanyManager(userInfo));
}
}
public async Task EditAsync(Comment model, int commentId)
{
var comment = await GetCommentById(commentId);
comment.Content = model.Content;
await db.SaveChangesAsync();
}
public async Task <IActionResult> PutAwards([FromRoute] int id, [FromBody] Awards awards)
{
if (!ModelState.IsValid)
{
APIReturn re4 = new APIReturn();
re4.Status = "Failed";
return(BadRequest(re4));
}
if (id != awards.awardId)
{
APIReturn re2 = new APIReturn();
re2.Status = "Failed";
return(BadRequest(re2));
}
//_context.Entry(awards).State = EntityState.Modified;
var list = await _context.Awards.AsNoTracking().SingleAsync(s => s.awardId == id);
awards.dateCreated = list.dateCreated;
awards.awardId = id;
try
{
_context.Update(awards);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AwardsExists(id))
{
APIReturn re1 = new APIReturn();
re1.Status = "Failed";
return(BadRequest(re1));
}
else
{
throw;
}
}
APIReturn re = new APIReturn();
re.Status = "success";
return(Ok(re));
}
public async Task <CandidateTestDto> CreateCandidateTest(UserInfo userInfo)
{
if (userInfo.IsCandidateLogin)
{
throw new Exception("You do not have access to perform this action!");
}
using (var db = new CMSContext())
{
var candidate = await db.Candidates.SingleOrDefaultAsync(c => c.Id == Dto.CandidateId && c.CompanyId == userInfo.CompanyId);
if (candidate == null)
{
throw new Exception("Candidate with specified id was not found!");
}
var checkExistingCandidate = db.CandidateTests.Any(c => c.CandidateId == Dto.CandidateId && c.TestId == Dto.TestId);
if (checkExistingCandidate)
{
throw new Exception("Candidate already has this Test in his profile!");
}
var candidateTest = new CandidateTest
{
Id = Guid.NewGuid(),
CandidateId = Dto.CandidateId,
TestId = Dto.TestId,
};
db.CandidateTests.Add(candidateTest);
var testScores = await db.TestScores.Include(ts => ts.Test).Where(c => c.TestId == Dto.TestId && c.Test.CompanyId == userInfo.CompanyId).ToListAsync();
if (testScores == null)
{
throw new Exception("Test Score with specified id was not found!");
}
foreach (var testScore in testScores)
{
var candidateTestScore = new CandidateTestScore
{
Id = Guid.NewGuid(),
CandidateTestId = candidateTest.Id,
TestScoreId = testScore.Id,
Value = null,
Comment = null
};
db.CandidateTestScores.Add(candidateTestScore);
}
await db.SaveChangesAsync();
return((await new GetCandidateTestsInternalQuery(Dto.TestId, companyId: userInfo.CompanyId, candidateId: Dto.CandidateId).GetCandidateTests()).SingleOrDefault());
}
}
