public async Task <LabGroup> Create(LabGroupCreate groupIn)
{
var group = LabGroup.FromCreate(groupIn);
await _labGroups.InsertOneAsync(group);
return(group);
}
public async Task <IActionResult> Update([FromHeader] string authToken, string id, LabGroupUpdate update)
{
if (!await _authenticationService.CheckAccess(authToken, "groupMgr"))
{
return(Unauthorized());
}
LabGroup group = await _labGroupService.Get(id);
if (group == null)
{
return(NotFound());
}
_labGroupService.Update(group, update);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document modified.",
"labGroups",
id,
JsonSerializer.Serialize(LabGroup.FromUpdate(group, update))
));
return(Ok());
}
} // SQL insert of the Mark Scheme Parts
public bool UploadLabGroup(LabGroup labGroupToUpload)
{
try
{
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder();
builder.DataSource = "tarambana.database.windows.net";
builder.UserID = "tasa";
builder.Password = "******";
builder.InitialCatalog = "bookChoice";
using (SqlConnection connection = new SqlConnection(builder.ConnectionString))
{
using (SqlCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandType = CommandType.Text;
command.CommandText = "INSERT INTO dbo.LabGroup (LabGroupAssignmentID, LabGroupLocation, LabGroupNumber, LabGroupStudentID, LabGroupUnit) VALUES (@labGroupAssignmentID, @labGroupLocation, @labGroupNumber, @labGroupStudentID, @labGroupUnit)";
command.Parameters.AddWithValue("@labGroupAssignmentID", labGroupToUpload.labGroupAssignmentID);
command.Parameters.AddWithValue("@labGroupLocation", labGroupToUpload.labGroupLocation);
command.Parameters.AddWithValue("@labGroupNumber", labGroupToUpload.labGroupNumber);
command.Parameters.AddWithValue("@labGroupStudentID", labGroupToUpload.labGroupStudentID);
command.Parameters.AddWithValue("@labGroupUnit", labGroupToUpload.labGroupUnit);
connection.Open();
command.ExecuteNonQuery();
return(true);
}
}
}
catch (SqlException e)
{
Console.WriteLine(e.ToString());
return(false);
} // SQL insert of the Mark Scheme LabGroup
}
public async Task <ActionResult <Order> > Create([FromHeader] string authToken, bool stockroom, OrderCreate create)
{
if (stockroom)
{
if (!await _authenticationService.CheckAccess(authToken, "orderMgr"))
{
return(Unauthorized());
}
Order created = await _orderService.CreateStockroom(create);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Order Placed",
"orders",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(created));
}
else
{
if (!await _authenticationService.CheckAccess(authToken, "orderView"))
{
return(Unauthorized());
}
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
Order created = await _orderService.Create(create, group.Id);
group.BudgetBalance = group.BudgetBalance - (created.UnitCost * created.Quantity);
group.Transactions.Add(new Transaction(
created.Id,
"Remove",
"Order Submitted",
(created.UnitCost * created.Quantity),
DateTime.UtcNow
));
_labGroupService.Update(group, group.Id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Order Placed",
"orders",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(created));
}
}
public async Task <ActionResult <List <Dictionary <string, object> > > > Get([FromHeader] string authToken, [FromQuery] string view)
{
if (!await _authenticationService.CheckAccess(authToken, "logView"))
{
return(Unauthorized());
}
List <Dictionary <string, object> > logs = new List <Dictionary <string, object> >();
if (view == "orders")
{
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
logs = await _logViewService.GetOrderHistory(view, group, _supplierService);
}
else if (view == "transactions")
{
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
int i = 1;
foreach (Transaction t in group.Transactions)
{
Dictionary <string, object> transaction = new Dictionary <string, object>();
transaction["action"] = t.Action;
transaction["amount"] = t.Amount;
transaction["description"] = t.Description;
if (t.OrderId == string.Empty || t.OrderId == null)
{
transaction["order"] = null;
}
else
{
Order o = await _orderService.Get(t.OrderId);
Supplier s = await _supplierService.Get(o.SupplierId);
Dictionary <string, object> order = new Dictionary <string, object>();
order["placedUtc"] = o.PlacedUtc;
order["partNumber"] = o.PartNumber;
if (!(s == null))
{
order["supplierName"] = s.Name;
}
order["url"] = o.Url;
transaction["order"] = order;
}
transaction["utc"] = t.Utc;
transaction["key"] = i;
logs.Add(transaction);
i++;
}
}
return(logs);
}
public async Task <ActionResult <LabGroup> > Create([FromHeader] string authToken, LabGroupCreate create)
{
if (!await _authenticationService.CheckAccess(authToken, "groupMgr"))
{
return(Unauthorized());
}
List <string> members = new List <string>();
foreach (string techId in create.Members)
{
User temp = await _userService.GetByTechId(techId);
members.Add(temp.Id);
}
LabCourse course = await _labCourseService.Get(create.LabCourseId);
LabGroupCreate editCreate = create;
editCreate.Members = members;
editCreate.Budget = course.InitialBudget;
editCreate.BudgetBalance = course.InitialBudget;
editCreate.GroupNumber = (course.LabGroups == null) ? 1 : course.LabGroups.Count + 1;
editCreate.Transactions = new List <Transaction>();
editCreate.Transactions.Add(new Transaction(null, "Add", "Initial Budget", course.InitialBudget, DateTime.UtcNow));
LabGroup created = await _labGroupService.Create(editCreate);
await _labCourseService.AddGroup(course, created.Id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Group created.",
"labGroups",
created.Id,
JsonSerializer.Serialize(created)
));
foreach (string id in created.Members)
{
User temp = await _userService.Get(id);
temp.Permissions.Add("61db5dde3fb8d66a6bbdde3b");
temp.Permissions.Add("61db59a03fb8d66a6bbdde34");
temp.Permissions.Add("61db5a813fb8d66a6bbdde36");
await _tokenService.InvalidateUserTokens(temp.Id);
_userService.Update(temp.Id, temp);
}
return(Ok(created));
}
public async Task <LabGroup> CheckIn(string checkIn)
{
LabGroup group = await _labGroups.Find <LabGroup>(labGroup => labGroup.CheckedOut.Contains(checkIn)).FirstOrDefaultAsync();
group.CheckedOut.Remove(checkIn);
await _labGroups.ReplaceOneAsync(labGroup => labGroup.Id == group.Id, group);
return(group);
}
public async Task <IActionResult> Delete([FromHeader] string authToken, string id)
{
if (!await _authenticationService.CheckAccess(authToken, "groupMgr"))
{
return(Unauthorized());
}
LabGroup group = await _labGroupService.Get(id);
if (group == null)
{
return(NotFound());
}
LabCourse course = await _labCourseService.Get(group.LabCourseId);
if (group.Members != null)
{
foreach (string memberId in group.Members)
{
User temp = await _userService.Get(memberId);
temp.Permissions.Remove("61db5dde3fb8d66a6bbdde3b");
temp.Permissions.Remove("61db59a03fb8d66a6bbdde34");
temp.Permissions.Remove("61db5a813fb8d66a6bbdde36");
await _tokenService.InvalidateUserTokens(memberId);
_userService.Update(temp.Id, temp);
}
}
LabBench bench = await _labBenchService.Get(group.LabBenchId);
if (bench != null)
{
_labBenchService.CheckInOut(bench, null, "Available");
}
await _labCourseService.RemoveGroup(course, id);
await _labGroupService.Delete(id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document deleted.",
"labGroup",
id,
null
));
return(Ok());
}
public async Task <IActionResult> Delete([FromHeader] string authToken, string id)
{
if (!await _authenticationService.CheckAccess(authToken, "courseMgr"))
{
return(Unauthorized());
}
LabCourse course = await _labCourseService.Get(id);
if (course == null)
{
return(NotFound());
}
if (course.LabGroups != null)
{
foreach (string labgroupId in course.LabGroups)
{
LabGroup group = await _labGroupService.Get(labgroupId);
foreach (string memberId in group.Members)
{
User temp = await _userService.Get(memberId);
if (temp != null)
{
temp.Permissions.Remove("61db5dde3fb8d66a6bbdde3b");
temp.Permissions.Remove("61db59a03fb8d66a6bbdde34");
temp.Permissions.Remove("61db5a813fb8d66a6bbdde36");
_userService.Update(temp.Id, temp);
}
}
await _labGroupService.Delete(labgroupId);
}
}
await _labCourseService.Delete(id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document deleted.",
"labCourses",
id,
null
));
return(Ok());
}
public async Task <ActionResult <List <Dictionary <string, object> > > > Get([FromHeader] string authToken, bool active)
{
if (!await _authenticationService.CheckAccess(authToken, "orderView"))
{
return(Unauthorized());
}
if (active)
{
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
List <Order> orders = await _orderService.GetActiveByGroupId(group.Id);
if (orders == null || orders.Count == 0)
{
return(NotFound());
}
List <Dictionary <string, object> > activeOrders = new List <Dictionary <string, object> >();
foreach (Order order in orders)
{
Dictionary <string, object> o = new Dictionary <string, object>();
o["description"] = order.Description;
o["partNumber"] = order.PartNumber;
o["quantity"] = order.Quantity;
o["unitCost"] = order.UnitCost;
o["url"] = order.Url;
o["status"] = order.Status;
o["placedUtc"] = order.PlacedUtc;
o["shippedUtc"] = order.ShippedUtc;
o["receivedUtc"] = order.ReceivedUtc;
Supplier s = await _supplierService.Get(order.SupplierId);
if (s != null)
{
o["supplierName"] = s.Name;
}
activeOrders.Add(o);
}
return(activeOrders);
}
return(NotFound());
}
public async Task <ActionResult <Dictionary <string, object> > > Get([FromHeader] string authToken, bool thisDoesNothing)
{
if (!await _authenticationService.CheckAccess(authToken, "groupView"))
{
return(Unauthorized());
}
Dictionary <string, object> groupBudget = new Dictionary <string, object>();
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
groupBudget["budget"] = group.Budget;
groupBudget["budgetBalance"] = group.BudgetBalance;
return(groupBudget);
}
public async Task <ActionResult <List <Order> > > Get([FromHeader] string authToken)
{
if (!await _authenticationService.CheckAccess(authToken, "orderView"))
{
return(Unauthorized());
}
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
var orders = await _orderService.GetByGroupId(group.Id);
if (orders == null || orders.Count == 0)
{
return(NotFound());
}
return(orders);
}
public async Task <ActionResult <Dictionary <string, object> > > Get([FromHeader] string authToken, string id, bool doesNothing)
{
if (!await _authenticationService.CheckAccess(authToken, "groupView"))
{
return(Unauthorized());
}
LabGroup group = await _labGroupService.Get(id);
if (group == null)
{
return(NotFound());
}
Dictionary <string, object> groupInfo = new Dictionary <string, object>();
groupInfo["groupNumber"] = group.GroupNumber;
List <string> members = new List <string>();
foreach (string userId in group.Members)
{
User temp = await _userService.Get(userId);
if (temp == null)
{
return(NotFound());
}
if (temp.PreferredName == null)
{
members.Add(temp.TechId + " " + temp.FirstName + " " + temp.LastName);
}
else
{
members.Add(temp.TechId + " " + temp.PreferredName + " " + temp.LastName);
}
}
groupInfo["members"] = members;
return(groupInfo);
}
} // Reads XML and extracts Mark Scheme info into a data structure passed by reference
public bool GetLabGroupInfo(String pathToXML, ref LabGroup inputLabGroup)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(pathToXML);
XmlNodeList elemList = doc.GetElementsByTagName("LabGroupLocation");
for (int i = 0; i < elemList.Count; i++)
{
inputLabGroup.labGroupLocation = elemList[i].InnerText;
}
XmlNodeList elemList1 = doc.GetElementsByTagName("LabGroupNumber");
for (int i = 0; i < elemList1.Count; i++)
{
inputLabGroup.labGroupNumber = int.Parse(elemList1[i].InnerText);
}
XmlNodeList elemList2 = doc.GetElementsByTagName("LabGroupStudentID");
for (int i = 0; i < elemList2.Count; i++)
{
inputLabGroup.labGroupStudentID = int.Parse(elemList2[i].InnerText);
}
XmlNodeList elemList4 = doc.GetElementsByTagName("LabGroupUnit");
for (int i = 0; i < elemList4.Count; i++)
{
inputLabGroup.labGroupUnit = elemList4[i].InnerText;
}
XmlNodeList elemList5 = doc.GetElementsByTagName("assignmentNumber");
for (int i = 0; i < elemList4.Count; i++)
{
inputLabGroup.labGroupAssignmentID = int.Parse(elemList5[i].InnerText);
}
return true;
}
catch (Exception e)
{
return false;
}
} // Reads XML and extracts Lab Group info into a data structure passed by reference
public async Task <ActionResult <BudgetRequest> > Create([FromHeader] string authToken, BudgetRequestCreate budgetRequest)
{
if (!await _authenticationService.CheckAccess(authToken, "announceView"))
{
return(Unauthorized());
}
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
BudgetRequest created = await _budgetRequestService.Create(budgetRequest, group.Id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document created.",
"budgetRequests",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(budgetRequest));
}
public async Task <IActionResult> Update([FromHeader] string authToken, string id, string type, OrderUpdate orderIn)
{
if (!await _authenticationService.CheckAccess(authToken, "orderMgr"))
{
return(Unauthorized());
}
Order order = await _orderService.Get(id);
if (order == null)
{
return(NotFound("Order Not Found!"));
}
if (type == "onOrder")
{
LabGroup group = await _labGroupService.Get(orderIn.GroupId);
if (!_hostEnvironment.EnvironmentName.Equals("Development", StringComparison.OrdinalIgnoreCase))
{
foreach (string userId in group.Members)
{
User temp = await _userService.Get(userId);
string details = "x" + orderIn.Quantity + " " + orderIn.PartNumber + " from " + orderIn.Url;
EmailHelpers.SendOrderPlacedEmail(temp.TechMail, details);
}
}
orderIn.ShippedUtc = DateTime.UtcNow;
}
else if (type == "completed")
{
LabGroup group = await _labGroupService.Get(orderIn.GroupId);
if (!_hostEnvironment.EnvironmentName.Equals("Development", StringComparison.OrdinalIgnoreCase))
{
foreach (string userId in group.Members)
{
User temp = await _userService.Get(userId);
string details = "x" + orderIn.Quantity + " " + orderIn.PartNumber + " from " + orderIn.Url;
EmailHelpers.SendOrderPlacedEmail(temp.TechMail, details);
}
}
orderIn.ReceivedUtc = DateTime.UtcNow;
}
else if (type == "rejected")
{
LabGroup group = await _labGroupService.Get(orderIn.GroupId);
group.BudgetBalance = group.BudgetBalance + (orderIn.UnitCost * orderIn.Quantity);
group.Transactions.Add(new Transaction(
null,
"Add",
"Order Rejected",
(orderIn.UnitCost * orderIn.Quantity),
DateTime.UtcNow
));
_labGroupService.Update(group, group.Id);
if (!_hostEnvironment.EnvironmentName.Equals("Development", StringComparison.OrdinalIgnoreCase))
{
foreach (string userId in group.Members)
{
User temp = await _userService.Get(userId);
EmailHelpers.SendOrderRejectedEmail(temp.TechMail);
}
}
}
_orderService.Update(order, orderIn);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Order Updated",
"orders",
id,
JsonSerializer.Serialize(Order.FromUpdate(order, orderIn))
));
return(Ok());
}
public ActionResult Save(Section section)
{
if (section.Id == 0)
{
_context.Sections.Add(section);
if (section.StudentCount > GlobalConfig.LAB_SPLIT_SIZE)
{
var studentCountG1 = 0;
var studentCountG2 = 0;
if (section.StudentCount % 2 == 0)
{
studentCountG1 = section.StudentCount / 2;
studentCountG2 = section.StudentCount / 2;
}
else
{
studentCountG1 = section.StudentCount / 2;
studentCountG2 = studentCountG1 + 1;
}
var g1 = new LabGroup
{
Name = "G-1",
Section = section,
StudentCount = (byte)studentCountG1
};
var g2 = new LabGroup
{
Name = "G-2",
Section = section,
StudentCount = (byte)studentCountG2
};
_context.LabGroups.Add(g1);
_context.LabGroups.Add(g2);
}
else
{
var g1 = new LabGroup
{
Name = "G-1",
Section = section,
StudentCount = (byte)section.StudentCount
};
_context.LabGroups.Add(g1);
}
}
else
{
var sectionInDb = _context.Sections.Single(s => s.Id == section.Id);
sectionInDb.DepartmentId = section.DepartmentId;
sectionInDb.EntranceYear = section.EntranceYear;
sectionInDb.Name = section.Name;
sectionInDb.StudentCount = section.StudentCount;
}
_context.SaveChanges();
return(RedirectToAction("Index", "Sections"));
}
public async Task <List <Dictionary <string, object> > > GetOrderHistory(string view, LabGroup group, SupplierService _suppliersService)
{
List <Log> logs = await _logs.Find(log => log.Collection == view && log.Document.Contains(group.Id)).Sort("{timestampUtc: -1}").ToListAsync();
List <Dictionary <string, object> > convertedLogs = new List <Dictionary <string, object> >();
int i = 1;
if (logs[0].Document != null)
{
Dictionary <string, object> firstDocument = new Dictionary <string, object>();
firstDocument = JsonConvert.DeserializeObject <Dictionary <string, object> >(logs[0].Document);
if (!(firstDocument["SupplierId"] == null))
{
Supplier s = await _suppliersService.Get(firstDocument["SupplierId"].ToString());
if (!(s == null))
{
firstDocument["SupplierName"] = s.Name;
}
}
firstDocument["GroupNumber"] = group.GroupNumber;
firstDocument["key"] = i;
convertedLogs.Add(firstDocument);
}
foreach (Log log in logs)
{
bool repeat = false;
foreach (Dictionary <string, object> conv in convertedLogs)
{
if (log.DocumentId == conv["Id"].ToString())
{
repeat = true;
}
}
if (!repeat && log.Document != null)
{
Dictionary <string, object> convertedDocument = new Dictionary <string, object>();
convertedDocument = JsonConvert.DeserializeObject <Dictionary <string, object> >(log.Document);
if (!(convertedDocument["SupplierId"] == null))
{
Supplier s = await _suppliersService.Get(convertedDocument["SupplierId"].ToString());
if (!(s == null))
{
convertedDocument["SupplierName"] = s.Name;
}
}
convertedDocument["GroupNumber"] = group.GroupNumber;
convertedDocument["key"] = i;
convertedLogs.Add(convertedDocument);
}
i++;
}
return(convertedLogs);
}
public async Task <IActionResult> Update([FromHeader] string authToken, string id, string memberId, bool addRemove)
{
if (!await _authenticationService.CheckAccess(authToken, "groupMgr"))
{
return(Unauthorized());
}
User add = await _userService.GetByTechId(memberId);
if (add == null)
{
return(NotFound());
}
LabGroup group = await _labGroupService.Get(id);
if (group == null)
{
return(NotFound());
}
if (addRemove)
{
if (group.Members == null)
{
group.Members = new List <string>();
group.Members.Add(add.Id);
}
else
{
group.Members.Add(add.Id);
}
add.Permissions.Add("61db5dde3fb8d66a6bbdde3b");
add.Permissions.Add("61db59a03fb8d66a6bbdde34");
add.Permissions.Add("61db5a813fb8d66a6bbdde36");
await _tokenService.InvalidateUserTokens(add.Id);
}
else
{
if (group.Members == null)
{
return(NotFound());
}
else
{
group.Members.Remove(add.Id);
add.Permissions.Remove("61db5dde3fb8d66a6bbdde3b");
add.Permissions.Remove("61db59a03fb8d66a6bbdde34");
add.Permissions.Remove("61db5a813fb8d66a6bbdde36");
await _tokenService.InvalidateUserTokens(add.Id);
}
}
_labGroupService.Update(group, id);
_userService.Update(add.Id, add);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document modified.",
"labGroups",
id,
JsonSerializer.Serialize(group)
));
return(Ok());
}
public async void Update(LabGroup original, LabGroupUpdate update) => await _labGroups.ReplaceOneAsync(labGroup => labGroup.Id == original.Id, LabGroup.FromUpdate(original, update));
public async void Update(LabGroup update, string id) => await _labGroups.ReplaceOneAsync(labGroup => labGroup.Id == id, update);
public async Task <IActionResult> Update([FromHeader] string authToken, string id, BudgetRequestUpdate budgetRequestUpdate)
{
if (!await _authenticationService.CheckAccess(authToken, "budgetMgr"))
{
return(Unauthorized());
}
var budgetRequest = await _budgetRequestService.Get(id);
if (budgetRequest == null)
{
return(NotFound());
}
_budgetRequestService.Update(budgetRequest, budgetRequestUpdate);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document modified.",
"budgetRequests",
id,
JsonSerializer.Serialize(BudgetRequest.FromUpdate(budgetRequest, budgetRequestUpdate))
));
if (budgetRequestUpdate.StockroomApprovedFlag)
{
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
group.Budget = group.Budget + budgetRequestUpdate.IncreaseAmount;
group.BudgetBalance = group.BudgetBalance + budgetRequestUpdate.IncreaseAmount;
group.Transactions.Add(new Transaction(
null,
"Add",
"Budget Increase",
budgetRequestUpdate.IncreaseAmount,
DateTime.UtcNow
));
_labGroupService.Update(group, group.Id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document modified.",
"budgetRequests",
id,
JsonSerializer.Serialize(group)
));
if (!_hostEnvironment.EnvironmentName.Equals("Development", StringComparison.OrdinalIgnoreCase))
{
foreach (string userId in group.Members)
{
User temp = await _userService.Get(userId);
EmailHelpers.SendBudgetRequestApprovedEmail(temp.TechMail);
}
}
}
return(Ok());
}
public async Task <IActionResult> Update([FromHeader] string authToken, string id, bool inOut, [FromQuery] string techId)
{
if (!await _authenticationService.CheckAccess(authToken, "benchMgr"))
{
return(Unauthorized());
}
LabBench bench = await _labBenchService.Get(id);
if (bench == null)
{
return(NotFound());
}
if (inOut)
{
User user = await _userService.GetByTechId(techId);
if (user == null)
{
return(NotFound());
}
LabGroup group = await _labGroupService.GetByMemberId(user.Id);
if (group == null)
{
return(NotFound());
}
_labBenchService.CheckInOut(bench, group.Id, "Taken");
_labGroupService.UpdateBench(group, id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document modified.",
"labBenches",
id,
JsonSerializer.Serialize(LabBench.FromCheckInOut(bench, group.Id, "Taken"))
));
}
else
{
LabGroup group = await _labGroupService.GetByBenchId(bench.Id);
if (group == null)
{
return(NotFound());
}
_labGroupService.UpdateBench(group, null);
_labBenchService.CheckInOut(bench, null, "Available");
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document modified.",
"labBenches",
id,
JsonSerializer.Serialize(LabBench.FromCheckInOut(bench, null, "Available"))
));
}
return(Ok());
}
public async void CheckOut(LabGroup original, string checkOut) => await _labGroups.ReplaceOneAsync(labGroup => labGroup.Id == original.Id, LabGroup.FromCheckOut(original, checkOut));
public async void UpdateBench(LabGroup original, string benchId) => await _labGroups.ReplaceOneAsync(labGroup => labGroup.Id == original.Id, LabGroup.FromAddRemoveBench(original, benchId));
public async void Update(LabGroup original, double increaseAmount) => await _labGroups.ReplaceOneAsync(labGroup => labGroup.Id == original.Id, LabGroup.FromUpdateBudget(original, increaseAmount));
} // Allows user to select path to XML to upload
private void uploadBtn_Click(object sender, EventArgs e)
{
XMLReader XMLManager = new XMLReader();
MarkScheme markSchemeInfo = new MarkScheme();
LabGroup labGroupInfo = new LabGroup();
List<MarkSchemeSection> markSchemeSectionsInfo = new List<MarkSchemeSection>();
List<MarkSchemePart> markSchemePartsInfo = new List<MarkSchemePart>();
if (XMLManager.GetMarkSchemeInfo(pathToXML, ref markSchemeInfo))
{
if (XMLManager.GetLabGroupInfo(pathToXML, ref labGroupInfo))
{
assignmentID = markSchemeInfo.markSchemeAssignmentID;
if (XMLManager.GetMarkSchemeSectionsInfo(pathToXML, assignmentID, ref markSchemeSectionsInfo))
{
if (XMLManager.GetMarkSchemePartsInfo(pathToXML, assignmentID, ref markSchemePartsInfo))
{
}
else
{
MessageBox.Show("Error in reading parts from XML, check file and retry");
}
}
else
{
MessageBox.Show("Error in sections parts from XML, check file and retry");
}
}
else
{
MessageBox.Show("Error in reading lab group information from XML, check file and retry");
}
}
else
{
MessageBox.Show("Error in reading mark scheme information from XML, check file and retry");
}
if (databaseConnection.UploadMarkScheme(markSchemeInfo))
{
if (databaseConnection.UploadLabGroup(labGroupInfo))
{
if (databaseConnection.UploadMarkSchemeSections(markSchemeSectionsInfo))
{
if (databaseConnection.UploadMarkSchemePart(markSchemePartsInfo))
{
}
else
{
MessageBox.Show("Error in part upload, retry");
}
}
else
{
MessageBox.Show("Error in section upload, retry");
}
}
else
{
MessageBox.Show("Error in lab group upload, retry");
}
}
else
{
MessageBox.Show("Error in mark scheme upload, retry");
}
MessageBox.Show("Upload complete");
}
public async Task <BudgetRequest> Get(LabGroup group) =>
await _budgetRequests.Find <BudgetRequest>(budgetRequest => budgetRequest.LabGroupId == group.Id).Sort("{submittedUtc: -1}").FirstOrDefaultAsync();
