public async Task <IHttpActionResult> ConfirmRequest(EditRequestViewModel model)
{
try
{
string userName = User.Identity.GetUserName();
ApplicationUser u = await GetApplicationUser(userName);
var request = _UnitOfWork.RequestRepository.Find(model.Id);
var inUse =
_UnitOfWork.RequestRepository.All()
.Any(x => x.Status == RequestStatusEnum.Inprogress && x.AgentId == u.Id);
if (inUse)
{
return(BadRequest("This Agent Already in Joined in Another Request"));
}
request.AgentId = u.Id;
request.Status = RequestStatusEnum.Inprogress;
var notify = await SendNotification(request, NotificationType.AgentReceivedRequest.GetHashCode(), userName);
await _UnitOfWork.CommitAsync();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public EditRequestViewModel OpenRequest(int id, IPrincipal user)
{
Request request = this.Context.Requests.Find(id);
var requestExist = request != null;
if (requestExist)
{
var userIsAdmin = user.IsInRole("Admin");
if (!userIsAdmin)
{
Employee employee = this.Context.Employees
.FirstOrDefault(e => e.ApplicationUser.UserName == user.Identity.Name);
var employeeExists = employee != null;
if (employeeExists)
{
var employeeIsOwner =
request.Owner.Id == employee.Id;
if (!employeeIsOwner)
{
return(null);
}
}
}
EditRequestViewModel viewModel =
Mapper.Instance.Map <Request, EditRequestViewModel>(request);
return(viewModel);
}
return(null);
}
public async Task <IActionResult> Create(int eventId)
{
var campaignEvent = await _mediator.SendAsync(new EventSummaryQuery { EventId = eventId });
if (campaignEvent == null)
{
return(BadRequest("Invalid event id"));
}
var authorizableEvent = await _mediator.SendAsync(new AuthorizableEventQuery(campaignEvent.Id));
if (!await authorizableEvent.UserCanManageChildObjects())
{
return(new ForbidResult());
}
var model = new EditRequestViewModel
{
OrganizationId = campaignEvent.OrganizationId,
OrganizationName = campaignEvent.OrganizationName,
CampaignId = campaignEvent.CampaignId,
CampaignName = campaignEvent.CampaignName,
EventId = campaignEvent.Id,
EventName = campaignEvent.Name
};
ViewBag.Title = CreateRequestTitle;
return(View("Edit", model));
}
public async Task EditPost_ReturnsCorrectViewAndViewModel_WhenPhoneNumberValidationFails()
{
const int eventId = 1;
const int orgId = 1;
var model = new EditRequestViewModel {
EventId = eventId, Phone = "111-111-1111"
};
var mediator = new Mock <IMediator>();
mediator.Setup(mock => mock.SendAsync(It.IsAny <EventSummaryQuery>())).ReturnsAsync(new EventSummaryViewModel {
Id = eventId, OrganizationId = orgId
});
mediator.Setup(mock => mock.SendAsync(It.IsAny <ValidatePhoneNumberRequestCommand>())).ReturnsAsync(new ValidatePhoneNumberResult {
IsValid = false
});
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableEventQuery>())).ReturnsAsync(new FakeAuthorizableEvent(false, false, false, true));
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableRequestQuery>())).ReturnsAsync(new FakeAuthorizableRequest(false, true, false, false));
var sut = new RequestController(mediator.Object);
var result = await sut.Edit(model) as ViewResult;
Assert.Equal(result.ViewName, "Edit");
Assert.IsType <EditRequestViewModel>(result.Model);
}
public async Task EditPost_AddsCorrectErrorToModelState_WhenPhoneNumberValidationFails()
{
const int eventId = 1;
const int orgId = 1;
var model = new EditRequestViewModel {
EventId = eventId, Phone = "111-111-1111"
};
var mediator = new Mock <IMediator>();
mediator.Setup(mock => mock.SendAsync(It.IsAny <EventSummaryQuery>())).ReturnsAsync(new EventSummaryViewModel {
Id = eventId, OrganizationId = orgId
});
mediator.Setup(mock => mock.SendAsync(It.IsAny <ValidatePhoneNumberRequestCommand>())).ReturnsAsync(new ValidatePhoneNumberResult {
IsValid = false
});
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableEventQuery>())).ReturnsAsync(new FakeAuthorizableEvent(false, false, false, true));
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableRequestQuery>())).ReturnsAsync(new FakeAuthorizableRequest(false, true, false, false));
var sut = new RequestController(mediator.Object);
var result = await sut.Edit(model) as ViewResult;
Assert.Equal(result.ViewData.ModelState.ErrorCount, 1);
Assert.Equal(result.ViewData.ModelState[nameof(model.Phone)].ValidationState, ModelValidationState.Invalid);
Assert.Equal(result.ViewData.ModelState[nameof(model.Phone)].Errors.Single().ErrorMessage, "Unable to validate phone number");
}
public async Task <IActionResult> EditAsync(EditRequestViewModel model)
{
if (ModelState.IsValid)
{
ServiceRequest serviceRequest = await _oDServiceRequestRepository.GetServiceRequestIdAsync(model.ServiceRequestId);
serviceRequest.ApplicantName = model.FullName;
serviceRequest.ApplicationDate = DateTime.Now;
//make all application pending after editing
serviceRequest.Status = "Pending";
serviceRequest.RejectMessage = null;
serviceRequest.Location = model.Location;
if (model.Image != null)
{
if (model.ExistingImageURL != null)
{
string filePath = Path.Combine(_webHostEnvironment.WebRootPath + model.ExistingImageURL);
System.IO.File.Delete(filePath);
}
serviceRequest.ImageUrl = ProcessUploadedImage(model.Image);
}
await _oDServiceRequestRepository.UpdateRequestAsync(serviceRequest);
return(RedirectToAction("MyRequests", new { applicantId = serviceRequest.ApplicantId }));
}
return(View());
}
public async Task EditPost_SendsEditRequestCommandWithCorrrectModel_WhenModelStateIsValid_AndEventIsNotNull_AndUserIsAuthorized_AndPhoneNumberIsValid()
{
const int eventId = 1;
const int orgId = 1;
var viewModel = new EventSummaryViewModel {
Id = eventId, OrganizationId = orgId
};
var mediator = new Mock <IMediator>();
mediator.Setup(mock => mock.SendAsync(It.IsAny <EventSummaryQuery>())).ReturnsAsync(viewModel);
mediator.Setup(mock => mock.SendAsync(It.IsAny <ValidatePhoneNumberRequestCommand>())).ReturnsAsync(new ValidatePhoneNumberResult {
IsValid = true
});
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableEventQuery>())).ReturnsAsync(new FakeAuthorizableEvent(false, false, false, true));
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableRequestQuery>())).ReturnsAsync(new FakeAuthorizableRequest(false, true, false, false));
var sut = new RequestController(mediator.Object);
var model = new EditRequestViewModel {
EventId = eventId
};
await sut.Edit(model);
mediator.Verify(x => x.SendAsync(It.Is <EditRequestCommand>(y => y.RequestModel == model)), Times.Once);
}
public async Task EditPost_SendsValidatePhoneNumberRequestWithCorrectData_WhenModelStateIsValid_AndEventIsNotNull_AndUserIsOrgAdmin()
{
const int eventId = 1;
const int orgId = 1;
var model = new EditRequestViewModel {
EventId = eventId, Phone = "111-111-1111"
};
var mediator = new Mock <IMediator>();
mediator.Setup(mock => mock.SendAsync(It.IsAny <EventSummaryQuery>())).ReturnsAsync(new EventSummaryViewModel {
Id = eventId, OrganizationId = orgId
});
mediator.Setup(mock => mock.SendAsync(It.IsAny <ValidatePhoneNumberRequestCommand>())).ReturnsAsync(new ValidatePhoneNumberResult {
IsValid = true, PhoneNumberE164 = model.Phone
});
var sut = new RequestController(mediator.Object);
sut.MakeUserAnOrgAdmin(orgId.ToString());
await sut.Edit(model);
mediator.Verify(x => x.SendAsync(It.Is <ValidatePhoneNumberRequestCommand>(y => y.PhoneNumber == model.Phone && y.ValidateType)), Times.Once);
}
public EditRequestView(Request request)
{
InitializeComponent();
EditRequestViewModel editRequestViewModel = new EditRequestViewModel(request);
DataContext = editRequestViewModel;
}
public EditRequest()
{
InitializeComponent();
editRequestViewModel = new EditRequestViewModel();
editRequestViewModel.navigation = Navigation;
this.BindingContext = editRequestViewModel;
}
public async Task <IActionResult> Edit(int id)
{
var request = repository.Requests.FirstOrDefault(r => r.Id == id);
if (request != null)
{
var reviewers = new List <ApplicationUser>();
foreach (var user in userManager.Users)
{
if (await userManager.IsInRoleAsync(user, "Reviewer"))
{
reviewers.Add(user);
}
}
EditRequestViewModel editModel = new EditRequestViewModel();
editModel.Id = request.Id;
editModel.Name = request.Name;
editModel.Description = request.Description;
editModel.RequestStatusId = request.RequestStatusId;
editModel.ReviewerId = request.ReviewerId;
editModel.Statuses = statusRepository.RequestStatuses;
editModel.Reviewers = reviewers;
return(View(editModel));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Edit(EditRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(View("Edit", model));
}
var @event = await _mediator.SendAsync(new EventSummaryQuery { EventId = model.EventId });
if (@event == null)
{
return(BadRequest("Invalid event id"));
}
if (!User.IsOrganizationAdmin(@event.OrganizationId))
{
return(Unauthorized());
}
var validatePhoneNumberResult = await _mediator.SendAsync(new ValidatePhoneNumberRequestCommand { PhoneNumber = model.Phone, ValidateType = true });
if (!validatePhoneNumberResult.IsValid)
{
ModelState.AddModelError(nameof(model.Phone), "Unable to validate phone number");
return(View("Edit", model));
}
await _mediator.SendAsync(new EditRequestCommand { RequestModel = model });
return(RedirectToAction("Requests", "Event", new { id = model.EventId }));
}
public async Task <IActionResult> Create(int eventId)
{
var campaignEvent = await _mediator.SendAsync(new EventSummaryQuery { EventId = eventId });
if (campaignEvent == null)
{
return(BadRequest("Invalid event id"));
}
if (!User.IsOrganizationAdmin(campaignEvent.OrganizationId))
{
return(Unauthorized());
}
var model = new EditRequestViewModel
{
OrganizationId = campaignEvent.OrganizationId,
OrganizationName = campaignEvent.OrganizationName,
CampaignId = campaignEvent.CampaignId,
CampaignName = campaignEvent.CampaignName,
EventId = campaignEvent.Id,
EventName = campaignEvent.Name
};
ViewBag.Title = CreateRequestTitle;
return(View("Edit", model));
}
public ActionResult EditRequestView(Guid requestUID)
{
var model = new EditRequestViewModel()
{
RequestUID = requestUID
};
return(View(model));
}
public IActionResult EditRequest(EditRequestViewModel req, int id, IFormFile reqfile)
{
if (!ModelState.IsValid)
{
return(View(req));
}
_userService.EditRequest(req, reqfile, id);
return(Redirect("/Userpanel/Requests"));
}
public async Task EditPost_SendsEventSummaryQuery_WithCorrectArguments()
{
var viewModel = new EditRequestViewModel {
EventId = 1
};
var mediator = new Mock <IMediator>();
var sut = new RequestController(mediator.Object);
await sut.Edit(viewModel);
mediator.Verify(x => x.SendAsync(It.Is <EventSummaryQuery>(y => y.EventId == viewModel.EventId)));
}
public EditRequestViewModel GetEditRequestViewModel(int requestId)
{
EditRequestViewModel model = new EditRequestViewModel
{
RequestId = requestId,
DepartmentId = _context.Requests.Find(requestId).DepartmentId,
ProfessionViewModelList = GetProfessionViewModelListByRequestId(requestId),
DatabaseHelper = this
};
return(model);
}
public ActionResult Open(int id)
{
var user = HttpContext.User;
EditRequestViewModel viewModel =
this._service.OpenRequest(id, user);
if (viewModel == null)
{
return(this.HttpNotFound());
}
return(View(viewModel));
}
public async Task <IActionResult> EditAsync(int requestId)
{
ServiceRequest serviceRequest = await _oDServiceRequestRepository.GetServiceRequestIdAsync(requestId);
EditRequestViewModel vm = new EditRequestViewModel
{
ServiceRequestId = serviceRequest.ServiceRequestId,
ExistingImageURL = serviceRequest.ImageUrl,
FullName = serviceRequest.ApplicantName,
Status = serviceRequest.Status,
RejectMessage = serviceRequest.RejectMessage,
ApplicantId = serviceRequest.ApplicantId
};
return(View(vm));
}
public async Task <IHttpActionResult> CancelAgentRequest(EditRequestViewModel model)
{
try
{
var request = _UnitOfWork.RequestRepository.Find(model.Id);
request.Status = RequestStatusEnum.New;
request.AgentId = null;
await _UnitOfWork.CommitAsync();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ViewResult Edit(int Id)
{
Request request = requestRepository.GetRequest(Id);
var model = new EditRequestViewModel
{
RequestId = request.RequestId,
ApplicationUserID = request.ApplicationUserID,
StartDate = request.StartDate,
PreviousStartDate = request.StartDate,
EndDate = request.EndDate,
PreviousEndDate = request.EndDate,
SpecialCase = request.SpecialCase
};
return(View(model));
}
public IActionResult DeclineEditRequest(int editRequestId)
{
var editRequest = _materialsService.GetEditRequest(editRequestId);
if (editRequest == null)
{
return(RedirectToAction("ResourceNotFound", "Error", new { error = "sugestia edycji o podanym Id nie istnieje." }));
}
var vm = new EditRequestViewModel
{
EditRequestId = editRequestId,
MaterialName = editRequest.MaterialToUpdate.Name,
};
return(View(vm));
}
public async Task <IActionResult> Edit(EditRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(View("Edit", model));
}
var @event = await _mediator.SendAsync(new EventSummaryQuery { EventId = model.EventId });
if (@event == null)
{
return(BadRequest("Invalid event id"));
}
if (model.Id == Guid.Empty)
{
var authorizableEvent = await _mediator.SendAsync(new AuthorizableEventQuery(model.EventId));
if (!await authorizableEvent.UserCanManageChildObjects())
{
return(new ForbidResult());
}
}
else
{
var authorizableRequest = await _mediator.SendAsync(new AuthorizableRequestQuery(model.Id));
if (!await authorizableRequest.UserCanEdit())
{
return(new ForbidResult());
}
}
var validatePhoneNumberResult = await _mediator.SendAsync(new ValidatePhoneNumberRequestCommand { PhoneNumber = model.Phone, ValidateType = true });
if (!validatePhoneNumberResult.IsValid)
{
ModelState.AddModelError(nameof(model.Phone), "Unable to validate phone number");
return(View("Edit", model));
}
await _mediator.SendAsync(new EditRequestCommand { RequestModel = model });
return(RedirectToAction(nameof(EventController.Requests), "Event", new { id = model.EventId }));
}
public void EditRequest(EditRequestViewModel req, IFormFile reqfile, int reqid)
{
var request = _context.Requests.Find(reqid);
request.GroupID = req.GroupID;
request.RequestText = req.RequestText;
if (reqfile != null)
{
request.RequestFileName = NameGenerator.GenerateUniqCode() + Path.GetExtension(reqfile.FileName);
string reqpath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/RequestFiles", request.RequestFileName);
using (var stream = new FileStream(reqpath, FileMode.Create))
{
reqfile.CopyTo(stream);
}
}
_context.Requests.Update(request);
_context.SaveChanges();
}
public void UpdateRequest(EditRequestViewModel model)
{
List <ProfessionsInRequest> professionsInRequest = _context.ProfessionsInRequest.Where(p => p.RequestId == model.RequestId).ToList();
List <PPIInRequest> ppi = new List <PPIInRequest>();
for (int i = 0; i < professionsInRequest.Count; i++)
{
_context.ProfessionsInRequest.Find(professionsInRequest[i].Id).EmployeesQuantity = model.ProfessionViewModelList[i].EmployeesQuantity;
var professionsInRequestId = professionsInRequest[i].Id;
ppi = _context.PPIInRequest.Where(p => p.ProfessionsInRequestId == professionsInRequestId).ToList();
for (int j = 0; j < ppi.Count; j++)
{
_context.PPIInRequest.Find(ppi[j].Id).QuantityOfPPI = model.ProfessionViewModelList[i].QuantityOfPPI[j].QuantityForOneEmployee;
_context.PPIInRequest.Find(ppi[j].Id).TotalQuantity = model.ProfessionViewModelList[i].QuantityOfPPI[j].TotalQuantity;
}
_context.SaveChanges();
}
}
public async Task <IHttpActionResult> InProgressRequest(EditRequestViewModel model)
{
try
{
string userName = User.Identity.GetUserName();
ApplicationUser u = await GetApplicationUser(userName);
var request = _UnitOfWork.RequestRepository.Find(model.Id);
request.Status = RequestStatusEnum.Inprogress;
await _UnitOfWork.CommitAsync();
return(Ok(request));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult CreateEditSuggestion(int materialId)
{
var identityUserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var materialToEdit = _service.GetMaterial(materialId);
if (materialToEdit == null)
{
return(RedirectToAction("ResourceNotFound", "Error", new { error = "materiał o podanym Id nie istnieje." }));
}
if (identityUserId == materialToEdit.Creator.IdentityUserId)
{
return(RedirectToAction(
"ActionForbidden",
"Error",
new {
error = "nie masz uprawnień do tego działania. Jesteś autorem danego materiału - skorzystaj z opcji edycji"
}));
}
ConfigureEditSuggestionBreadcrumbs(materialToEdit);
var emvm = new EditMaterialViewModel
{
MaterialId = materialId,
Name = materialToEdit.Name,
Description = materialToEdit.Description
};
var vm = new EditRequestViewModel
{
EditMaterialViewModel = emvm,
Files = materialToEdit.Files.Select(f => new FileViewModel
{
FileId = f.FileId,
FileName = f.FileName,
RelativePath = f.RelativePath,
ContentType = f.ContentType
}).ToList()
};
return(View(vm));
}
public async Task <IActionResult> Edit(EditRequestViewModel editViewModel)
{
if (ModelState.IsValid)
{
var model = repository.Requests.FirstOrDefault(r => r.Id == editViewModel.Id);
if (model != null)
{
model.Name = editViewModel.Name;
model.Description = editViewModel.Description;
model.ReviewerId = editViewModel.ReviewerId;
model.RequestStatusId = editViewModel.RequestStatusId;
repository.SaveRequest(model);
}
return(RedirectToAction(nameof(Index)));
}
return(View(editViewModel));
}
public async Task <IHttpActionResult> GetRequestDetails(EditRequestViewModel model)
{
try
{
var request = await _UnitOfWork.RequestRepository.GetRequestDetails(model.Id);
if (request == null)
{
return(BadRequest($"Request's User Is Removed"));
}
return(Ok(request));
}
catch (Exception ex)
{
ErrorSaver.SaveError(ex.Message);
return(BadRequest(ex.Message));
}
}
public IActionResult DeclineEditRequest(EditRequestViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var loggedModerator = _userService.FindByIdentityUserId(User.FindFirstValue(ClaimTypes.NameIdentifier));
try
{
_materialsService.DeclineEditRequest(vm.EditRequestId, vm.DeclineReason);
}
catch (ArgumentException)
{
return(RedirectToAction("ResourceNotFound", "Error", new { error = "sugestia edycji o podanym Id nie istnieje." }));
}
return(RedirectToAction("EditSuggestions"));
}
