public RequestService(RequestsRepository repo, BarRepository barRepo, UserBarRepository userBarRepo, UserManager <ApplicationUser> userManager)
{
_userManager = userManager;
_repo = repo;
_barRepo = barRepo;
_userBarRepo = userBarRepo;
}
void TestRequestsRepository()
{
var newrequest = new Requests()
{
Description = "ZZZ", Justification = "ZZZ", RejectionReason = null,
DeliveryMode = "Pickup", UserId = UsersRepository.GetByPk(2).Id
};
if (!RequestsRepository.Insert(newrequest))
{
throw new Exception("Request insert failed!");
}
DisplayAllRequests();
newrequest.Description = "YYY";
if (!RequestsRepository.Update(newrequest))
{
throw new Exception("Request update failed!");
}
DisplayAllRequests();
if (!RequestsRepository.Delete(newrequest))
{
throw new Exception("Request delete failed!");
}
DisplayAllRequests();
}
public ActionResult BatchUpdateForReqItems(MVCxGridViewBatchUpdateValues <ItemRequest, int> updatedItems, string status)
{
RequestDetailModel model;
Session["Status"] = ViewData["Status"] = status; // To show batchEdit commands
var reqId = Session["ReqId"] != null?int.Parse(Convert.ToString(Session["ReqId"])) : 0;
if (ModelState.IsValid)
{
try
{
RequestsRepository.RecommendItems(updatedItems);
model = GetRequestModel(reqId);
return(PartialView("Grid/_ReqItemGrid", model.Items));
}
catch (Exception e)
{
TempData["ErrorMessage"] = e.ToString();
BaseRepository.OimsDataContext.ClearChanges(); // Roll back all changes
Logger.LogError(e, "Error while recommending items for request from Supervisor zone");
}
}
else
{
TempData["ErrorMessage"] = "Please, correct all errors.";
}
model = GetRequestModel(reqId);
return(PartialView("Grid/_ReqItemGrid", model.Items));
}
public override Request InsertRequest(RequestModel <RequestDelegatePermissionsUserModel> requestModel)
{
var delegationRequestUsersExtInfo = new List <DelegationRequestUsersExtInfo>();
var request = ConvertToRequest(requestModel, (rua, user) =>
{
delegationRequestUsersExtInfo.Add(GetDelegationRequestUsersExtInfo(rua, user));
});
request.User = RequestSecurityService.GetUserInfo();
var idRequestStateType =
RequestSecurityService.CanSetRequestStateGlobal(request, 1) ? 1 : 2;
request.RequestStates = new List <RequestState>
{
new RequestState
{
IdRequestStateType = idRequestStateType,
Request = request,
Date = DateTime.Now
}
};
var insertedRequest = RequestsRepository.InsertRequest(request);
RequestsRepository.InsertDelegationRequestUsersExtInfo(delegationRequestUsersExtInfo);
return(insertedRequest);
}
public MoveTaskTransactionHandler(ProjectMembersRepository projectMembersRepository, ProjectsRepository projectsRepository,
UsersRepository usersRepository, RequestsRepository requestsRepository, TransactionsRepository transactionsRepository)
: base(requestsRepository, transactionsRepository)
{
_projectMembersRepository = projectMembersRepository;
_projectsRepository = projectsRepository;
_usersRepository = usersRepository;
}
public ListsManager(RequestsRepository requestsRepository,
ListsRepository listsRepository, ProjectsRepository projectsRepository,
RabbitMqTopicManager rabbitMq) : base(requestsRepository)
{
_requestsRepository = requestsRepository;
_listsRepository = listsRepository;
_projectsRepository = projectsRepository;
}
public ProjectMembersManager(RequestsRepository requestsRepository,
ProjectsRepository projectsRepository, UsersRepository usersRepository,
ProjectMembersRepository projectMembersRepository) : base(requestsRepository)
{
_requestsRepository = requestsRepository;
_projectsRepository = projectsRepository;
_usersRepository = usersRepository;
_projectMembersRepository = projectMembersRepository;
}
public ActionResult GridForRequests_CustomHandler(string filter)
{
if (filter.Equals("All"))
{
Session["Filter"] = "All";
return(PartialView("Grid/_GridForRequests", RequestsRepository.GetAllRequests()));
}
Session["Filter"] = null;
return(PartialView("Grid/_GridForRequests", RequestsRepository.Requests));
}
public async Task WhenIsRequestAlreadySentGetsCalled()
{
Setup();
_request = new Fixture().Create <Request>();
RequestsRepository.Setup(repository => repository.GetRequestByUserIdsAndType(It.IsAny <Request>()))
.ReturnsAsync(_request).Callback <Request>(req => _usedRequest = req);
_result = await RequestsService.IsRequestAlreadySent(_request);
}
public async Task WhenGetOutgoingRequestsGetCalled()
{
Setup();
_requests = new Fixture().CreateMany <Request>().ToList();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestsRepository.Setup(repository => repository.GetRequestsBySenderId(_userId))
.ReturnsAsync(_requests);
_result = await RequestsController.GetOutgoingRequests(_userId);
}
public async Task WhenDeclineRequestsGetCalled()
{
Setup();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestsRepository
.Setup(repository => repository
.GetRequestByUserIdsAndType(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <RequestType>()))
.ReturnsAsync((Request)null);
_result = await RequestsController.DeclineRequest(_userId, _senderId, RequestTypeId);
}
public TasksManager(TasksRepository tasksRepository, RequestsRepository requestsRepository,
ListsRepository listsRepository, UsersRepository usersRepository, LabelsRepository labelsRepository,
ProjectMembersRepository projectMembersRepository, IMapper mapper)
: base(requestsRepository)
{
_tasksRepository = tasksRepository;
_requestsRepository = requestsRepository;
_listsRepository = listsRepository;
_usersRepository = usersRepository;
_labelsRepository = labelsRepository;
_projectMembersRepository = projectMembersRepository;
_mapper = mapper;
}
public override Request UpdateRequest(RequestModel <RequestDelegatePermissionsUserModel> requestModel)
{
var delegationRequestUsersExtInfo = new List <DelegationRequestUsersExtInfo>();
var request = ConvertToRequest(requestModel, (rua, user) =>
{
delegationRequestUsersExtInfo.Add(GetDelegationRequestUsersExtInfo(rua, user));
});
var updatedRequest = RequestsRepository.UpdateRequest(request,
!RequestSecurityService.InRole(AclRole.Administrator));
RequestsRepository.UpdateDelegationRequestUsersExtInfo(request.IdRequest, delegationRequestUsersExtInfo);
return(updatedRequest);
}
private RequestModifyPermissionsViewModel LoadAdditionalInfoToViewModel(
RequestModifyPermissionsViewModel viewModel)
{
viewModel.Resources =
RequestSecurityService.FilterResources(ResourceRepository.GetResources())
.OrderBy(r => r.Name)
.ToList();
viewModel.ResourceRights = ResourceRepository.GetResourceRights().OrderBy(r => r.Name).ToList();
viewModel.RequestRightGrantTypes = RequestsRepository.GetRequestRightGrantTypes()
.Where(r => r.IdRequestRightGrantType != 3)
.OrderBy(r => r.Name).ToList();
return(viewModel);
}
public async Task WhenGetIncomingRequestsGetCalled()
{
Setup();
var fixture = new Fixture();
_expectedRequests = fixture.CreateMany <Request>().ToList();
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestsRepository.Setup(repo => repo.GetRequestsByReceiverId(It.IsAny <Guid>())).ReturnsAsync(_expectedRequests);
_result = await RequestsController.GetIncomingRequests(_userId);
}
public async Task WhenGetRequestGetsCalled()
{
Setup();
_expectedRequest = new Request
{
ReceiverId = _receiverId, SenderId = _senderId, RequestType = (RequestType)RequestTypeId
};
AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())).Returns(true);
RequestsRepository.Setup(repository => repository.GetRequestByUserIdsAndType(It.IsAny <Request>()))
.ReturnsAsync((Request)null).Callback <Request>(req => _usedRequest = req);
_result = await RequestsController.GetRequest(_receiverId, _senderId, RequestTypeId);
}
public ActionResult SaveStatus(int statusId, int?requestId, int requestorId)
{
string msg;
if (Application.LoggedManagerId != null)
{
if (requestId != null)
{
var mgrId = (int)Application.LoggedManagerId;
var reqId = (int)requestId;
ViewData["Status"] = statusId;
try
{
RequestsRepository.SaveRequest(requestorId, mgrId, statusId, reqId);
return(Json(new
{
success = true,
message = "Status saved for request Id " + reqId + " successfully!"
}));
}
catch (Exception exc)
{
msg = exc.Message;
BaseRepository.OimsDataContext.ClearChanges(); // Roll back all changes
Logger.LogError(exc, "Error while saving status from Manager zone");
}
}
else
{
msg = Common.ErrorMsgReqNotFound;
}
}
else
{
msg = Common.ErrorMsgForSession;
}
return(Json(new
{
success = false,
message = msg
}));
}
public override RequestModel <RequestDelegatePermissionsUserModel> GetRequestModelBy(Request request)
{
DateTime?completeDate = null;
if (request.IdCurrentRequestStateType == 4)
{
completeDate = request.CurrentRequestStateDate;
}
return(new RequestModel <RequestDelegatePermissionsUserModel>
{
IdRequest = request.IdRequest,
Description = request.Description,
OwnerSnp = request.User.Snp,
OwnerDepartment = request.User.Department.Name,
RequestStateName = request.CurrentRequestStateType.Name,
RequestDate = request.RequestStates.First(r => !r.Deleted).Date,
CompleteDate = completeDate,
IdRequestType = request.IdRequestType,
Users = request.RequestUserAssoc.Where(ru => !ru.Deleted).Select(ru =>
{
var delegationExtInfo =
RequestsRepository.GetDelegationRequestUserExtInfoBy(ru.IdRequestUserAssoc);
if (delegationExtInfo == null)
{
throw new ApplicationException("Отсутствует дополнительная информация о делегировании");
}
var userModel = FillRequestUserModel(ru);
userModel.DelegationRequestUsersExtInfoModel = new DelegationRequestUsersExtInfoModel
{
LoginDelegateTo = delegationExtInfo.DelegateToUser.Login,
PostDelegateTo = delegationExtInfo.DelegateToUser.Post,
SnpDelegateTo = delegationExtInfo.DelegateToUser.Snp,
PhoneDelegateTo = delegationExtInfo.DelegateToUser.Phone,
DepartmentDelegateTo = delegationExtInfo.DelegateToUser.Department,
UnitDelegateTo = delegationExtInfo.DelegateToUser.Unit,
OfficeDelegateTo = delegationExtInfo.DelegateToUser.Office,
DelegateFromDate = delegationExtInfo.DelegateFromDate,
DelegateToDate = delegationExtInfo.DelegateToDate
};
return userModel;
}).ToList()
});
}
public async Task WhenValidateAcceptRequestGetsCalled()
{
Setup();
_expectedErrors = new List <Error>
{
new Error("invalid_request", "There is no pending request."),
new Error("invalid_request", "You are already connected.")
};
_request = new Fixture().Build <Request>().With(request => request.RequestType, RequestType.Friend).Create();
RequestsRepository.Setup(repository => repository.GetRequestByUserIdsAndType(It.IsAny <Request>()))
.ReturnsAsync((Request)null);
RelationshipsService.Setup(service => service.AreAlreadyFriends(It.IsAny <Guid>(), It.IsAny <Guid>()))
.ReturnsAsync(true);
_result = await RequestValidator.ValidateAcceptRequest(_request);
}
/// <summary>
/// Set request details for Manager or Supervisor.
/// </summary>
/// <param name="reqId">Request Id of request</param>
public void SetReqDetails(int reqId)
{
var request = Application.Filter != null?
RequestsRepository.GetAllRequests().FirstOrDefault(u => u.RequestId.Equals(reqId)) :
RequestsRepository.Requests.FirstOrDefault(u => u.RequestId.Equals(reqId));
if (request == null)
{
return;
}
RequestId = request.RequestId;
DbStatusId = request.StatusId;
RequestDate = request.CreatedOn;
RequestStatus = request.Status;
RequestorName = GetUserName(request.RequestorId);
UpdatorName = GetUserName(request.UpdatorId);
UpdateDate = request.UpdatedOn;
Shelters = GetShelters(reqId);
Items = GetItems(reqId);
Statuses = RequestsRepository.GetStatusList();
}
public void ThenRequestRepositoryCreateRequestShouldHaveBeenCalled()
=> RequestsRepository.Verify(repo => repo.CreateRequest(It.Is <Request>(request =>
request.SenderId == _requestRequest.SenderId && request.ReceiverId == _requestRequest.ReceiverId && request.RequestType == (RequestType)_requestRequest.RequestTypeId)));
public void ThenRequestsRepositoryDeleteRequestShouldHaveBeenCalled()
=> RequestsRepository.Verify(
repository => repository.DeleteRequest(_request.SenderId, _request.ReceiverId, RequestType.Friend), Times.Once);
public void ThenRequestsRepositoryGetRequestByUserIdsAndTypeShouldHaveBeenCalled() => RequestsRepository.Verify(repository => repository.GetRequestByUserIdsAndType(It.IsAny <Request>()), Times.Once);
public MoveTaskTransactionHandler(ListsRepository listsRepository, ProjectsRepository projectsRepository,
TransactionsRepository transactionsRepository, RequestsRepository requestsRepository, RabbitMqTopicManager rabbit)
: base(requestsRepository, transactionsRepository)
{
_listsRepository = listsRepository;
_projectsRepository = projectsRepository;
}
public LabelsManager(LabelsRepository labelsRepository, RequestsRepository requestsRepository)
: base(requestsRepository)
{
_labelsRepository = labelsRepository;
_requestsRepository = requestsRepository;
}
public void ThenRequestRepositoryGetRequestsBySenderIdShouldHaveBeenCalled() => RequestsRepository.Verify(repo => repo.GetRequestsByReceiverId(_userId), Times.Once);
public void ThenRequestRepositoryCreateRequestShouldNotHaveBeenCalled() => RequestsRepository.Verify(repo => repo.CreateRequest(It.IsAny <Request>()), Times.Never);
void DisplayAllRequests()
{
Console.WriteLine("\n*** Requests ***");
RequestsRepository.GetAll()
.ForEach(r => { Console.WriteLine(r); });
}
public void ThenRequestsRepositoryGetRequestByUserIdsAndTypeShouldNotHaveBeenCalled()
=> RequestsRepository.Verify(
repository =>
repository.GetRequestByUserIdsAndType(It.IsAny <Guid>(), It.IsAny <Guid>(),
It.IsAny <RequestType>()), Times.Never);
public void ThenRequestsRepositoryGetRequestByUserIdsAndTypeShouldHaveBeenCalled()
=> RequestsRepository.Verify(
repository =>
repository.GetRequestByUserIdsAndType(_userId, _senderId, (RequestType)RequestTypeId), Times.Once);
