/// <summary>
///
/// </summary>
/// <param name="itemsRepository"></param>
/// <param name="mappingRepository"></param>
/// <param name="itemsService"></param>
/// <param name="mappingManager"></param>
/// <param name="importManager"></param>
/// <param name="accountsService"></param>
/// <param name="projectsService"></param>
/// <param name="templateService"></param>
/// <param name="cacheManager"></param>
/// <param name="gcAccountSettings"></param>
public UpdateManager(
IItemsRepository itemsRepository,
IMappingRepository mappingRepository,
IItemsService itemsService,
IMappingManager mappingManager,
IImportManager importManager,
IAccountsService accountsService,
IProjectsService projectsService,
ITemplatesService templateService,
ICacheManager cacheManager,
GCAccountSettings gcAccountSettings)
: base(accountsService, projectsService, templateService, cacheManager)
{
ItemsRepository = itemsRepository;
MappingRepository = mappingRepository;
ItemsService = itemsService;
MappingManager = mappingManager;
ImportManager = importManager;
GcAccountSettings = gcAccountSettings;
}
public BrandMappingsController(IMappingRepository <BrandMappingViewModel, BrandMappingFilter, BrandMappingRestriction> mappingRepository,
IReferencesRepository referencesRepository,
ISettingsManager settingsManager,
ILogger logger,
IMappingSyncLogic mappingSyncLogic) : base(mappingRepository, referencesRepository, settingsManager, logger, mappingSyncLogic)
{
}
public ItemPLKindsController(IMappingRepository <ItemPLKindsViewModel, ItemPLKindsFilter, ItemPLKindsRestriction> mappingRepository,
IReferencesRepository referencesRepository,
ISettingsManager settingsManager,
ILogger logger,
IMappingSyncLogic mappingSyncLogic) : base(mappingRepository, referencesRepository, settingsManager, logger, mappingSyncLogic)
{
}
public EntityMappingsController(IRepository <EntityMapping> repository, IRepository <MappingOrigin> originRepo, IRepository <Entity> entityRepo, IMappingRepository mappingRepository)
{
_repository = repository;
_originRepo = originRepo;
_entityRepo = entityRepo;
_mappingRepository = mappingRepository;
}
public CountriesController(IMemoryPhotoService memoryPhotoService, WorldExplorerContext worldExplorerContext, IRepository <Country> countryRepo, IMappingRepository <CountryDto> repository, IMapper mapper) : base(repository)
{
_memoryPhotoService = memoryPhotoService;
_worldExplorerContext = worldExplorerContext;
_countryMapperRepo = repository;
_mapper = mapper;
_countryRepo = countryRepo;
}
public static IEnumerable <TTarget> MapAll <TSource, TTarget>(this IEnumerable <TSource> source,
IMappingRepository repo)
{
Guard.CheckArgumentNotNull(repo, "repo");
IExtensibleMapper <TSource, TTarget> mapper = repo.ResolveMapper <TSource, TTarget>();
return(MapAll(source, mapper));
}
public static TTarget MapTo <TTarget>(this object source, IMappingRepository repo)
{
Guard.CheckArgumentNotNull(source, "source");
Guard.CheckArgumentNotNull(repo, "repo");
var mapper = repo.ResolveMapper(source.GetType(), typeof(TTarget));
return((TTarget)mapper.Map(source));
}
private void ResetRepositories()
{
_transactionRepository = null;
_accountRepository = null;
_analyticsRepository = null;
_expenditureRepository = null;
_reportRepository = null;
_mappingRepository = null;
}
public MapsController(ILangRepository langRepo, IMappingRepository mappingRepo, IUpdateRepository updateRepo,
IUserRepository userRepo, IRestRegexRepository regexRepo)
{
Langs = langRepo;
Mappings = mappingRepo;
Updates = updateRepo;
Users = userRepo;
Regexes = regexRepo;
}
/// <summary>An IMappingRepository extension method that initializes the mappings.</summary>
/// <exception cref="ArgumentNullException">
/// The <paramref name="initializers" /> parameter is null.
/// </exception>
/// <param name="mappingRepo"> The mappingRepo to act on.</param>
/// <param name="initializers">The initializers.</param>
public static void InitializeMappings(
this IMappingRepository mappingRepo,
IEnumerable <IMappingInitializer> initializers)
{
Guard.CheckArgumentNotNull(initializers, "initializers");
foreach (IMappingInitializer i in initializers)
{
i.InitializeMappings(mappingRepo);
}
}
/// <summary>An IMappingRepository extension method that initializes the mappings.</summary>
/// <exception cref="ArgumentNullException">
/// The <paramref name="assemblies" /> parameter is null.
/// </exception>
/// <param name="mappingRepo"> The mappingRepo to act on.</param>
/// <param name="assemblies">The initializers.</param>
public static void InitializeMappings(
this IMappingRepository mappingRepo,
IEnumerable <Assembly> assemblies)
{
Guard.CheckArgumentNotNull(assemblies, "assemblies");
IEnumerable <IMappingInitializer> q = from assm in assemblies
from t in assm.GetTypes()
where !t.IsAbstract
where typeof(IMappingInitializer).IsAssignableFrom(t)
select(IMappingInitializer) Activator.CreateInstance(t);
InitializeMappings(mappingRepo, q);
}
public MappingManager(
IMappingRepository mappingRepository,
IAccountsService accountsService,
IProjectsService projectsService,
ITemplatesService templateService,
IItemsService itemService,
ICacheManager cacheManager,
GCAccountSettings accountSettings)
: base(accountsService, projectsService, templateService, cacheManager)
{
AccountSettings = accountSettings;
MappingRepository = mappingRepository;
ItemService = itemService;
TemplateService = templateService;
}
public ImportManager(
IItemsRepository itemsRepository,
IMappingRepository mappingRepository,
IItemsService itemsService,
IAccountsService accountsService,
IProjectsService projectsService,
ITemplatesService templateService,
ICacheManager cacheManager,
GCAccountSettings gcAccountSettings)
: base(accountsService, projectsService, templateService, cacheManager, gcAccountSettings)
{
ItemsRepository = itemsRepository;
MappingRepository = mappingRepository;
ItemsService = itemsService;
}
public UsersController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IMappingRepository <CompanyDto> companyRepository,
IMappingRepository <CustomerDto> customerRepository,
IMappingRepository <DriverDto> driverRepository,
IMappingRepository <AddressDto> addressRepository)
{
_userManager = userManager;
_signInManager = signInManager;
_companyRepository = companyRepository;
_customerRepository = customerRepository;
_driverRepository = driverRepository;
_addressRepository = addressRepository;
}
public MappingManager(
IMappingRepository mappingRepository,
IAccountsService accountsService,
IProjectsService projectsService,
ITemplatesService templateService,
IItemsService itemService,
ICacheManager cacheManager,
ILogger logger,
GCAccountSettings accountSettings)
: base(accountsService, projectsService, templateService, cacheManager, accountSettings)
{
MappingRepository = mappingRepository;
ItemService = itemService;
Log = logger ?? new NullLogger();
TemplateService = templateService;
}
/// <summary>
///
/// </summary>
/// <param name="itemsRepository"></param>
/// <param name="mappingRepository"></param>
/// <param name="itemsService"></param>
/// <param name="accountsService"></param>
/// <param name="projectsService"></param>
/// <param name="templateService"></param>
/// <param name="cacheManager"></param>
/// <param name="logger"></param>
/// <param name="gcAccountSettings"></param>
public UpdateManager(
IItemsRepository itemsRepository,
IMappingRepository mappingRepository,
IItemsService itemsService,
IAccountsService accountsService,
IProjectsService projectsService,
ITemplatesService templateService,
ICacheManager cacheManager,
ILogger logger,
GCAccountSettings gcAccountSettings)
: base(accountsService, projectsService, templateService, cacheManager, gcAccountSettings)
{
ItemsRepository = itemsRepository;
MappingRepository = mappingRepository;
ItemsService = itemsService;
Log = logger ?? new NullLogger();
}
public MigrationSegmentRunner(
IOperationExecutive operationExecutive,
IServiceProvider <TEntity> serviceProvider,
ISafeMetadataProvider <TEntity> safeMetadataProvider,
IParameterProvider parameterProvider,
IMappingRepository <TEntity> mappingRepository,
IProcessor <TEntity> processor,
IEventDispatcher <TEntity> eventDispatcher)
{
this.operationExecutive = operationExecutive;
this.serviceProvider = serviceProvider;
this.safeMetadataProvider = safeMetadataProvider;
this.parameterProvider = parameterProvider;
this.mappingRepository = mappingRepository;
this.processor = processor;
this.eventDispatcher = eventDispatcher;
}
protected virtual IMapper <TSource, TTarget> CreateMapper(Type[] innerMappers)
{
IMappingRepository repo = null;
if (innerMappers != null)
{
var options = new MappingOptions(innerMappers);
repo = new MappingRepository(options);
}
else
{
repo = new MappingRepository();
}
var mapper = repo.ResolveMapper <TSource, TTarget>();
this.AddMappingActions(mapper);
return(mapper);
}
public Processor(
IContext context,
IOperationExecutive operationExecutive,
ISafeMetadataProvider <TEntity> safeMetadataProvider,
IServiceProvider <TEntity> serviceProvider,
IMappingRepository <TEntity> mappingRepository,
IPreprocessor <TEntity> preprocessor,
IDeduplicator <TEntity> deduplicator,
IHashingSerializer <TEntity> hashingSerializer,
IGateway <TEntity> gateway,
IEventHub <TEntity> eventHub)
{
this.context = context;
this.operationExecutive = operationExecutive;
this.safeMetadataProvider = safeMetadataProvider;
this.serviceProvider = serviceProvider;
this.mappingRepository = mappingRepository;
this.preprocessor = preprocessor;
this.deduplicator = deduplicator;
this.hashingSerializer = hashingSerializer;
this.gateway = gateway;
this.eventHub = eventHub;
}
public MappingService(IMappingRepository mappingRepository)
{
this.mappingRepository = mappingRepository;
}
public EntitySessionBuilder(IMappingRepository repository)
{
_repository = repository;
}
public DriversController(IMappingRepository <DriverDto> driverMappingRepository, IMapper mapper, IHubContext <TaxiHub> hub) : base(driverMappingRepository)
{
_hub = hub;
_mapper = mapper;
}
public CustomersController(IMappingRepository <CustomerDto> customerMappingRepository) : base(customerMappingRepository)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MapperConstructionInfo"/> class.
/// </summary>
/// <param name="parentRepo">
/// The parent repo.
/// </param>
public MapperConstructionInfo(IMappingRepository parentRepo)
{
this.ParentRepo = parentRepo;
}
/// <summary>An IMappingRepository extension method that initializes the mappings.</summary>
public static void InitializeMappings(this IMappingRepository mappingRepo)
{
mappingRepo.InitializeMappings(AppDomain.CurrentDomain.GetAssemblies());
}
public MappingService(IMappingRepository mappingRepository)
{
_mappingRepository = mappingRepository;
}
public void InitializeMappings(IMappingRepository mappingRepo)
{
Repos.Add(mappingRepo);
}
/// <summary>
/// Initializes a new instance of the <see cref="MapperConstructionInfo"/> class.
/// </summary>
/// <param name="parentRepo">
/// The parent repo.
/// </param>
public MapperConstructionInfo(IMappingRepository parentRepo)
{
this.ParentRepo = parentRepo;
}
public OrdersController(IMappingRepository <OrderDto> orderMappingRepository, IHubContext <TaxiHub> hub) : base(orderMappingRepository)
{
_hub = hub;
}
public PagesController(IPageRepository pages, IMappingRepository mappings)
{
_pages = pages;
_mappings = mappings;
}
public void InitializeMappings(IMappingRepository mappingRepo)
{
Repos.Add(mappingRepo);
}
public AutomationController(IMappingRepository mappingRepository)
{
//_entityRepo = entityRepo;
_mappingRepository = mappingRepository;
}
public CompaniesController(IMappingRepository <CompanyDto> companyMappingRepository) :
base(companyMappingRepository)
{
}
/// <summary>
/// Asynchronously maps the values on object the to a target type.
/// </summary>
/// <typeparam name="TTarget">The type of the target.</typeparam>
/// <param name="source">The source object.</param>
/// <param name="repo">The repository that will provide the mapper.</param>
/// <returns>
/// The object representing the asynchronous operation. The task result will contain a
/// filled target object.
/// </returns>
public static async Task <TTarget> MapToAsync <TTarget>(this object source, IMappingRepository repo)
{
return(await Task.Run(() => source.MapTo <TTarget>(repo)));
}
public PageProcessor(IPageRepository pages, ILangRepository langs, IMappingRepository mappings)
{
Pages = pages;
Langs = langs;
Mappings = mappings;
}
public SpotifyPlaylistsController(IMappingRepository <SpotifyPlaylistDto> playlistMappingRepo, WorldExplorerContext worldExplorerContext) : base(playlistMappingRepo)
{
_playlistMappingRepo = playlistMappingRepo;
_spotify = new Spotify();
_worldExplorerContext = worldExplorerContext;
}