public ListItemService(IUnitOfWork unitOfWork, IUserContext userContext, IListItemRepository repository, IPermissionService permissionService)
{
_unitOfWork = unitOfWork;
_userContext = userContext;
_listItemRepository = repository;
_permissionService = permissionService;
}
public ListService(
IListRepository listRepository,
IListItemRepository listItemRepository)
{
_listRepository = listRepository;
_listItemRepository = listItemRepository;
}
public ListItemService(
IUserContext applicationContext,
IListItemRepository listItemRepository,
IQueueDispatcher <IMessage> dispatcher) : base(applicationContext, dispatcher)
{
_listItemRepository = listItemRepository;
}
public static InvoiceService Create(
IUserContext userContext,
IInvoiceRepository invoiceRepository,
IListItemRepository listItemRepository,
ICustomerRepository customerRepository,
IBankDetailsRepository bankDetailsRepository,
ITaxCodeRepository taxCodeRepository,
ICurrencyRepository currencyRepository)
{
var dispatcher = MockRepository.GenerateStub <IQueueDispatcher <IMessage> >();
return(new InvoiceService(
userContext,
new InvoiceItemService(
userContext,
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
MockRepository.GenerateStub <IInvoiceRepository>(),
MockRepository.GenerateStub <IInvoiceItemRepository>(),
MockRepository.GenerateStub <IJobItemRepository>(),
MockRepository.GenerateStub <IQuoteItemRepository>(),
MockRepository.GenerateStub <IListItemRepository>(),
dispatcher),
invoiceRepository,
EntityIdProviderFactory.GetEntityIdProviderFor <Invoice>("IR2000"),
listItemRepository,
customerRepository,
bankDetailsRepository,
taxCodeRepository,
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
currencyRepository,
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >()));
}
public ListTableController(IConstantRepository ConstantParam, IMinistryRepository MinistryParam, IListtableRepository ListTableParam,
IMinistryMemberRepository MinistryMemberParam, IListHeaderRepository ListHeaderParam, IListItemRepository ListItemParam)
{
ConstantRepository = ConstantParam;
MinistryRepository = MinistryParam;
ListTableRepository = ListTableParam;
ListHeaderRepository = ListHeaderParam;
ListItemRepository = ListItemParam;
MinistryMemberRepository = MinistryMemberParam;
ViewBag.Supervisor = false;
int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]);
if (memberID > 0)
{
if (MembershipRepositroy.IsUser(memberID))
{
user user = MembershipRepositroy.GetUserByID(memberID);
if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "Admin2")) //creator access
{
ViewBag.Supervisor = true;
}
if (user.role.Name == "WebMaster") //creator access
{
ViewBag.WebMaster = true;
}
if (user.role.Name == "Officer") //creator access
{
ViewBag.Supervisor2 = true;
}
}
}
}
public ShoppingListService(IUnitOfWork unitOfWork, IUserContext userContext, IShoppingListRepository shoppingListRepository, IPermissionService permissionService, IListItemRepository listItemRepository, IUserService userService)
{
_unitOfWork = unitOfWork;
_shoppingListRepository = shoppingListRepository;
_userContext = userContext;
_permissionService = permissionService;
_listItemRepository = listItemRepository;
_userService = userService;
}
public static CertificateService Create(IUserContext userContext, IListItemRepository listItemRepository, ICertificateRepository certificateRepository, IJobItemRepository jobItemRepository)
{
return(new CertificateService(
userContext,
jobItemRepository,
certificateRepository,
listItemRepository,
EntityIdProviderFactory.GetEntityIdProviderFor <Certificate>("CERT2000"),
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >()));
}
public ListItemController(IListItemRepository ListItemRepository)
{
_ListItemRepository = ListItemRepository;
// ToDo SR : Maybe use DI to inject the mapper
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ListItemDto, ListItem>();
cfg.CreateMap <ListItem, ListItemDto>();
});
_Mapper = config.CreateMapper();
}
public CertificateService(
IUserContext applicationContext,
IJobItemRepository jobItemRepository,
ICertificateRepository certificateRepository,
IListItemRepository listItemRepository,
IEntityIdProvider entityIdProvider,
IQueueDispatcher <IMessage> dispatcher) : base(applicationContext, dispatcher)
{
_jobItemRepository = jobItemRepository;
_certificateRepository = certificateRepository;
_listItemRepository = listItemRepository;
_entityIdProvider = entityIdProvider;
}
public static JobItemService CreateForUpdateStatus(
IJobItemRepository jobItemRepository, IListItemRepository listItemRepository, IUserContext userContext)
{
var dispatcher = MockRepository.GenerateStub <IQueueDispatcher <IMessage> >();
return(new JobItemService(
userContext,
MockRepository.GenerateStub <IJobRepository>(),
jobItemRepository,
new ListItemService(userContext, listItemRepository, dispatcher),
new InstrumentService(userContext, MockRepository.GenerateStub <IInstrumentRepository>(), dispatcher),
dispatcher));
}
public ConsignmentItemService(
IUserContext applicationContext,
IConsignmentRepository consignmentRepository,
IConsignmentItemRepository consignmentItemRepository,
IJobItemRepository jobItemRepository,
IListItemRepository listItemRepository,
ISupplierRepository supplierRepository,
IQueueDispatcher <IMessage> dispatcher) : base(applicationContext, dispatcher)
{
_consignmentRepository = consignmentRepository;
_consignmentItemRepository = consignmentItemRepository;
_jobItemRepository = jobItemRepository;
_listItemRepository = listItemRepository;
_supplierRepository = supplierRepository;
}
public JobService(
IUserContext applicationContext,
IJobAttachmentDataRepository jobAttachmentDataRepository,
IJobRepository jobRepository,
IListItemRepository listItemRepository,
ICustomerRepository customerRepository,
IEntityIdProvider entityIdProvider,
IQueueDispatcher <IMessage> dispatcher) : base(applicationContext, dispatcher)
{
_jobAttachmentDataRepository = jobAttachmentDataRepository;
_jobRepository = jobRepository;
_listItemRepository = listItemRepository;
_customerRepository = customerRepository;
_entityIdProvider = entityIdProvider;
}
public OrderItemService(
IUserContext applicationContext,
IOrderRepository orderRepository,
IOrderItemRepository orderItemRepository,
ISupplierRepository supplierRepository,
IJobItemRepository jobItemRepository,
IListItemRepository listItemRepository,
IQueueDispatcher <IMessage> dispatcher) : base(applicationContext, dispatcher)
{
_orderRepository = orderRepository;
_orderItemRepository = orderItemRepository;
_supplierRepository = supplierRepository;
_jobItemRepository = jobItemRepository;
_listItemRepository = listItemRepository;
}
public CompanyDetailsService(
IUserContext applicationContext,
ICompanyDetailsRepository companyDetailsRepository,
IBankDetailsRepository bankDetailsRepository,
ICurrencyRepository currencyRepository,
IListItemRepository listItemRepository,
ITaxCodeRepository taxCodeRepository,
IQueueDispatcher <IMessage> dispatcher) : base(applicationContext, dispatcher)
{
_companyDetailsRepository = companyDetailsRepository;
_bankDetailsRepository = bankDetailsRepository;
_currencyRepository = currencyRepository;
_listItemRepository = listItemRepository;
_taxCodeRepository = taxCodeRepository;
}
public QuoteItemService(
IUserContext applicationContext,
IQuoteRepository quoteRepository,
IQuoteItemRepository quoteItemRepository,
IJobItemRepository jobItemRepository,
IListItemRepository listItemRepository,
ICustomerRepository customerRepository,
IQueueDispatcher <IMessage> dispatcher) : base(applicationContext, dispatcher)
{
_quoteRepository = quoteRepository;
_quoteItemRepository = quoteItemRepository;
_customerRepository = customerRepository;
_jobItemRepository = jobItemRepository;
_listItemRepository = listItemRepository;
}
public MemoryContext(IContextConfiguration configuration) : base(configuration)
{
_storeSet = new Dictionary <Type, object>();
_storeSet.Add(typeof(UserModel), new List <UserModel>());
_storeSet.Add(typeof(ListModel), new List <ListModel>());
_storeSet.Add(typeof(ListItemModel), new List <ListItemModel>());
_userRepository = new UserRepository(this);
_listRepository = new ListRepository(this);
_listItemRepository = new ListItemRepository(this);
_nextIds = new Dictionary <Type, int>();
_nextIds.Add(typeof(UserModel), 1);
_nextIds.Add(typeof(ListModel), 1);
_nextIds.Add(typeof(ListItemModel), 1);
}
public InvoiceItemService(
IUserContext userContext,
ICompanyDetailsRepository companyDetailsRepository,
IInvoiceRepository invoiceRepository,
IInvoiceItemRepository invoiceItemRepository,
IJobItemRepository jobItemRepository,
IQuoteItemRepository quoteItemRepository,
IListItemRepository listItemRepository,
IQueueDispatcher <IMessage> dispatcher) : base(userContext, dispatcher)
{
_companyDetailsRepository = companyDetailsRepository;
_invoiceRepository = invoiceRepository;
_invoiceItemRepository = invoiceItemRepository;
_jobItemRepository = jobItemRepository;
_listItemRepository = listItemRepository;
_quoteItemRepository = quoteItemRepository;
}
public static InvoiceItemService Create(
IUserContext userContext,
ICompanyDetailsRepository companyDetailsRepository,
IInvoiceRepository invoiceRepository,
IInvoiceItemRepository invoiceItemRepository,
IJobItemRepository jobItemRepository,
IQuoteItemRepository quoteItemRepository,
IListItemRepository listItemRepository)
{
return(new InvoiceItemService(
userContext,
companyDetailsRepository,
invoiceRepository,
invoiceItemRepository,
jobItemRepository,
quoteItemRepository,
listItemRepository,
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >()));
}
public static DeliveryItemService Create(
IUserContext userContext,
IDeliveryRepository deliveryRepository,
IDeliveryItemRepository deliveryItemRepository,
IJobItemRepository jobItemRepository,
IQuoteItemRepository quoteItemRepository,
IListItemRepository listItemRepository,
ICustomerRepository customerRepository)
{
return(new DeliveryItemService(
userContext,
deliveryRepository,
deliveryItemRepository,
jobItemRepository,
quoteItemRepository,
listItemRepository,
customerRepository,
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >()));
}
public ListItemValidator(IListItemRepository ListItemRepository)
{
_ListItemRepository = ListItemRepository;
RuleFor(x => x.Id).GreaterThanOrEqualTo(0).WithMessage("Id is mandatory");
RuleFor(x => x.Name).MaximumLength(100).WithMessage("Name can not be 'henk'")
.Must((o, list, context) =>
{
if (null != o.Name)
{
context.MessageFormatter.AppendArgument("Name", o.Name);
return(IsValidType(o.Name));
}
return(true);
});
RuleFor(x => x.CreatedAt).NotEmpty();
RuleFor(x => x.UpdatedAt).NotEmpty();
RuleFor(x => x.Status).Matches(@"^[a-zA-Z0-9]*$");
// ToDo SR very stupid test, but it does something
RuleFor(x => x.Name).MustAsync(IsNameAvailable).When(x => x.Id == 0 && x.Name != null);
}
public InvoiceService(
IUserContext userContext,
InvoiceItemService invoiceItemService,
IInvoiceRepository invoiceRepository,
IEntityIdProvider entityIdProvider,
IListItemRepository listItemRepository,
ICustomerRepository customerRepository,
IBankDetailsRepository bankDetailsRepository,
ITaxCodeRepository taxCodeRepository,
ICompanyDetailsRepository companyDetailsRepository,
ICurrencyRepository currencyRepository,
IQueueDispatcher <IMessage> dispatcher) : base(userContext, dispatcher)
{
_invoiceItemService = invoiceItemService;
_invoiceRepository = invoiceRepository;
_entityIdProvider = entityIdProvider;
_listItemRepository = listItemRepository;
_customerRepository = customerRepository;
_bankDetailsRepository = bankDetailsRepository;
_taxCodeRepository = taxCodeRepository;
_companyDetailsRepository = companyDetailsRepository;
_currencyRepository = currencyRepository;
}
public static JobItemService CreateForUpdateStatus(IJobItemRepository jobItemRepository, IListItemRepository listItemRepository)
{
return(CreateForUpdateStatus(jobItemRepository, listItemRepository,
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Member)));
}
private async Task <ListItem> ProcessMove(MoveToListItemParams state, ListItem listItem, ListItem afterListItem, OwnedList targetList, IListItemRepository listItemRepository, IListRepository listRepository)
{
ListItem result = null;
ListItem processedListItem;
var positions = new List <Guid>();
var processedList = targetList;
Guid listId;
if (state.Copy)
{
processedListItem = listItemRepository.CreateNew(listItem.Content, state.User.PortalUserID);
if (targetList != null)
{
processedListItem.ListID = targetList.ListID;
}
else
{
processedListItem.ListID = afterListItem.ListItemID;
processedList = await listRepository.GetOwnedList(processedListItem.ListID);
}
await listItemRepository.SaveNew(processedListItem);
result = processedListItem;
foreach (var item in processedList.ListItem.OrderBy(i => i.OrderPosition))
{
positions.Add(item.ListItemID);
}
listId = processedList.ListID;
ReorderPositions(afterListItem, positions, processedListItem.ListItemID);
}
else
{
processedList = targetList;
if (targetList != null && targetList.ListID != listItem.ListID)
{
await listItemRepository.Delete(listItem.ListItemID);
await listItemRepository.ReorderItems(listItem.ListID);
}
if (processedList == null)
{
processedList = await listRepository.GetOwnedList(afterListItem.ListID);
}
listId = processedList.ListID;
if (processedList.ListID != listItem.ListID)
{
listItem.ListID = processedList.ListID;
result = listItem;
await listItemRepository.SaveNew(listItem);
}
foreach (var item in processedList.ListItem.OrderBy(i => i.OrderPosition))
{
positions.Add(item.ListItemID);
}
if (positions.Contains(listItem.ListItemID))
{
positions.Remove(listItem.ListItemID);
}
ReorderPositions(afterListItem, positions, listItem.ListItemID);
}
await listItemRepository.ReorderItems(listId, positions);
return(result);
}
public ListItemController(IListItemRepository listItemRepository)
{
_listItemRepository = listItemRepository;
}
protected BaseEntityRepository()
{
this.listItemRepository = ServiceLocator.GetInstance().Get <IListItemRepository>();
}
public static OrderItemService GetOrderItemService(
IUserContext userContext, IOrderRepository orderRepository, IOrderItemRepository orderItemRepository, ISupplierRepository supplierRepository, IJobItemRepository jobItemRepository, IListItemRepository listItemRepository)
{
return(new OrderItemService(
userContext,
orderRepository,
orderItemRepository,
supplierRepository,
jobItemRepository,
listItemRepository,
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >()));
}
public ListItemServices(IListItemRepository listItemRepository) : base(listItemRepository)
{
_listItemRepository = listItemRepository;
}
public ListItemsController(IListItemRepository repo)
{
_repo = repo;
}
public ListsController(IUserListRepository listRepo, IListItemRepository listItemRepo)
{
_listRepo = listRepo;
_listItemRepo = listItemRepo;
}
public ListService(IListItemRepository repo)
{
_repo = repo;
}
public ListService(IListItemRepository repo)
{
_repo = repo;
}
