public NeuralNetworkItemMatcher(IItemMapper mapper, IDictionary <string, IndexableAttributeMetadata> actualMetadata, ICollection <LostAndFoundIndexedItem> items)
{
Mapper = mapper;
ActualMetadata = actualMetadata;
Findings = items.Where(item => item.ItemType == LostAndFoundIndexedItem.Type.Finding).ToArray();
Losses = items.Where(item => item.ItemType == LostAndFoundIndexedItem.Type.Loss).ToArray();
}
public GenreService(IGenreRepository genreRepository, IItemRepository itemRepository, IGenreMapper genreMapper, IItemMapper itemMapper)
{
_genreRepository = genreRepository;
_itemRepository = itemRepository;
_genreMapper = genreMapper;
_itemMapper = itemMapper;
}
public ItemService(IItemRepository itemRepository, IItemMapper itemMapper, ILogger <IItemService> logger, ConnectionFactory eventBusConnectionFactory, EventBusSettings settings)
{
_itemRepository = itemRepository;
_itemMapper = itemMapper;
_logger = logger;
_eventBusConnectionFactory = eventBusConnectionFactory;
_settings = settings;
}
public ItemService(IItemRespository itemRespository, IGenreRespository genreRespository, IArtistRespository artistRespository, IItemMapper itemMapper, ILogger <IItemService> logger)
{
_itemRespository = itemRespository;
_genreRespository = genreRespository;
_artistRespository = artistRespository;
_itemMapper = itemMapper;
_logger = logger;
}
public ArtistService(IArtistRepository artistRepository, IItemRepository itemRepository,
IArtistMapper artistMapper, IItemMapper itemMapper)
{
_artistRepository = artistRepository;
_itemRepository = itemRepository;
_artistMapper = artistMapper;
_itemMapper = itemMapper;
}
/// <summary>
/// Constructor for BaseHackerRestClient
/// </summary>
/// <param name="config">RestApiConfig containing details about Rest API to call</param>
/// <param name="logger">ILogger implementation for logging</param>
/// <param name="itemMapper">IItemMapper implementation for parsing the type from the response.</param>
public HackerNewsRestClient(IApiConfig config,
IHttpClientFactory clientFactory,
ILogger <IHackerNewsClient <T> > logger,
IItemMapper <T> itemMapper)
{
this.apiConfig = config;
this.clientFactory = clientFactory;
this.logger = logger;
this.itemMapper = itemMapper;
}
public ItemServiceTests(CatalogContextFactory catalogContextFactory, ITestOutputHelper testOutputHelper)
{
_itemRepository = new ItemRepository(catalogContextFactory.ContextInstance);
_mapper = catalogContextFactory.ItemMapper;
_logger = new Mock <LoggerAbstraction <IItemService> >();
_logger
.Setup(x => x.Log(It.IsAny <LogLevel>(), It.IsAny <Exception>(), It.IsAny <string>()))
.Callback((LogLevel logLevel, Exception exception, string information) => testOutputHelper.WriteLine($"{logLevel}:{information}"));
}
public CatalogContextFactory()
{
var contextOptions = new DbContextOptionsBuilder <CatalogContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.EnableSensitiveDataLogging()
.Options;
EnsureCreation(contextOptions);
ContextInstance = new TestCatalogContext(contextOptions);
GenreMapper = new GenreMapper();
ArtistMapper = new ArtistMapper();
ItemMapper = new ItemMapper(ArtistMapper, GenreMapper);
}
public void HandleMapping <TModel>(
TModel model,
Item item,
IPropertyMeta propertyMeta,
ICache cache,
IItemMapper itemMapper)
{
var renderingParameterMappings = MappingUtil.GetRenderingParameterMappers(cache);
var renderingContext = RenderingContext.Current;
if (renderingContext != null)
{
if (renderingParameterMappings.ContainsKey(propertyMeta.PropertyKey))
{
renderingParameterMappings[propertyMeta.PropertyKey].SetRenderingParameterMappingMapping(
model,
propertyMeta,
renderingContext);
}
}
}
public void HandleMapping <TModel>(TModel model, Item item, IPropertyMeta propertyMeta, ICache cache, IItemMapper itemMapper)
{
var itemPropertyMappings = MappingUtil.GetItemPropertyMappers(cache);
if (itemPropertyMappings.ContainsKey(propertyMeta.PropertyKey))
{
itemPropertyMappings[propertyMeta.PropertyKey].SetItemPropertyMapping(model, propertyMeta, item);
}
}
public PrincipleMapper(IItemMapper itemMapper)
{
_itemMapper = itemMapper;
}
public ItemServiceTest()
{
_itemMapperStub = Substitute.For <IItemMapper>();
_itemRepositoryStub = Substitute.For <IItemRepository>();
_itemService = new ItemService(_itemMapperStub, _itemRepositoryStub);
}
public SiteConfigurationRepository(IItemMapper itemMapper, ICacheService cacheService)
{
_itemMapper = itemMapper;
_cacheService = cacheService;
}
public AddItemCommandHandler(IItemRespository itemRespository, IItemMapper itemMapper, ILogger <IRequest> logger)
{
_itemRespository = itemRespository;
_itemMapper = itemMapper;
_logger = logger;
}
public SortOptionRepository(ICacheService cacheService, IItemMapper itemMapper)
{
this.cacheService = cacheService;
this.itemMapper = itemMapper;
}
public void HandleMapping <TModel>(TModel model, Item item, IPropertyMeta propertyMeta, ICache cache, IItemMapper itemMapper)
{
var itemFieldMappings = MappingUtil.GetFieldMappers(cache);
if (item == null || item.Fields[propertyMeta.MappingName] == null)
{
return;
}
if (itemFieldMappings.ContainsKey(propertyMeta.PropertyKey))
{
itemFieldMappings[propertyMeta.PropertyKey].SetModelFieldMapping(model, propertyMeta, item);
}
else
{
HandleLinkedObjectMapping(model, item, propertyMeta, itemMapper);
}
}
public LeisureActivityMapper(IItemMapper itemMapper)
{
_itemMapper = itemMapper;
}
public MatchingItemMatcher(IItemMapper mapper)
{
_mapper = mapper;
}
public ItemServiceTests(CatalogContextFactory catalogContextFactory)
{
_itemRepository = new ItemRepository(catalogContextFactory.ContextInstance);
_mapper = catalogContextFactory.ItemMapper;
}
public DelteItemCommandHandler(IItemService itemService, IItemMapper itemMapper, ILogger <IRequest> logger)
{
_itemService = itemService;
_itemMapper = itemMapper;
_logger = logger;
}
public ItemController(IItemMapper itemMapper, IitemService itemService)
{
_itemMapper = itemMapper;
_itemService = itemService;
}
private void HandleLinkedObjectMapping <TModel>(TModel model, Item item, IPropertyMeta propertyMeta, IItemMapper itemMapper)
{
Guid guid;
if (!Guid.TryParse(item[propertyMeta.MappingName], out guid))
{
return;
}
var linkedItem = global::Sitecore.Context.Database.GetItem(new ID(guid));
if (linkedItem == null)
{
return;
}
var property = model.GetType().GetProperty(propertyMeta.PropertyName);
var linkedObject = Activator.CreateInstance(property.PropertyType) as dynamic;
itemMapper.Map(linkedObject, linkedItem);
property.SetValue(model, linkedObject);
}
public NavigationService(IItemMapper mapper, ICacheService cacheService)
{
this.mapper = mapper;
this.cacheService = cacheService;
}
public TaskMapper(IItemMapper itemMapper)
{
_itemMapper = itemMapper;
}
public ProductionController(IUnitOfWork uOW, IOrderMapper orderMapper, IItemMapper itemMapper)
{
_uOW = uOW;
_orderMapper = orderMapper;
_itemMapper = itemMapper;
}
public ItemService(IItemRepository itemRepository, IItemMapper itemMapper, ILogger <IItemService> logger)
{
_itemRepository = itemRepository;
_itemMapper = itemMapper;
_logger = logger;
}
public RandomNotMatchingItemMatcher(IItemMapper mapper, int daysWithoutMatch)
{
_mapper = mapper;
_daysWithoutMatch = daysWithoutMatch;
}
public void HandleMapping <TModel>(TModel model, Item item, IPropertyMeta propertyMeta, ICache cache, IItemMapper itemMapper)
{
var childMapPropertyMeta = propertyMeta as IChildMappingPropertyMeta;
if (childMapPropertyMeta == null || model.GetType().GetProperty(propertyMeta.PropertyName).Equals(null))
{
return;
}
var property = model.GetType().GetProperty(propertyMeta.PropertyName);
var listType = property.PropertyType.GetGenericArguments()[0];
var genericList = typeof(List <>).MakeGenericType(listType);
var collection = Activator.CreateInstance(genericList) as IList;
if (collection == null)
{
return;
}
var parentItem = GetParentItemForChildCollection(item, childMapPropertyMeta);
if (parentItem != null)
{
foreach (Item childItem in parentItem.Children)
{
var childObject = Activator.CreateInstance(listType) as dynamic;
itemMapper.Map(childObject, childItem);
collection.Add(childObject);
}
}
property.SetValue(model, collection);
}
public ItemService(IItemRepository itemRepository, IItemMapper itemMapper)
{
_itemRepository = itemRepository;
_itemMapper = itemMapper;
}
public ItemController(IItemService Service, IItemMapper Mapper)
{
_itemService = Service;
_itemMapper = Mapper;
}
