public Mapper()
{
_assemblyRepository = new AssemblyRepository();
_typeRepository = new TypeRepository(_assemblyRepository);
_memberRepository = new MemberRepository(_typeRepository);
_modelCreator = new ModelCreator(_typeRepository, _memberRepository);
}
public AvaloniaXamlMember(string name,
XamlType owner,
ITypeRepository xamlTypeRepository,
ITypeFeatureProvider featureProvider)
: base(name, owner, xamlTypeRepository, featureProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodInfoTypeFactory"/> class.
/// </summary>
/// <param name="typeRepository">The type repository.</param>
public MethodInfoTypeFactory(ITypeRepository typeRepository)
{
if (typeRepository == null)
throw new ArgumentNullException("typeRepository");
_typeRepository = typeRepository;
}
public VehicleEditorModel(ICustomerRepository customerRepository, IVehicleGroupRepository vehicleGroupRepository,
IVehicleRepository vehicleRepository,
IVehicleDetailRepository vehicleDetailRepository, IVehicleWheelRepository vehicleWheelRepository,
ISparepartRepository sparepartRepository, ITypeRepository typeRepository,
ISpecialSparepartDetailRepository wheelDetailRepository, IBrandRepository brandRepository,
ISparepartDetailRepository sparepartDetailRepository,
ISpecialSparepartDetailRepository specialSparepartDetailRepository,
ISparepartStockCardRepository sparepartStokCardRepository,
IReferenceRepository referenceRepository,
IUnitOfWork unitOfWork)
: base()
{
_customerRepository = customerRepository;
_vehicleGroupRepository = vehicleGroupRepository;
_vehicleRepository = vehicleRepository;
_vehicleDetailRepository = vehicleDetailRepository;
_vehicleWheelRepository = vehicleWheelRepository;
_specialSparepartDetailRepository = wheelDetailRepository;
_sparepartDetailRepository = sparepartDetailRepository;
_sparepartRepository = sparepartRepository;
_typeRepository = typeRepository;
_brandRepository = brandRepository;
_sparepartStokCardRepository = sparepartStokCardRepository;
_referenceRepository = referenceRepository;
_unitOfWork = unitOfWork;
}
public TypeEditorModel(ITypeRepository typeRepository,
IUnitOfWork unitOfWork)
: base()
{
_typeRepository = typeRepository;
_unitOfWork = unitOfWork;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyTypeBuilder"/> class.
/// </summary>
/// <param name="typeRepository">The type repository.</param>
/// <param name="parentType">The parent type.</param>
public ProxyTypeBuilder(ITypeRepository typeRepository, Type parentType)
{
if (typeRepository == null)
throw new ArgumentNullException("typeRepository");
if (parentType == null)
throw new ArgumentNullException("parentType");
if (parentType.IsSealed)
throw new ArgumentException(Resources.ParentTypeMustNotBeSealed, "parentType");
if (parentType.IsGenericTypeDefinition)
throw new ArgumentException(Resources.ParentTypeMustNotBeAGenericTypeDefinition, "parentType");
_typeRepository = typeRepository;
_parentType = parentType;
_typeBuilder = typeRepository.DefineType("Proxy" , parentType);
_invocationHandlerFieldInfo = _typeBuilder.DefineField(
"_invocationHandler",
typeof (IInvocationHandler),
FieldAttributes.Private | FieldAttributes.InitOnly);
_interfaceTypes = new HashSet<Type>();
}
public WpfAttachableMember(string name,
MethodInfo getter,
MethodInfo setter,
ITypeRepository typeRepository,
ITypeFeatureProvider typeFeatureProvider)
: base(name, getter, setter, typeRepository, typeFeatureProvider)
{
}
public PerspexAttachableXamlMember(string name,
XamlType owner,
MethodInfo getter,
MethodInfo setter,
ITypeRepository xamlTypeRepository,
ITypeFeatureProvider featureProvider)
: base(name, getter, setter, xamlTypeRepository, featureProvider)
{
}
private Type ResolveFromString(string type, ITypeRepository typeRepository)
{
Guard.ThrowIfNull(type, nameof(type));
var split = type.Split(':');
var prefix = split.Length == 1 ? split[0] : null;
var typeName = split.Length == 1 ? split[1] : split[0];
var xamlType = typeRepository.GetByPrefix(prefix, typeName);
return xamlType.UnderlyingType;
}
public ModelCreator(ITypeRepository typeRepository, IMemberRepository memberRepository)
{
_types.Push(TypeKey.None);
_methods.Push(MethodKey.None);
_properties.Push(PropertyKey.None);
_fields.Push(FieldKey.None);
_events.Push(EventKey.None);
_typeRepository = typeRepository;
_memberRepository = memberRepository;
}
public AttachableMember(string name,
MethodInfo getter,
MethodInfo setter,
ITypeRepository typeRepository,
ITypeFeatureProvider featureProvider) : base(name, typeRepository.GetByType(getter.DeclaringType), typeRepository, featureProvider)
{
this.getter = getter;
this.setter = setter;
XamlType = LookupType();
}
public TypeService()
{
try
{
string typeStr1 = ConfigurationManager.AppSettings["typeRepository"];
Type type1 = Type.GetType(typeStr1);
repo = (ITypeRepository)Activator.CreateInstance(type1);
repo.SourcePath = System.Web.Hosting.HostingEnvironment.MapPath("~/App_data/type.xml");
}
catch (Exception ex) { }
}
public XamlType(Type type, ITypeRepository typeRepository, ITypeFactory typeTypeFactory, ITypeFeatureProvider featureProvider)
{
Guard.ThrowIfNull(type, nameof(type));
Guard.ThrowIfNull(typeRepository, nameof(typeRepository));
Guard.ThrowIfNull(featureProvider, nameof(featureProvider));
TypeRepository = typeRepository;
TypeFactory = typeTypeFactory;
FeatureProvider = featureProvider;
UnderlyingType = type;
Name = type.Name;
}
public Context(DbContext context = null,
IUserRepository users = null,
IUserProfileRepository profiles = null,
IModelRepository models = null,
IBrandRepository brands = null,
ITypeRepository types =null,
ICarRepository cars =null,
IImageCarRepository imageCars =null)
{
_db = context ?? new CarDatabase();
Users = users ?? new UserRepository(_db,true);
Profiles = profiles ?? new UserProfileRepository(_db, true);
Models = models ?? new ModelRepository(_db, true);
Brands = brands ?? new BrandRepository(_db, true);
Types = types ?? new TypeRepository(_db, true);
Cars = cars ?? new CarRepository(_db, true);
ImageCars = imageCars ?? new ImageCarRepository(_db, true);
}
public AvaloniaXamlType(Type type,
ITypeRepository typeRepository,
ITypeFactory typeFactory,
ITypeFeatureProvider featureProvider) : base(type, typeRepository, typeFactory, featureProvider)
{
}
public TypeService(ITypeRepository typeRepository, IProductService productService)
{
_typeRepository = typeRepository;
_productService = productService;
}
public AuthorController(IAuthorRepository _authRepo, IBookRepository _bookRepo, ITypeRepository _typeRepo)
{
authorRepository = _authRepo;
bookRepository = _bookRepo;
typeRepository = _typeRepo;
}
public TypeService(ITypeRepository typeRepository)
{
_typeRepository = typeRepository;
}
// Ctor
public AdminTypeController (ITypeRepository repo)
=> typeRepository = repo;
private static XamlInstructionBuilder CreateBuilder(ITypeRepository typeRepository)
{
return new XamlInstructionBuilder(typeRepository);
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
CycleEvents = new CycleEventRepository(_context);
Types = new TypeRepository(_context);
}
public DeviceService(ILogger <DeviceService> log, IMapper mapper, IDeviceRepository dr, IProjectService ps, ITypeHardwareConfigService th, ITypeRepository tr)
{
this._log = log;
this._mapper = mapper;
this._dr = dr;
this._ps = ps;
this._th = th;
this._tr = tr;
}
public Member(string name, XamlType declaringType, ITypeRepository typeRepository, ITypeFeatureProvider featureProvider)
: base(name, declaringType, typeRepository, featureProvider)
{
XamlType = LookupType();
}
public FunctionalTypeController(ITypeRepository typeRepository)
{
_typeRepository = typeRepository;
}
public BookController(ILanguageRepository _languageRepo, IPublisherRepository _publisherRepo, IBookRepository _bookRepo, ITypeRepository _typeRepo, IAuthorRepository _authRepo)
{
bookRepository = _bookRepo;
typeRepository = _typeRepo;
authorRepository = _authRepo;
publisherRepository = _publisherRepo;
languageRepository = _languageRepo;
}
public ValueCommand(StateCommuter stateCommuter, ITypeRepository typeSource, ITopDownValueContext topDownValueContext, string value) : base(stateCommuter)
{
this.value = value;
ValuePipeLine = new ValuePipeline(typeSource, topDownValueContext);
}
public XamlInstructionBuilder(ITypeRepository registry)
{
this.registry = registry;
}
public RuntimeTypeSource(ITypeRepository typeRepository, INamespaceRegistry nsRegistry)
{
TypeRepository = typeRepository;
NamespaceRegistry = nsRegistry;
}
public TypeSystemService(ILogger <TypeSchemaService> log, IMapper mapper, ITypeSystemRepository tsr, ITypeRepository tr)
{
this._log = log;
this._mapper = mapper;
this._tsr = tsr;
this._tr = tr;
}
public TypeUpdateFileService(ILogger <TypeUpdateFileService> log, IMapper mapper, ITypeUpdateFileRepository tu, ITypeRepository tr)
{
this._log = log;
this._mapper = mapper;
this._tu = tu;
this._tr = tr;
}
public RecipeController(IProductRepository product, IRecipeRepository recipe, ITypeRepository type)
{
productRepository = product;
recipeRepository = recipe;
typeRepository = type;
}
public ZoningDomainService(ITypeRepository typeRepository)
{
_typeRepository = typeRepository;
}
public StartObjectCommand(StateCommuter stateCommuter, ITypeRepository typeRepository, XamlType xamlType, object rootInstance) : base(stateCommuter)
{
this.typeRepository = typeRepository;
this.xamlType = xamlType;
this.rootInstance = rootInstance;
}
public TypeController(ITypeRepository repo, ILogger logger)
{
_repo = repo;
_logger = logger;
}
public MemberRepository(ITypeRepository typeRepository)
{
_typeRepository = typeRepository;
}
public TypeConfigService(ILogger <TypeConfigService> log, ITypeConfigRepository tc, IMapper mapper, ITypeRepository tr)
{
this._log = log;
this._tc = tc;
this._mapper = mapper;
this._tr = tr;
}
public ValuesController(IProductRepository productContext, ITypeRepository productTypeRepository)
{
_productContext = productContext;
_productTypeContext = productTypeRepository;
}
public TypeListModel(ITypeRepository typeRepository, IUnitOfWork unitOfWork)
: base()
{
_typeRepository = typeRepository;
_unitOfWork = unitOfWork;
}
public DeviceController(IDeviceRepository deviceRepository, IManufacturerRepository manufacturerRepository, ITypeRepository typeRepository,
IOperatingSystemRepository operatingSystemRepository, IOSversionRepository osVersionRepository, IRAMamountRepository ramAmountRepository,
IProcessorRepository processorRepository, IUserRepository userRepository)
{
_deviceRepository = deviceRepository;
_manufacturerRepository = manufacturerRepository;
_typeRepository = typeRepository;
_operatingSystemRepository = operatingSystemRepository;
_osVersionRepository = osVersionRepository;
_ramAmountRepository = ramAmountRepository;
_processorRepository = processorRepository;
_userRepository = userRepository;
}
public WpfMember(string name, XamlType declaringType, ITypeRepository typeRepository, ITypeFeatureProvider typeFeatureProvider)
: base(name, declaringType, typeRepository, typeFeatureProvider)
{
}
public TypesController(ITypeRepository typeRepository)
{
_typeRepository = typeRepository;
}
public TypeMenuViewComponent(ITypeRepository repo)
{
_repository = repo;
}
public EndMemberCommand(ITypeRepository typeRepository, StateCommuter stateCommuter, IValueContext valueContext) : base(stateCommuter)
{
this.typeRepository = typeRepository;
this.valueContext = valueContext;
}
public EndMemberCommand(ITypeRepository typeRepository, StateCommuter stateCommuter) : base(stateCommuter)
{
this.typeRepository = typeRepository;
}
public TypeService(ITypeRepository typeRepository, IUnitOfWork unitOfWork)
{
this._typeRepository = typeRepository;
this._unitOfWork = unitOfWork;
}
public TypesSeeds(ITypeRepository typeRepository)
{
_typeRepository = typeRepository;
}
public HomeController(ILogger <HomeController> logger, ITypeRepository typeRepository)
{
_logger = logger;
_typeRepository = typeRepository;
}
public TypeService(ITypeRepository typeRepository)
{
this.typeRepository = typeRepository;
}
public XamlTypeMock(Type type, ITypeRepository typeRepository, ITypeFactory typeTypeFactory, ITypeFeatureProvider featureProvider)
: base(type, typeRepository, typeTypeFactory, featureProvider)
{
}
public EndMemberCommand(ITypeRepository typeRepository, StateCommuter stateCommuter, IValueContext valueContext)
: base(stateCommuter)
{
this.typeRepository = typeRepository;
this.valueContext = valueContext;
}
public ValueContext(ITypeRepository typeRepository, ITopDownValueContext topDownValueContext, IReadOnlyDictionary<string, object> parsingDictionary)
{
this.typeRepository = typeRepository;
this.topDownValueContext = topDownValueContext;
this.parsingDictionary = parsingDictionary;
}
public DeviceController(IDeviceRepository repository, ICampaignRepository campaign, ITypeRepository type, IUsersRepository usersRepository)
{
_repository = repository;
_campaign = campaign;
_typeRepository = type;
_usersRepository = usersRepository;
}
public static XamlType Create(Type underlyingType,
ITypeRepository typeRepository,
ITypeFactory typeFactory,
ITypeFeatureProvider featureProvider)
{
Guard.ThrowIfNull(underlyingType, nameof(typeRepository));
return new XamlType(underlyingType, typeRepository, typeFactory, featureProvider);
}
public PerspexXamlType(Type type,
ITypeRepository typeRepository,
ITypeFactory typeFactory,
ITypeFeatureProvider featureProvider) : base(type, typeRepository, typeFactory, featureProvider)
{
}
public Member(string name, XamlType declaringType, ITypeRepository typeRepository, ITypeFeatureProvider featureProvider)
: base(name, declaringType, typeRepository, featureProvider)
{
XamlType = LookupType();
}
public RuntimeTypeSource(ITypeRepository typeRepository, INamespaceRegistry nsRegistry)
{
TypeRepository = typeRepository;
NamespaceRegistry = nsRegistry;
}
public AnothersExpenseController(UserManager <User> userManager, SignInManager <User> signInManager, ITypeRepository typeRepository,
IAnothersExpenseRepository anothersExpenseRepository, ICategoryRepository categoryRepository)
{
_userManager = userManager;
_signInManager = signInManager;
_anothersExpenseRepository = anothersExpenseRepository;
_categoryRepository = categoryRepository;
_typeRepository = typeRepository;
}
public ImageController(IImageRepository imageRepository, IHashRepository hashRepository, ITypeRepository typeRepository, IConfiguration configuration, IHttpClientFactory clientFactory)
{
ImageRepository = imageRepository;
HashRepository = hashRepository;
TypeRepository = typeRepository;
Configuration = configuration;
HttpClientFactory = clientFactory;
}
public ValuePipeline(ITypeRepository typeRepository, ITopDownValueContext topDownValueContext)
{
this.typeRepository = typeRepository;
this.topDownValueContext = topDownValueContext;
}
public UploadController(ITypeRepository typeRepository)
{
this.typeRepository = typeRepository;
}
