public CustomMapperAttribute(Type customMapperType)
{
customMapperType.ThrowIfNull("customMapperType");
if (customMapperType.IsNotPublic)
{
throw new ArgumentException("Type must be public.", "customMapperType");
}
if (customMapperType.IsAbstract)
{
throw new ArgumentException("Type cannot be abstract or static.", "customMapperType");
}
if (!customMapperType.ImplementsInterface<ICustomMapper>())
{
throw new ArgumentException(String.Format("Type must implement {0}.", customMapperType.FullName), "customMapperType");
}
ConstructorInfo constructorInfo = customMapperType.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null);
if (constructorInfo == null)
{
throw new ArgumentException("Type must declare a public default constructor.", "customMapperType");
}
_mapper = (ICustomMapper)Activator.CreateInstance(customMapperType);
}
public VehiclesController(
ICarService carService,
ILogger <VehiclesController> logger,
IUriService uriService,
ICustomMapper customMapper,
IWebHostEnvironment appEnvironment,
IVehicleImageRetriever vehicleImageRetriever,
ICustomAuthorizationService authorizationService
)
{
_carService = carService;
_logger = logger;
_uriService = uriService;
_customMapper = customMapper;
_appEnvironment = appEnvironment;
_vehicleImageRetriever = vehicleImageRetriever;
_customAuthorizationService = authorizationService;
// var directory = Directory.GetCurrentDirectory();
var directory = _appEnvironment.WebRootPath;
_logger.LogInformation($"current directory {directory}");
var imgDirectory = $@"{directory}/{ApiRoutes.imgsPath}";
_imgDirectory = imgDirectory;
_logger.LogInformation($"VehiclesController _imgDirectory \n {_imgDirectory}");
}
public CreateQuizCommandHandler(DataContext context, IRandomStringGenerator stringGenerator,
ICustomMapper customMapper)
{
_context = context;
_stringGenerator = stringGenerator;
_customMapper = customMapper;
}
public StudentDataProcessor(IFileReader fileReader, ICustomMapper mapper, IFileWriter fileWriter, IValidator validator)
{
this.fileReader = fileReader;
this.mapper = mapper;
this.fileWriter = fileWriter;
this.validator = validator;
}
public RecipeController(IDataRepository <Recipe> dataRepository, IMapper mapper, ICustomMapper custumMapper, UserManager <ApplicationUser> userManager)
{
_dataRepository = dataRepository;
_mapper = mapper;
_custumMapper = custumMapper;
_userManager = userManager;
}
public CreateProductCommandHandler(ICustomMapper <Product, CreateProductCommand> customMapper,
ICurrentUser currentUser, IProductRepository productRepository)
{
_customMapper = customMapper;
_currentUser = currentUser;
_productRepository = productRepository;
}
public CustomMapperAttribute(Type customMapperType)
{
customMapperType.ThrowIfNull("customMapperType");
if (customMapperType.IsNotPublic)
{
throw new ArgumentException("Type must be public.", "customMapperType");
}
if (customMapperType.IsAbstract)
{
throw new ArgumentException("Type cannot be abstract or static.", "customMapperType");
}
if (!customMapperType.ImplementsInterface <ICustomMapper>())
{
throw new ArgumentException(String.Format("Type must implement {0}.", customMapperType.FullName), "customMapperType");
}
ConstructorInfo constructorInfo = customMapperType.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null);
if (constructorInfo == null)
{
throw new ArgumentException("Type must declare a public default constructor.", "customMapperType");
}
_mapper = (ICustomMapper)Activator.CreateInstance(customMapperType);
}
/// <summary>
/// specify a special mapping, e.g. CLS ArrayList <=> java.util.ArrayList.
/// </summary>
/// <param name="clsType">the native cls type, e.g. ArrayList</param>
/// <param name="idlType">the idl type (mapped from idl to CLS) used to describe serialisation / deserialisation, e.g. java.util.ArrayListImpl</param>
/// <param name="mapper">the mapper, knowing how to map instances of CLS ArrayList to java.util.ArrayListImpl and in the other direction</param>
public void AddMapping(Type clsType, Type idlType, ICustomMapper mapper)
{
// check that idlType implements IIdlEntity:
if (!(ReflectionHelper.IIdlEntityType.IsAssignableFrom(idlType)))
{
throw new Exception("illegal type for custom mapping encountered: " + idlType.FullName);
}
// be aware: mapping is not bijektive, because of impl classes; however for an idl type only one
// cls type is allowed
if (m_mappingsIdl.ContainsKey(idlType) && (!((CustomMappingDesc)m_mappingsIdl[idlType]).ClsType.Equals(clsType)))
{
throw new Exception("mapping constraint violated, tried to insert another cls type " + clsType +
"mapped to the idl type " + idlType);
}
CustomMappingDesc desc = new CustomMappingDesc(clsType, idlType, mapper);
m_mappingsCls[clsType] = desc;
m_mappingsIdl[idlType] = desc;
// check for impl class attribute, if present: add impl class here too
object[] implAttr = idlType.GetCustomAttributes(ReflectionHelper.ImplClassAttributeType, false);
if ((implAttr != null) && (implAttr.Length > 0))
{
ImplClassAttribute implCl = (ImplClassAttribute)implAttr[0];
// get the type
Type implIdlType = Repository.GetValueTypeImplClass(implCl.ImplClass);
if (implIdlType != null) // if impl type not found, (test needed e.g. when called from CLSToIDLGen)
{
CustomMappingDesc descImpl = new CustomMappingDesc(clsType, implIdlType, mapper);
m_mappingsIdl[implIdlType] = descImpl;
}
}
}
public StudentDataProcessorBuilder()
{
this.fileReader = Substitute.For <IFileReader>();
this.mapper = Substitute.For <ICustomMapper>();
this.fileWriter = Substitute.For <IFileWriter>();
this.validator = Substitute.For <IValidator>();
}
public DomainBase(IServiceProvider serviceProvider)
{
Logger = serviceProvider.GetService <IAppLogger <T> >();
SessionManager = serviceProvider.GetService <ISessionManager>();
Mapper = serviceProvider.GetService <ICustomMapper>();
DatabaseUnitOfWork = serviceProvider.GetService <IDatabaseUnitOfWork>();
}
public CreateQuestionCommandHandler(DataContext context, ICustomMapper customMapper,
IUploadFiles uploadFiles, IDocumentsUrl documentsUrl)
{
_context = context;
_customMapper = customMapper;
_uploadFiles = uploadFiles;
_documentsUrl = documentsUrl;
}
public UserService(
IUserManager <User> userManager,
IUserRepository userRepository,
ICustomMapper customMapper)
{
this.userManager = userManager;
this.userRepository = userRepository;
this.customMapper = customMapper;
}
public IdentityController(
IIdentityService identityService,
ILogger <IdentityController> logger,
ICustomMapper customMapper)
{
_identityService = identityService;
_logger = logger;
_customMapper = customMapper;
}
public CarOwnersController(
ICarOwnerService carOwnerService,
ILogger <VehiclesController> logger,
IUriService uriService,
ICustomMapper customMapper)
{
_carOwnerService = carOwnerService;
_logger = logger;
_uriService = uriService;
_customMapper = customMapper;
}
public OrderService(
IOrderRepository orderRepository,
IProductRepository productRepository,
IOrderFactory orderFactory,
ICustomMapper customMapper)
{
this.orderRepository = orderRepository;
this.productRepository = productRepository;
this.orderFactory = orderFactory;
this.customMapper = customMapper;
}
public RecipeHelperController(IDataRepository <Recipe> dataRepository,
IDataRepositoryTokenis <RecipeTokenLookUP> tokenRepository,
ICustomMapper custumMapper,
UserManager <ApplicationUser> userManager,
IDataRepository <Country> countryRepository)
{
_dataRepository = dataRepository;
_tokenRepository = tokenRepository;
_custumMapper = custumMapper;
_userManager = userManager;
_countryRepository = countryRepository;
}
public ProductService(
IProductRepository productRepository,
ICategoryRepository categoryRepository,
IPictureRepository pictureRepository,
IProductFactory productFactory,
ICustomMapper customMapper)
{
this.productRepository = productRepository;
this.categoryRepository = categoryRepository;
this.pictureRepository = pictureRepository;
this.productFactory = productFactory;
this.customMapper = customMapper;
}
public PenaltyController(
IPenaltyRepository penaltyRepository,
ILogger <PenaltyController> logger,
ICustomAuthorizationService customAuthorizationService,
ICustomMapper customMapper,
ICarService carService
)
{
_penaltyRepository = penaltyRepository;
_logger = logger;
_customAuthorizationService = customAuthorizationService;
_customMapper = customMapper;
_carService = carService;
}
public ShoppingCartService(
ILogger <IShoppingCartService> logger,
IShoppingCartRepository shoppingCartRepository,
IProductRepository productRepository,
IPictureRepository pictureRepository,
IShoppingCartFactory shoppingCartFactory,
ICustomMapper customMapper)
{
this.logger = logger;
this.shoppingCartRepository = shoppingCartRepository;
this.productRepository = productRepository;
this.pictureRepository = pictureRepository;
this.shoppingCartFactory = shoppingCartFactory;
this.customMapper = customMapper;
}
public CategoryService(
ICategoryFactory factory,
ICategoryRepository repository,
IProductRepository productRepository,
IPictureRepository pictureRepository,
IProductService productService,
ICustomMapper customMapper)
{
this.factory = factory;
this.categoryRepository = repository;
this.productRepository = productRepository;
this.pictureRepository = pictureRepository;
this.productService = productService;
this.customMapper = customMapper;
}
public void Test_map_From_recipeVieModel_To_recipe()
{
RecipeViewModel acctual = new MockDBHandler().buildMockRecipeView();
DbContextOptions <RepositoryContext> options = new MockDBHandler().CategoryWithThreeMember().CountryWithThreeMember().UnitWithThreeMember().IngredientWithThreeMember().ReciptWithThreeMember().build();
using (var context = new RepositoryContext(options))
{
_custumMapper = new CustomMapper(context);
//Act
var recipDes = _custumMapper.Map(acctual);
var expected = _custumMapper.Map(recipDes);
// Assert
Assert.True(expected.Equals(acctual));
}
}
/// <summary>
/// takes an instance deserialised from a cdr stream and maps it to the instance
/// used in .NET. The mapped instance must be assignable to formalSig.
/// </summary>
/// <remarks>
/// Custom mapping must be present; otherwise an exception is thrown.
/// </remarks>
public object CreateClsForIdlInstance(object idlInstance, Type formalSig)
{
// for subtype of idl formal support, get acutal mapping
CustomMappingDesc actualMapping = GetMappingForIdl(idlInstance.GetType());
if (actualMapping == null)
{
throw new BAD_PARAM(12309, CompletionStatus.Completed_MayBe);
}
ICustomMapper mapper = actualMapping.Mapper;
object result = mapper.CreateClsForIdlInstance(idlInstance);
// check, if mapped instance is assignable to formal in CLS signature -> otherwise will not work.
if (!formalSig.IsAssignableFrom(result.GetType()))
{
throw new BAD_PARAM(12311, CompletionStatus.Completed_MayBe);
}
return(result);
}
/// <summary>
/// adds special mappings from a config stream
/// </summary>
public void AddMappingFromStream(Stream configStream)
{
// check schema ok
if (m_mappingPluginSchema == null)
{
configStream.Close();
throw new Exception("schema loading problem");
}
XmlDocument doc = new XmlDocument();
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas.Add(m_mappingPluginSchema);
XmlReader validatingReader = XmlReader.Create(configStream, settings);
try {
doc.Load(validatingReader);
// process the file
XmlNodeList elemList = doc.GetElementsByTagName("mapping");
foreach (XmlNode elem in elemList)
{
XmlElement idlTypeName = elem["idlTypeName"];
XmlElement idlTypeAsm = elem["idlTypeAssembly"];
XmlElement clsTypeAsqName = elem["clsType"];
XmlElement customMapperElem = elem["customMapper"];
// idlType:
String asmQualIdlName = idlTypeName.InnerText + "," + idlTypeAsm.InnerText;
Type idlType = Type.GetType(asmQualIdlName, true);
// clsType:
Type clsType = Type.GetType(clsTypeAsqName.InnerText, true);
// custom Mapper:
ICustomMapper customMapper = null;
if (customMapperElem != null)
{
Type customMapperType = Type.GetType(customMapperElem.InnerText, true);
customMapper = (ICustomMapper)Activator.CreateInstance(customMapperType);
}
AddMapping(clsType, idlType, customMapper);
}
} finally {
validatingReader.Close();
}
}
/// <summary>
/// takes a .NET instance and maps it to the instance, which should be serialised into
/// the CDR stream. The mapped instance must be assignable to the formal type specified in idl.
/// </summary>
/// <remarks>
/// Custom mapping must be present; otherwise an exception is thrown.
/// </remarks>
public object CreateIdlForClsInstance(object clsInstance, Type formal)
{
// for subtypes support (subtypes of formal before cls to idl mapping; new formal is idl formal)
CustomMappingDesc actualMapping =
GetMappingForCls(clsInstance.GetType());
if (actualMapping == null)
{
throw new BAD_PARAM(12308, CompletionStatus.Completed_MayBe);
}
ICustomMapper mapper = actualMapping.Mapper;
object actual = mapper.CreateIdlForClsInstance(clsInstance);
// check, if mapped is instance is assignable to formal -> otherwise will not work on other side ...
if (!formal.IsAssignableFrom(actual.GetType()))
{
throw new BAD_PARAM(12310, CompletionStatus.Completed_MayBe);
}
return(actual);
}
public void Test_map_From_recipe_To_recipeVieModel()
{
DbContextOptions <RepositoryContext> options = new MockDBHandler().CategoryWithThreeMember().CountryWithThreeMember().UnitWithThreeMember().IngredientWithThreeMember().ReciptWithThreeMember().build();
using (var context = new RepositoryContext(options))
{
_custumMapper = new CustomMapper(context);
var acctual = context.Recipe.Include(y => y.Category)
.Include(r => r.Country)
.Include(w => w.Ingredients)
.FirstOrDefaultAsync().Result;
acctual.Ingredients = context.RecipeIngredient.Include(x => x.Ingredient).Include(y => y.Unit).Where(T => T.RecipeID == acctual.ID).ToList();
//Act
var recipDes = _custumMapper.Map(acctual);
var expected = _custumMapper.Map(recipDes);
// Assert
Assert.True(expected.Equals(acctual));
}
}
public static IPagedList <TResult> ToMappedPagedList <TSource, TResult>(this IPagedList <TSource> list, ICustomMapper <TSource, TResult> mapper) where TSource : class
{
var sourceList = mapper.Map(list);
return(new StaticPagedList <TResult>(sourceList, list.GetMetaData()));
}
/// <summary>
///
/// </summary>
/// <param name="clsType"></param>
/// <param name="idlType"></param>
/// <param name="mapper"></param>
/// <remarks>precondition: clsType != null, idlType != null, mapper != null</remarks>
public CustomMappingDesc(Type clsType, Type idlType, ICustomMapper mapper)
{
m_clsType = clsType;
m_idlType = idlType;
m_mapper = mapper;
}
public StudentDataProcessorBuilder WithMapper(ICustomMapper mapper)
{
this.mapper = mapper;
return(this);
}
/// <summary>
///
/// </summary>
/// <param name="clsType"></param>
/// <param name="idlType"></param>
/// <param name="mapper"></param>
/// <remarks>precondition: clsType != null, idlType != null, mapper != null</remarks>
public CustomMappingDesc(Type clsType, Type idlType, ICustomMapper mapper) {
m_clsType = clsType;
m_idlType = idlType;
m_mapper = mapper;
}
/// <summary>
/// specify a special mapping, e.g. CLS ArrayList <=> java.util.ArrayList.
/// </summary>
/// <param name="clsType">the native cls type, e.g. ArrayList</param>
/// <param name="idlType">the idl type (mapped from idl to CLS) used to describe serialisation / deserialisation, e.g. java.util.ArrayListImpl</param>
/// <param name="mapper">the mapper, knowing how to map instances of CLS ArrayList to java.util.ArrayListImpl and in the other direction</param>
public void AddMapping(Type clsType, Type idlType, ICustomMapper mapper) {
// check that idlType implements IIdlEntity:
if (!(ReflectionHelper.IIdlEntityType.IsAssignableFrom(idlType))) {
throw new Exception("illegal type for custom mapping encountered: " + idlType.FullName);
}
// be aware: mapping is not bijektive, because of impl classes; however for an idl type only one
// cls type is allowed
if (m_mappingsIdl.ContainsKey(idlType) && (!((CustomMappingDesc)m_mappingsIdl[idlType]).ClsType.Equals(clsType))) {
throw new Exception("mapping constraint violated, tried to insert another cls type " + clsType +
"mapped to the idl type " + idlType);
}
CustomMappingDesc desc = new CustomMappingDesc(clsType, idlType, mapper);
m_mappingsCls[clsType] = desc;
m_mappingsIdl[idlType] = desc;
// check for impl class attribute, if present: add impl class here too
object[] implAttr = idlType.GetCustomAttributes(ReflectionHelper.ImplClassAttributeType, false);
if ((implAttr != null) && (implAttr.Length > 0)) {
ImplClassAttribute implCl = (ImplClassAttribute) implAttr[0];
// get the type
Type implIdlType = Repository.GetValueTypeImplClass(implCl.ImplClass);
if (implIdlType != null) { // if impl type not found, (test needed e.g. when called from CLSToIDLGen)
CustomMappingDesc descImpl = new CustomMappingDesc(clsType, implIdlType, mapper);
m_mappingsIdl[implIdlType] = descImpl;
}
}
}
public HomeController(IWeatherService weatherService, ICustomMapper mapper)
{
_weatherService = weatherService;
_mapper = mapper;
}
public EditQuizCommandHandler(DataContext context, ICustomMapper customMapper)
{
_context = context;
_customMapper = customMapper;
}
public GenericManager(IGenericRepository <T> genericRepository, IMapper mapper, ICustomMapper customMapper)
{
this.genericRepository = genericRepository;
this.mapper = mapper;
this.customMapper = customMapper;
}
