public ClockWorkController(IModelConverter<MO, Translation> requestConverter,
IRetrievalService<Translation, string> languageTranslationService, ISMSApi smsApi)
{
_requestConverter = requestConverter;
_languageTranslationService = languageTranslationService;
_smsApi = smsApi;
}
public PhoneBookCRUDService()
{
_PhonesUnitOfWork = new PhonesUnitOfWork();
_PersonConverter = new PersonModelConverter();
_PhoneNumberConverter = new PhoneNumberModelConverter();
_PersonValidator = new PersonNameValidator(_PersonConverter);
}
public void SetUp()
{
Mapper.Initialize(a =>
{
MapperRegistry.Mappers.Add(new DataReaderMapper { YieldReturnEnabled = true });
a.CreateMap<CustomerRequest, Customer>();
a.CreateMap<IDataReader, Customer>();
});
var servicelocator = ServiceLocator.Builder.Create as ServiceLocator;
servicelocator.Register(typeof(IConverter<CustomerRequest, Customer>), new AutoMapperConverter<CustomerRequest, Customer>());
servicelocator.Register(typeof(IConverter<IDataReader, Customer>), new AutoMapperConverter<IDataReader, Customer>());
servicelocator.Register(typeof(IConverter<IDataReader, IList<Customer>>), new AutoMapperConverter<IDataReader, IList<Customer>>());
servicelocator.Register(typeof(IConverter<IDataReader, List<Customer>>), new AutoMapperConverter<IDataReader, List<Customer>>());
servicelocator.Register(typeof(IConverter<IDataReader, IEnumerable<Customer>>), new AutoMapperConverter<IDataReader, IEnumerable<Customer>>());
servicelocator.Register(typeof(IConverter<IDataReader, ICollection<Customer>>), new AutoMapperConverter<IDataReader, ICollection<Customer>>());
_modelConverter = ModelConverter.Builder.UseLocator(servicelocator).Create;
}
public ProcedureModelConverter(IUnitOfWork unitOfWork,
IModelConverter<ProcedureType, ProcedureTypeEditModel> typesModelConverter,
IModelConverter<Domain.ProcedureCategory, ProcedureCategoryViewModel> categoryModelConverter)
{
_unitOfWork = unitOfWork;
_typesModelConverter = typesModelConverter;
_categoryModelConverter = categoryModelConverter;
}
public void SetUp()
{
var serviceLocator = ServiceLocator.Builder.Create as ServiceLocator;
serviceLocator.Register(typeof(IConverter<CustomerRequest, Customer>), new CustomerRequestCustomerConverter());
_modelConverter = ModelConverter.Builder.UseLocator(serviceLocator).Create;
}
public ContentSearchService(IUmbracoWrapper umbracoWrapper,
IExamineSearchProviderWrapper examineSearchProviderWrapper,
IModelConverter modelConverter)
{
_umbracoWrapper = umbracoWrapper;
_examineSearchProviderWrapper = examineSearchProviderWrapper;
_modelConverter = modelConverter;
}
public FeedController(IModelConverter modelConverter,
IUmbracoWrapper umbracoWrapper,
IEventSearchService eventSearchService)
{
_modelConverter = modelConverter;
_umbracoWrapper = umbracoWrapper;
_eventSearchService = eventSearchService;
}
public UmbracoNavigationProvider(
IModelConverter modelConverter, IUmbracoNodeService umbracoNodeService,
IUmbracoWrapper umbracoWrapper, INodeTypeFactory nodeTypeFactory,
int priority)
: this(modelConverter, umbracoNodeService, umbracoWrapper,
nodeTypeFactory, priority, typeof(SettingsNodeType))
{
}
public JsonFileRepository(
JsonFileRepositoryStore <Model> store,
IEnumerable <IRepositoryEvents <Model> > events,
IModelConverter modelConverter
)
: base(store, events, modelConverter)
{
}
/// <summary>
/// Constructor sets dependent components.
/// </summary>
/// <param name="administrationPortalService">Provides generic administration features.</param>
/// <param name="gridService">Used to construct grid view models.</param>
/// <param name="masterPageService">Provides access to master pages.</param>
/// <param name="masterPageConverter">Converts between master page business and view models.</param>
/// <param name="webHelperService">Provides access to low level web components.</param>
public MasterPagePortalService(IAdministrationPortalService administrationPortalService, IGridService gridService, IMasterPageService masterPageService, IModelConverter <MasterPage, MasterPageViewModel> masterPageConverter, IWebHelperService webHelperService)
{
_administrationPortalService = administrationPortalService;
_gridService = gridService;
_masterPageService = masterPageService;
_masterPageConverter = masterPageConverter;
_webHelperService = webHelperService;
}
public MemoryStoreRepository(
Store store,
IEnumerable <IRepositoryEvents <Model> > events,
IModelConverter modelConverter
)
: base(store, events, modelConverter)
{
}
public DbContextRepository(
DbContext context,
IEnumerable <IRepositoryEvents <Model> > events,
IModelConverter modelConverter,
IExpressionConverter expressionConverter
)
: base(context, events, modelConverter, expressionConverter)
{
}
/// <summary>
/// Constructor sets dependent components.
/// </summary>
/// <param name="administrationPortalService">Provides generic administration features.</param>
/// <param name="formHelperService">Form helper service.</param>
/// <param name="gridService">Used to construct grid view models.</param>
/// <param name="webConverter">Converts between web business and web view models.</param>
/// <param name="webService">Provides access to websites.</param>
/// <param name="webHelperService">Access to low level web components.</param>
public WebPortalService(IAdministrationPortalService administrationPortalService, IFormHelperService formHelperService, IGridService gridService, IModelConverter <Web, WebViewModel> webConverter, IWebService webService, IWebHelperService webHelperService)
{
_administrationPortalService = administrationPortalService;
_formHelperService = formHelperService;
_gridService = gridService;
_webConverter = webConverter;
_webService = webService;
_webHelperService = webHelperService;
}
public TradingBotClient(IRestClient restClient, IModelConverter modelConverter)
{
this.Health = HealthManager.Create(restClient, modelConverter);
this.Instance = InstanceManager.Create(restClient, modelConverter);
this.Trading = TradingManager.Create(restClient, modelConverter);
this.Markets = MarketsManager.Create(restClient, modelConverter);
this.Account = AccountManager.Create(restClient, modelConverter);
this.Orders = OrdersManager.Create(restClient, modelConverter);
}
public MappingRepository(Func <TDbContext> dbContextFactory,
IModelConverter <TModel, TPesistance> converter,
Func <TDbContext, DbSet <TPesistance> > getDbSet)
{
DbContext = dbContextFactory();
Converter = converter;
MaterializedObjects = new Dictionary <TModel, TPesistance>();
GetDbSet = getDbSet;
}
public AgentController(IAgentViewRepository agentViewRepository, IMembershipService membershipService, IModelConverter<Agent, AgentEditModel> agentModelConverter,
IMessageCenter mailService, IBlobStore blobStore, IUnitOfWork unitOfWork) : base(membershipService, blobStore)
{
_membershipService = membershipService;
_agentModelConverter = agentModelConverter;
_mailService = mailService;
_unitOfWork = unitOfWork;
_agentViewRepository = agentViewRepository;
}
public PatientController(IPatientViewRepository patientViewRepository, IMembershipService membershipService,
IModelConverter<Patient, PatientEditModel> modelConverter, IMessageCenter mailService,
IAgentViewRepository agentViewRepository) : base(membershipService)
{
_patientViewRepository = patientViewRepository;
_modelConverter = modelConverter;
_mailService = mailService;
_agentViewRepository = agentViewRepository;
_membershipService = membershipService;
}
public MailStorage(DbContextOptions options,
IModelConverter <Item, Maple2.Sql.Model.Item> itemConverter,
IModelConverter <MailInfo, Maple2.Sql.Model.Mail> mailConverter,
ILogger <MarketStorage> logger)
{
this.options = options;
this.itemConverter = itemConverter;
this.mailConverter = mailConverter;
this.logger = logger;
}
public WorkOrderWriteRepository(IPersistenceContext persistenceContext,
IModelConverter modelConverter)
{
Guard.On(persistenceContext, Error.ArgumentNull(nameof(persistenceContext))).AgainstNull();
Guard.On(modelConverter, Error.ArgumentNull(nameof(modelConverter))).AgainstNull();
_modelConverter = modelConverter;
_collection = persistenceContext.Database.GetCollection <WorkOrderClass>(Consts.Collections.WorkOrders);
}
public CardPaymentService(ITransactionService transactionService,
IBankService bankService,
IModelConverter modelConverter,
ILogger <CardPaymentService> logger)
{
_transactionService = transactionService;
_bankService = bankService;
_modelConverter = modelConverter;
_logger = logger;
}
public BooksController(IBookReadRepository bookReadRepository,
IMediator mediatr,
IBookFileStorage bookFileStorage,
IModelConverter modelConverter)
{
this.bookReadRepository = bookReadRepository;
this.mediatr = mediatr;
this.bookFileStorage = bookFileStorage;
this.modelConverter = modelConverter;
}
public BooksController(IBookReadRepository bookReadRepository,
IBookService bookService,
IBookFileStorage bookFileStorage,
IModelConverter modelConverter)
{
this.bookReadRepository = bookReadRepository;
this.bookService = bookService;
this.bookFileStorage = bookFileStorage;
this.modelConverter = modelConverter;
}
public TransactionsController(IBookSagaEventRepository bookSagaEventRepository,
IMediator mediatr,
IBookFileStorage bookFileStorage,
IModelConverter modelConverter)
{
this.bookSagaEventRepository = bookSagaEventRepository;
this.mediatr = mediatr;
this.bookFileStorage = bookFileStorage;
this.modelConverter = modelConverter;
}
public DbContextRepository(
DbContext context,
IEnumerable <IRepositoryEvents <Model> > events,
IModelConverter modelConverter,
IExpressionConverter expressionConverter
)
{
_context = context;
_events = events;
_modelConverter = modelConverter;
_expressionConverter = expressionConverter;
}
public MarketStorage(DbContextOptions options,
IModelConverter <Item, Maple2.Sql.Model.Item> itemConverter,
IModelConverter <BlackMarketListing, Maple2.Sql.Model.BlackMarketListing> blackMarketListingConverter,
IModelConverter <MesoMarketListing, Maple2.Sql.Model.MesoMarketListing> mesoMarketListingConverter,
ILogger <MarketStorage> logger)
{
this.options = options;
this.itemConverter = itemConverter;
this.blackMarketListingConverter = blackMarketListingConverter;
this.mesoMarketListingConverter = mesoMarketListingConverter;
this.logger = logger;
}
public UmbracoNavigationProvider(
IModelConverter modelConverter, IUmbracoNodeService umbracoNodeService,
IUmbracoWrapper umbracoWrapper, INodeTypeFactory nodeTypeFactory,
int priority, Type rootNodeType)
{
_modelConverter = modelConverter;
_umbracoNodeService = umbracoNodeService;
_umbracoWrapper = umbracoWrapper;
_nodeTypeFactory = nodeTypeFactory;
Priority = priority;
_rootNodeType = rootNodeType;
}
public FileConversionOrchestrator(
IFileHandler fileHandlerService,
IModelSerializer <TSourceModel> sourceModelSerializerService,
IModelConverter <TSourceModel, TIntermediateModel> sourceModelConverterService,
IModelConverter <TTargetModel, TIntermediateModel> targetModelConverterService,
IModelSerializer <TTargetModel> targetModelSerializerService)
{
_fileHandlerService = fileHandlerService;
_sourceModelSerializerService = sourceModelSerializerService;
_sourceModelConverterService = sourceModelConverterService;
_targetModelConverterService = targetModelConverterService;
_targetModelSerializerService = targetModelSerializerService;
}
public void CtorShouldFailWhenModelConverterNull()
{
// Arrange
var persistenceConfiguration = new PersistenceConfiguration("mongodb://*****:*****@localhost:10255/admin?ssl=true");
IPersistenceContext persistenceContext = new PersistenceContext(persistenceConfiguration);
IModelConverter modelConverter = null;
// Act
Action ctor = () => { new WorkOrderWriteRepository(persistenceContext, modelConverter); };
// Assert
ctor.Should().Throw <ArgumentNullException>();
}
public SessionsController(ILogger <SessionsController> logger,
IDataEncryptor dataEncryptor,
IDateTimeProvider dateTimeProvider,
IMessageStore messageStore,
IModelConverter modelConverter,
ISessionStore sessionStore)
{
this._logger = logger;
this._dataEncryptor = dataEncryptor;
this._dateTimeProvider = dateTimeProvider;
this._messageStore = messageStore;
this._modelConverter = modelConverter;
this._sessionStore = sessionStore;
}
public ResourcesController(IMembershipService membershipService,
IBlobStore blobStore, IViewRepository<FileEditModelSync> viewRepository,
IViewModelBuilder<FileEditModelSync> modelBuilder, IEntityConverter<DocumentSubcategory, CategoryEditModel> catConverter,
IModelConverter<SharedDocument, FileEditModelSync> fileModelConverter, IViewRepository<UserProcedurePatientDocViewModel> patientDocViewRepository,
IFileService fileService, IUnitOfWork unitOfWork) : base(membershipService, blobStore)
{
_viewRepository = viewRepository;
_modelBuilder = modelBuilder;
_catConverter = catConverter;
_fileModelConverter = fileModelConverter;
_patientDocViewRepository = patientDocViewRepository;
_fileService = fileService;
_unitOfWork = unitOfWork;
}
public PatientDashboardModelConverter(IModelConverter<Patient, PatientEditModel> patientModelConverter,
IModelConverter<UserProcedure, PatientProcedureEditModel> procedureModelConverter,
IModelConverter<Agent, AgentEditModel> agentModelConverter, IUnitOfWork unitOfWork,
IModelConverter<Appointment, AppointmentEditModel> appointmentModelConverter,
IModelConverter<Message, MessageEditModel> messageModelConverter,
IModelConverter<UserProcedureConsentSign, ProcedureConsentViewModel> consentModelConverter)
{
_patientModelConverter = patientModelConverter;
_procedureModelConverter = procedureModelConverter;
_agentModelConverter = agentModelConverter;
_unitOfWork = unitOfWork;
_appointmentModelConverter = appointmentModelConverter;
_messageModelConverter = messageModelConverter;
_consentModelConverter = consentModelConverter;
}
public void SetUp()
{
var directory = AppDomain.CurrentDomain.BaseDirectory;
var finder = AssemblyFinder.Builder.UsePath(directory).Create;
var container = new ServiceContainer();
container.RegisterFrom<ServiceLocatorCompositionRoot>();
var assemblies = finder.GetAssemblies(x => x.FullName.Contains("Jal.Converter.Tests"));
container.RegisterConverter(assemblies);
_modelConverter = container.GetInstance<IModelConverter>();
}
public UploadService(
ICsvProcessor csvProcessor,
IValidationService validationService,
IDbContext db,
IModelConverter converter,
UploadServiceSettings settings,
ILogger <UploadService> logger
)
{
_csvProcessor = csvProcessor ?? throw new ArgumentException(nameof(csvProcessor));
_validationService = validationService ?? throw new ArgumentNullException(nameof(validationService));
_db = db ?? throw new ArgumentException(nameof(db));
_converter = converter ?? throw new ArgumentException(nameof(converter));
_settings = settings ?? throw new ArgumentException(nameof(settings));
_logger = logger;
}
public void SetUp()
{
var directory = AppDomain.CurrentDomain.BaseDirectory;
var finder = AssemblyFinder.Builder.UsePath(directory).Create;
var container = new WindsorContainer();
container.Install(new ServiceLocatorInstaller());
var assemblies = finder.GetAssemblies(x => x.FullName.Contains("Jal.Converter.Tests"));
container.Install(new ConverterInstaller(assemblies));
_modelConverter = container.Resolve<IModelConverter>();
}
public UserStorage(DbContextOptions options,
IModelConverter <Account, Maple2.Sql.Model.Account> accountConverter,
IModelConverter <Character, Maple2.Sql.Model.Character> characterConverter,
IModelConverter <Item, Maple2.Sql.Model.Item> itemConverter,
IModelConverter <ProgressState, Maple2.Sql.Model.CharacterProgress> progressConverter,
IModelConverter <SkillTab, Maple2.Sql.Model.SkillTab> skillTabConverter,
IModelConverter <Quest, Maple2.Sql.Model.Quest> questConverter,
ILogger <UserStorage> logger)
{
this.options = options;
this.accountConverter = accountConverter;
this.characterConverter = characterConverter;
this.itemConverter = itemConverter;
this.progressConverter = progressConverter;
this.skillTabConverter = skillTabConverter;
this.questConverter = questConverter;
this.logger = logger;
}
public PatientProcedureModelConverter(IUnitOfWork unitOfWork, IModelConverter<Procedure, ProcedureEditModel> procedureModelConverter,
IModelConverter<Doctor, DoctorEditModel> doctorModelConverter,
IModelConverter<Agent, AgentEditModel> agentModelConverter,
IModelConverter<SharedDocument, FileEditModel> sharedFileModelConverter,
IModelConverter<UserProcedurePatientDocument, FileEditModel> docFileModelConverter,
IModelConverter<Place, PlaceEditModel> placeModelConverter,
IModelConverter<UserProcedureConsentSign, ProcedureConsentViewModel> procedureConsentConverter,
IModelConverter<ConsentForm, ConsentFormEditModel> consentFormModelConverter)
{
_unitOfWork = unitOfWork;
_procedureModelConverter = procedureModelConverter;
_doctorModelConverter = doctorModelConverter;
_agentModelConverter = agentModelConverter;
_sharedFileModelConverter = sharedFileModelConverter;
_docFileModelConverter = docFileModelConverter;
_placeModelConverter = placeModelConverter;
_procedureConsentConverter = procedureConsentConverter;
_consentFormModelConverter = consentFormModelConverter;
}
/// <summary>
///
/// </summary>
public virtual IPage <TARGET> LoadPage <SOURCE, TARGET, T1>(ServiceImpl service,
IQuery <T1, SOURCE> query,
Pageable pageable,
IModelConverter <SOURCE, TARGET> converter,
Func <IQuery <T1, SOURCE>, int, int, PageQueryCmd <T1, SOURCE> > createPageQueryCmd)
{
int firstResult = (pageable.PageNo <= 0 ? 0 : pageable.PageNo - 1) * pageable.PageSize;
PageQueryCmd <T1, SOURCE> cmd;
if (createPageQueryCmd != null)
{
cmd = createPageQueryCmd(query, firstResult, pageable.PageSize);
}
else
{
cmd = new PageQueryCmd <T1, SOURCE>(query, firstResult, pageable.PageSize);
}
var elements = service.CommandExecutor.Execute(cmd);
long count = query.Count();
return(new PageImpl <TARGET>(converter.From(elements), count));
}
public PhoneBookSearchService()
{
_PhonesUnitOfWork = new PhonesUnitOfWork();
_PersonConverter = new PersonModelConverter();
}
public GridAttribute()
{
_modelConverter = DependencyResolver.Current.GetService <IModelConverter>();
_mediaService = DependencyResolver.Current.GetService <IMediaService>();
}
public GridAttribute(IMediaService mediaService, IModelConverter modelConverter)
{
_mediaService = mediaService;
_modelConverter = modelConverter;
}
public UmbracoContentService(IModelConverter modelConverter)
{
_modelConverter = modelConverter;
}
public StudentController(IUnitOfWork unitOfWork, IModelConverter <Student, StudentDto> modelConverter)
: base(unitOfWork, LogManager.GetCurrentClassLogger())
{
_modelConverter = modelConverter;
}
public VMRepository(IModelConverter <TModel, VM> modelConverter,
DataContext context) : base(context)
{
this.modelConverter = modelConverter;
}
public AppointmentsModelConverter(IUnitOfWork unitOfWork, IModelConverter<Place, PlaceEditModel> placeModelConverter)
{
_unitOfWork = unitOfWork;
_placeModelConverter = placeModelConverter;
}
