public void Tasks_TasksAssignments_Tests()
{
try
{
storageService.File.CopyFile(Utils.CloudStorage_Input_Folder + "/sample-mpp.mpp", Utils.CloudStorage_Output_Folder + "/sample-mpp.mpp");
AssignmentsResponse assignmentsResponse = tasksService.TasksAssignments.ReadProjectAssignmentItems("sample-mpp.mpp", Utils.CloudStorage_Output_Folder);
AssignmentItemResponse assignmentItemResponse = tasksService.TasksAssignments.AddNewAssignment("sample-mpp.mpp", 8, 1, string.Empty, Utils.CloudStorage_Output_Folder);
AssignmentResponse assignmentResponse = tasksService.TasksAssignments.ReadProjectAssignment("sample-mpp.mpp", 7, Utils.CloudStorage_Output_Folder);
tasksService.TasksAssignments.DeletesProjectAssignmentWithAllReferences("sample-mpp.mpp", 7, string.Empty, Utils.CloudStorage_Output_Folder);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public IActionResult Post([FromBody] AssignmentRequest request)
{
try
{
var response = new AssignmentResponse(request.Title);
foreach (var assignment in request.Assignments)
{
var studentResult = new StudentResult(assignment.FirstName, assignment.LastName);
response.StudentResults.Add(studentResult);
if (assignment.Files == null)
{
continue;
}
foreach (var file in assignment.Files)
{
var source = Encoding.UTF8.GetString(Convert.FromBase64String(file.Base64Source));
var tree = CSharpSyntaxTree.ParseText(source);
var root = (CompilationUnitSyntax)tree.GetRoot();
var tokens = root.DescendantTokens();
var tokenMap = new StudentTokenMap(file.FileName);
studentResult.Files.Add(tokenMap);
foreach (var token in tokens)
{
tokenMap.Tokens.Add(new TokenWithPosition(token.RawKind, token.FullSpan.Start, token.FullSpan.End));
}
}
}
return(new ObjectResult(response));
}
catch (Exception)
{
return(new BadRequestObjectResult("Invalid request format"));
}
}
public async Task <IActionResult> AssignPermission([FromBody] AssignmentRequest request)
{
//TODO Implement many-to-many relationship so user could own more than one permission
// TODO
// Implement auto re-login to update claims info in the jwt
// Or invalidate jwt so user must login again
// one of the above solutions can avoid asking user obtain a new token and automatically applying permission on token
var organisationID = HttpContext.GetOrganisationID();
var user = await _unitOfWork.UserRepository.GetWithDetailsAsync(request.UserID, organisationID);
var policy = await _unitOfWork.PolicyRepository.GetByOrganisationAsync(request.PolicyName, organisationID);
if (user == null || policy == null || user.Policy?.Name == policy.Name)
{
return(BadRequest(new ErrorResponse
{
Message = "Permission/User does not exist or already has the permission."
}));
}
var transaction = _unitOfWork.UserRepository.BeginTransaction();
user.Policy = policy;
await _unitOfWork.UserRepository.AddAsync(user);
await _userManager.AddClaimAsync(user, new Claim(policy.Claim, "true"));
transaction.Commit();
AssignmentResponse assignmentResponse = new AssignmentResponse
{
UserID = user.Id,
PolicyName = policy.Name,
Info = "Permission has been granted, please log-in again for the action to take effect."
};
return(Ok(new Response <AssignmentResponse>(assignmentResponse)));
}
private List <AssignmentPianoResponse> Load(string id = "")
{
List <AssignmentPianoResponse> responses = new List <AssignmentPianoResponse>();
var pianoTypes = db.PianoTypes.ToList();
var pianoSizes = db.PianoSize.ToList();
var pianoFinishs = db.PianoFinish.ToList();
var pianoMakes = db.PianoMake.ToList();
var assignments = db.Assignments
.Include(x => x.Leg) // will be loaded next
.Include(x => x.Leg.FromLocation)
.Include(x => x.Leg.ToLocation)
.Include(x => x.Order)
.Include(x => x.Drivers)
.Include(x => x.Vehicle)
.Include(x => x.Route);
if (!string.IsNullOrEmpty(id))
{
assignments = assignments.Where(x => x.Id.ToString() == id);
}
List <AssignmentResponse> assignmentResponses = new List <AssignmentResponse>();
List <Guid> orderIds = new List <Guid>();
foreach (var assignment in assignments.ToList())
{
var order = db.Orders
.Include(x => x.Client)
.Include(x => x.Pianos)
.Include(x => x.PickupAddress)
.Include(x => x.DeliveryAddress)
.Include(x => x.OrderCharges)
.FirstOrDefault(x => x.Id == assignment.OrderId);
if (order == null)
{
throw new Exception("Order not found. Wrong Assignment.");
}
orderIds.Add(order.Id);
var assignmentResponse = new AssignmentResponse()
{
Id = assignment.Id.ToString(),
AssignmentNumber = assignment.AssignmentNumber,
VehicleCode = assignment.Vehicle.Code,
VehicleName = assignment.Vehicle.Code + " " + assignment.Vehicle.Name,
DriverCode = String.Join(",", assignment.Drivers.Select(x => x.Code).ToList()),
DriverName = String.Join(",", assignment.Drivers.Select(x => x.Code + " " + x.Name).ToList()),
OrderId = order.Id.ToString(),
OrderNumber = order.OrderNumber,
OrderedAt = order.CreatedAt.ToString(StringConstants.TimeStampFormatApp),
OrderType = ((OrderTypeEnum)order.OrderType).ToString(),
CallerName = order.CallerFirstName + " " + order.CallerLastName,
CallerPhoneNumber = order.CallerPhoneNumber,
CallerPhoneNumberAlt = order.CallerAlternatePhone,
CallerEmail = order.CallerEmail,
PickupDate = order.PickupDate?.ToString(),
PickupAddress = TinyMapper.Map <AddressVm>(order.PickupAddress).ToStringWithoutBreak,
PickupName = order.PickupAddress.Name,
PickupPhoneNumber = order.PickupAddress.PhoneNumber,
PickupAlternateContact = order.PickupAddress.AlternateContact,
PickupAlternatePhone = order.PickupAddress.AlternatePhone,
PickupNumberStairs = order.PickupAddress.NumberStairs,
PickupNumberTurns = order.PickupAddress.NumberTurns,
PickupInstructions = order.PickUpNotes,
DeliveryDate = order.DeliveryDate?.ToString(),
DeliveryAddress = TinyMapper.Map <AddressVm>(order.DeliveryAddress).ToStringWithoutBreak,
DeliveryName = order.DeliveryAddress.Name,
DeliveryPhoneNumber = order.DeliveryAddress.PhoneNumber,
DeliveryAlternateContact = order.DeliveryAddress.AlternateContact,
DeliveryAlternatePhone = order.DeliveryAddress.AlternatePhone,
DeliveryNumberStairs = order.DeliveryAddress.NumberStairs,
DeliveryNumberTurns = order.DeliveryAddress.NumberTurns,
DeliveryInstructions = order.DeliveryNotes,
CustomerCode = order.ClientId.HasValue ? order.Client.AccountCode : "",
CustomerName = order.ClientId.HasValue ? order.Client.Name : "",
PaymentOption = ((PaymentOptionEnum)order.PaymentOption).ToString(),
PaymentAmount = order.PaymentOption == 0 ? order.CodAmount.ToString() : (order.PaymentOption == 1 ? order.OfficeStaff : order.OnlinePayment),
NumberOfItems = order.Pianos.Count,
Route = assignment.Route.OrderBy(x => x.Order)
.Select(x => new RouteResponse()
{
ConsignmentId = assignment.Id.ToString(),
Lat = x.Lat,
Lng = x.Lng,
Order = x.Order
}).ToArray()
};
assignmentResponse.LegDate = assignment.Leg.LegDate.ToString();
assignmentResponse.LegFromLocation = assignment.Leg.FromLocation.Name;
assignmentResponse.LegToLocation = assignment.Leg.ToLocation.Name;
assignmentResponses.Add(assignmentResponse);
}
// Pianos
var pianoResponses = db.Pianos
.Include(x => x.Order)
.Where(x => orderIds.Contains(x.OrderId.Value)).OrderBy(x => x.CreatedAt)
.ToList()
.Select(x => new PianoResponse()
{
Id = x.Id.ToString(),
OrderId = x.OrderId.ToString(),
Category = System.Enum.GetName(typeof(PianoCategoryTypeEnum), x.PianoCategoryType),
Type = x.PianoTypeId.HasValue ? pianoTypes.FirstOrDefault(y => y.Id == x.PianoTypeId).Type : "",
Size = x.PianoSizeId.HasValue ? pianoSizes.FirstOrDefault(y => y.Id == x.PianoSizeId).Width.ToString() : "",
Make = x.PianoMakeId.HasValue ? pianoMakes.FirstOrDefault(y => y.Id == x.PianoMakeId).Name : "",
Model = x.Model,
Finish = x.PianoFinishId.HasValue ? pianoFinishs.FirstOrDefault(y => y.Id == x.PianoFinishId).Name : "",
SerialNumber = x.SerialNumber,
IsBench = x.IsBench ? 1 : 0,
IsPlayer = x.IsPlayer ? 1 : 0,
IsBoxed = x.IsBoxed ? 1 : 0,
}).ToArray();
responses.Add(new AssignmentPianoResponse()
{
Assignments = assignmentResponses.ToArray(),
Pianos = pianoResponses
});
return(responses);
}
