private void ProcessUnresolvedTypes(ITypeRegistry typeRegistry)
{
foreach (TypeReference unresolvedType in
typeRegistry.GetUnresolvedTypes())
{
if (IsObjectType(unresolvedType))
{
typeRegistry.RegisterType(
new TypeReference(typeof(ObjectType <>)
.MakeGenericType(unresolvedType.ClrType)));
}
else if (IsInputObjectType(unresolvedType))
{
typeRegistry.RegisterType(
new TypeReference(typeof(InputObjectType <>)
.MakeGenericType(unresolvedType.ClrType)));
}
else if (IsEnumType(unresolvedType))
{
typeRegistry.RegisterType(
new TypeReference(typeof(EnumType <>)
.MakeGenericType(unresolvedType.ClrType)));
}
}
}
private Dictionary <ObjectType, ObjectTypeBinding> CreateObjectTypeBindings(
ITypeRegistry typeRegistry)
{
Dictionary <ObjectType, ObjectTypeBinding> typeBindings =
new Dictionary <ObjectType, ObjectTypeBinding>();
foreach (TypeBindingInfo typeBindingInfo in _typeBindings)
{
if (typeBindingInfo.Name == null)
{
typeBindingInfo.Name = GetNameFromType(typeBindingInfo.Type);
}
IEnumerable <FieldBinding> fieldBindings = null;
if (typeRegistry.TryGetType <ObjectType>(
typeBindingInfo.Name, out ObjectType ot))
{
fieldBindings = CreateFieldBindings(typeBindingInfo, ot.Fields);
typeBindings[ot] = new ObjectTypeBinding(ot.Name,
typeBindingInfo.Type, ot, fieldBindings);
}
}
return(typeBindings);
}
public void Initialise(ITypeRegistry registry)
{
registry.RegisterType<IContactsProvider, GoogleContactsProvider>();
registry.RegisterType<IAccountAuthentication, GoogleAuthentication>("GoogleAuthentication");
GoogleConfigSection.EnsureIsValid();
}
public DefaultTableMappingStrategy()
{
if (ServiceLocator.IsInitialised())
{
_typeRegistry = ServiceLocator.Instance.Resolve <ITypeRegistry>();
}
}
private void CompleteAbstractTypeResolver(
ITypeRegistry typeRegistry)
{
if (_resolveAbstractType == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
List <ObjectType> types = null;
_resolveAbstractType = (c, r) =>
{
if (types == null)
{
types = typeRegistry.GetTypes()
.OfType <ObjectType>()
.Where(t => t.Interfaces.ContainsKey(Name))
.ToList();
}
foreach (ObjectType type in types)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
public FileObjectAccess(string path, ITypeRegistry typeRegistry)
{
Path = path;
_buffer = new DataAccessBuffer();
TypeRegistry = typeRegistry;
}
private string LookupFieldName(ITypeRegistry typeRegistry, FieldResolverMember fieldResolverMember)
{
foreach (ResolverCollectionBindingInfo resolverBinding in
_resolverBindings[fieldResolverMember.TypeName])
{
FieldResolverBindungInfo fieldBinding = resolverBinding.Fields
.FirstOrDefault(t => t.FieldMember == fieldResolverMember.Member);
if (fieldBinding != null)
{
return(fieldBinding.FieldName);
}
}
if (typeRegistry.TryGetTypeBinding(fieldResolverMember.TypeName, out ObjectTypeBinding binding))
{
FieldBinding fieldBinding = binding.Fields.Values
.FirstOrDefault(t => t.Member == fieldResolverMember.Member);
if (fieldBinding != null)
{
return(fieldBinding.Name);
}
}
return(fieldResolverMember.FieldName);
}
public override void Generate(Service service, Element element, ITypeRegistry registry)
{
base.Generate(service, element, registry);
// Aggregate repository
var aggregate = base.GetDependency <Aggregate>(element, registry);
if (aggregate != null)
{
service.AggregateRepository = aggregate.Value.Type;
}
// Query repositories
var repositories = base.GetDependencies <Aggregate>(element, registry, "query");
foreach (var repository in repositories)
{
if (!service.QueryRepositories.Contains(repository.Type))
{
service.QueryRepositories.Add(repository.Type);
}
}
// Services
var services = base.GetDependencies <Service>(element, registry);
foreach (var s in services)
{
if (!service.Services.Contains(s.Type))
{
service.Services.Add(s.Type);
}
}
}
private Dictionary <InputObjectType, InputObjectTypeBinding> CreateInputObjectTypeBindings(
ITypeRegistry typeRegistry)
{
Dictionary <InputObjectType, InputObjectTypeBinding> typeBindings =
new Dictionary <InputObjectType, InputObjectTypeBinding>();
foreach (TypeBindingInfo typeBindingInfo in _typeBindings)
{
if (typeBindingInfo.Name == null)
{
typeBindingInfo.Name = typeBindingInfo.Type.GetGraphQLName();
}
IEnumerable <InputFieldBinding> fieldBindings = null;
if (typeRegistry.TryGetType <InputObjectType>(
typeBindingInfo.Name, out InputObjectType iot))
{
fieldBindings = CreateInputFieldBindings(typeBindingInfo, iot.Fields);
typeBindings[iot] = new InputObjectTypeBinding(iot.Name,
typeBindingInfo.Type, iot, fieldBindings);
}
}
return(typeBindings);
}
internal void CompleteInputField(
ITypeRegistry typeRegistry,
Action <SchemaError> reportError,
INamedType parentType)
{
_type = _typeFactory(typeRegistry);
if (_type == null)
{
reportError(new SchemaError(
$"The type of the input field {Name} is null.",
parentType));
}
if (_defaultValueFactory == null)
{
DefaultValue = new NullValueNode(null);
}
else
{
DefaultValue = _defaultValueFactory(typeRegistry);
}
if (parentType is InputObjectType &&
Property == null &&
typeRegistry.TryGetTypeBinding(parentType, out InputObjectTypeBinding binding) &&
binding.Fields.TryGetValue(Name, out InputFieldBinding fieldBinding))
{
Property = fieldBinding.Property;
}
}
private void CompleteCollectionBindings(ITypeRegistry typeRegistry)
{
foreach (ResolverCollectionBindingInfo binding in _resolverBindings
.OfType <ResolverCollectionBindingInfo>())
{
if (binding.ObjectType == null && binding.ObjectTypeName == null)
{
binding.ObjectType = binding.ResolverType;
}
ObjectTypeBinding typeBinding = null;
if (binding.ObjectType == null && typeRegistry
.TryGetTypeBinding(binding.ObjectTypeName, out typeBinding))
{
binding.ObjectType = typeBinding.Type;
}
if (binding.ObjectTypeName == null && typeRegistry
.TryGetTypeBinding(binding.ObjectType, out typeBinding))
{
binding.ObjectTypeName = typeBinding.Name;
}
if (binding.ObjectTypeName == null)
{
binding.ObjectTypeName = binding.ObjectType.GetGraphQLName();
}
// TODO : error handling if object type cannot be resolverd
CompleteFieldResolverBindungs(binding, typeBinding, binding.Fields);
}
}
CreateObjectTypeBindings(ITypeRegistry typeRegistry)
{
var typeBindings = new Dictionary <ObjectType, ObjectTypeBinding>();
foreach (TypeBindingInfo typeBindingInfo in _typeBindings)
{
if (typeBindingInfo.Name == null)
{
typeBindingInfo.Name =
typeBindingInfo.Type.GetGraphQLName();
}
IEnumerable <FieldBinding> fieldBindings = null;
if (typeRegistry.TryGetType(
typeBindingInfo.Name, out ObjectType ot))
{
fieldBindings =
CreateFieldBindings(typeBindingInfo, ot.Fields);
typeBindings[ot] = new ObjectTypeBinding(ot.Name,
typeBindingInfo.Type, ot, fieldBindings);
}
}
return(typeBindings);
}
public override void GenerateTypes(Element parent, Module module, ITypeRegistry registry)
{
base.GenerateTypes(parent, module, registry);
GenerateViewModels(module, module.GetTypes <Aggregate>());
GenerateViewModels(module, module.GetTypes <Entity>());
GenerateViewModels(module, module.GetTypes <Value>());
}
/// <summary>
/// This Operation is called, when the module shall initialize itself.
/// </summary>
/// <param name="typeRegistry">The type registry for service requests or registrations.</param>
/// <inheritdoc/>
public void Initialize(ITypeRegistry typeRegistry)
{
var modelBuilderFactory = typeRegistry.GetObject <IModelBuilderFactory>();
var dataTypeRegistry = typeRegistry.GetObject <IDataTypeRegistry>();
var modelItemNamingService = typeRegistry.GetObject <IModelItemNamingService>();
var odataObjectFactory = typeRegistry.GetObject <IODataObjectFactory>();
var structuralPropertyBinder = new StructuralPropertyBinder();
var navigationPropertyBinder = new NavigationPropertyBinder();
var entityReader = new EntityReader();
var referenceParser = new ReferenceParser(entityReader);
var uncontainedNavigationPropertyParser = new UncontainedNavigationPropertyParser(referenceParser);
var dependencyResolver = new DependencyResolver(uncontainedNavigationPropertyParser);
var entityCreator = new EntityCreator(
structuralPropertyBinder,
navigationPropertyBinder,
uncontainedNavigationPropertyParser,
dependencyResolver);
var entityUpdater = new EntityUpdater(structuralPropertyBinder, navigationPropertyBinder, uncontainedNavigationPropertyParser);
uncontainedNavigationPropertyParser.SetUncontainedEntitiesFactory(entityCreator.CreateInUncontainedNavigationProperty);
typeRegistry.RegisterInstance <IBindableModelBuilderFactory>(new BindableModelBuilderFactory(modelBuilderFactory));
typeRegistry.RegisterInstance <IEntityCreator>(entityCreator);
typeRegistry.RegisterInstance <IEntityReader>(entityReader);
typeRegistry.RegisterInstance <IEntityUpdater>(entityUpdater);
typeRegistry.RegisterInstance <IFactonQueryService>(CreateQueryService(typeRegistry));
typeRegistry.RegisterInstance <IStructuralPropertyFactory>(new StructuralPropertyFactory(dataTypeRegistry, modelItemNamingService));
typeRegistry.RegisterInstance <IODataEntityDtoBuilderFactory>(new ODataEntityDtoBuilderFactory(odataObjectFactory));
}
internal void CompleteInputField(
ITypeRegistry typeRegistry,
Action <SchemaError> reportError,
INamedType parentType)
{
if (!_completed)
{
DeclaringType = parentType;
Type = this.ResolveFieldType <IInputType>(typeRegistry,
reportError, _typeReference);
if (Type != null)
{
CompleteDefaultValue(Type, reportError, parentType);
if (parentType is InputObjectType &&
Property == null &&
typeRegistry.TryGetTypeBinding(parentType, out InputObjectTypeBinding binding) &&
binding.Fields.TryGetValue(Name, out InputFieldBinding fieldBinding))
{
Property = fieldBinding.Property;
}
}
_completed = true;
}
}
private static MetaType ToMetaType(ITypeRegistry registry, MemberType type)
{
return(new MetaType
{
SystemType = type?.SystemType,
Type = registry.Resolve(type?.ReferenceType?.Element)
});
}
public void Initialise(ITypeRegistry registry)
{
registry.RegisterSingleton<IUserRepository, UserRepository>();
registry.RegisterSingleton<IContactFeedRepository, ContactFeedRepository>();
registry.RegisterSingleton<IContactRepository, ContactRepository>();
registry.RegisterType<IProcess, InMemoryRepositoryProcess>("InMemoryRepositoryProcess");
}
public ColumnToPropertyMappingStrategy()
{
if (ServiceLocator.IsInitialised())
{
_typeRegistry = ServiceLocator.Instance.Resolve <ITypeRegistry>();
_mapper = ServiceLocator.Instance.Resolve <IDictionaryToObjectMapper>();
}
}
/// <summary>
/// This Operation is called, when the module shall initialize itself.
/// </summary>
/// <param name="typeRegistry">The type registry for service requests or registrations.</param>
/// <inheritdoc/>
public void Initialize(ITypeRegistry typeRegistry)
{
var metadataService = typeRegistry.GetObject <IMetadataService>();
var oDataObjectFactory = typeRegistry.GetObject <IODataObjectFactory>();
var registry = typeRegistry.GetObject <IDataTypeRegistry>();
RegisterDataTypes(registry, oDataObjectFactory, metadataService);
}
public SchemaSyntaxVisitor(
ITypeRegistry typeRegistry,
IDirectiveRegistry directiveRegistry)
{
_typeRegistry = typeRegistry
?? throw new ArgumentNullException(nameof(typeRegistry));
_directiveRegistry = directiveRegistry
?? throw new ArgumentNullException(nameof(directiveRegistry));
}
public static bool TryGetObjectTypeField(
this ITypeRegistry typeRegistry,
FieldReference fieldReference,
out ObjectField field)
{
field = null;
return(typeRegistry.TryGetType(fieldReference.TypeName, out ObjectType ot) &&
ot.Fields.TryGetField(fieldReference.FieldName, out field));
}
public SchemaSyntaxVisitor(ITypeRegistry typeRegistry)
{
if (typeRegistry == null)
{
throw new ArgumentNullException(nameof(typeRegistry));
}
_typeRegistry = typeRegistry;
}
public void Initialise(ITypeRegistry registry)
{
registry.RegisterType<IAccountContactProvider, FakeGoogleAccountContactProvider>();
registry.RegisterType<ICommunicationProvider, FakeGoogleCommunicationProvider>();
registry.RegisterType<ICalendarProvider, FakeGoogleCalendarProvider>();
registry.RegisterType<IGalleryProvider, FakeGoogleGalleryProvider>();
registry.RegisterType<IContactCollaborationProvider, FakeGoogleContactCollaborationProvider>();
registry.RegisterType<IAccountAuthentication, FakeGoogleAuthentication>("FakeGoogleAuthentication");
}
public SchemaConfiguration(
Action <IServiceProvider> registerServiceProvider,
ITypeRegistry typeRegistry)
{
_registerServiceProvider = registerServiceProvider
?? throw new ArgumentNullException(nameof(registerServiceProvider));
_typeRegistry = typeRegistry
?? throw new ArgumentNullException(nameof(typeRegistry));
}
private void EnqueueUnprocessedTypes(ITypeRegistry types)
{
foreach (INamedType type in types.GetTypes())
{
if (!_registered.Contains(type.Name))
{
_queue.Enqueue(type);
}
}
}
internal void RegisterDependencies(
ITypeRegistry typeRegistry,
Action <SchemaError> reportError,
INamedType parentType)
{
if (_nativeNamedType != null)
{
typeRegistry.RegisterType(_nativeNamedType);
}
}
public DashboardModule(ITypeRegistry typeRegistry, IRegionManager regionManager, ISchedulerProvider schedulerProvider,
Func <IProfileActivatorAggregator> profileActivatorAggregatorFactory,
Func <IProfileDashboardView> profileDashboardViewFactory)
{
_typeRegistry = typeRegistry;
_regionManager = regionManager;
_schedulerProvider = schedulerProvider;
_profileActivatorAggregatorFactory = profileActivatorAggregatorFactory;
_profileDashboardViewFactory = profileDashboardViewFactory;
}
public DashboardModule(ITypeRegistry typeRegistry, IRegionManager regionManager, ISchedulerProvider schedulerProvider,
Func<IProfileActivatorAggregator> profileActivatorAggregatorFactory,
Func<IProfileDashboardView> profileDashboardViewFactory)
{
_typeRegistry = typeRegistry;
_regionManager = regionManager;
_schedulerProvider = schedulerProvider;
_profileActivatorAggregatorFactory = profileActivatorAggregatorFactory;
_profileDashboardViewFactory = profileDashboardViewFactory;
}
/// <summary>
/// This Operation is called, when the module shall initialize itself.
/// </summary>
/// <param name="typeRegistry">The type registry for service requests or registrations.</param>
/// <inheritdoc/>
public void Initialize(ITypeRegistry typeRegistry)
{
var signatureSetInitializer = typeRegistry.GetObject <ISignatureEntitySetInitializer>();
var configurationRegistry = typeRegistry.GetObject <IModelConfigurationRegistry>();
var entityTypeInitializerRegistry = typeRegistry.GetObject <IEntityTypeInitializerRegistry>();
var globalSignatureTypeInitializer = new GlobalSignatureTypeInitializer(signatureSetInitializer);
entityTypeInitializerRegistry.RegisterEntityTypeInitializer(globalSignatureTypeInitializer);
configurationRegistry.RegisterSignatureTypeConfiguration(new SignatureTypeConfiguration("Global", new[] { "globalEntity" }));
}
public virtual void Generate(T type, Element e, ITypeRegistry registry)
{
// Generate properties from associations
GenerateAssociationProperties(type, e, registry);
// Generate properties from attributes
GenerateAttributeProperties(type, e, registry);
// Generate methods from operations
GenerateOperationMethods(type, e, registry);
}
public override void Generate(DomainEvent domainEvent, Element element, ITypeRegistry registry)
{
base.Generate(domainEvent, element, registry);
var association = GetDependency <Aggregate>(element, registry);
if (association != null)
{
domainEvent.Aggregate = association.Value.Type;
}
}
public override void Generate(ViewModel viewModel, Element element, ITypeRegistry registry)
{
base.Generate(viewModel, element, registry);
var dependency = GetDependency <Aggregate>(element, registry);
if (dependency != null)
{
viewModel.Target = dependency.Value.Type;
}
}
public override void Generate(InputModel inputModel, Element element, ITypeRegistry registry)
{
base.Generate(inputModel, element, registry);
var dependency = GetDependency <DomainEvent>(element, registry);
if (dependency != null)
{
inputModel.Source = dependency.Value.Type;
}
}
public override void Generate(Command command, Element element, ITypeRegistry registry)
{
base.Generate(command, element, registry);
var service = GetDependency <Service>(element, registry);
if (service != null)
{
command.Service = service.Value.Type;
command.ServiceMethod = service.Value.Element.Name;
var method = command.Service.Methods.SingleOrDefault(m => m.Name == command.ServiceMethod);
// Try to create service method for corresponding aggregate method
if (method == null && command.Service.AggregateRepository != null)
{
method = command.Service.AggregateRepository.Methods.FirstOrDefault(m => m.Name == command.ServiceMethod);
if (method != null)
{
var serviceMethod = new MetaMethod(method.Name);
// Return aggregate
serviceMethod.AddParameter(new MetaParameter
{
IsReturn = true,
Type = new MetaType {
Type = command.Service.AggregateRepository
}
});
// Don't pass aggregate when the aggregate needs to be constructed...
if (!method.IsConstructor)
{
serviceMethod.AddParameter(new MetaParameter
{
Name = command.Service.AggregateRepository.Name.ToCamelCase(),
Type = new MetaType {
Type = command.Service.AggregateRepository
}
});
}
foreach (var p in method.Parameters)
{
serviceMethod.AddParameter(p);
}
command.Service.Methods.Add(serviceMethod);
}
}
}
}
public void Initialise(ITypeRegistry registry)
{
registry.RegisterSingleton<IEventStoreClient, EventStoreClient>();
registry.RegisterSingleton<IEventStoreConnectionFactory, EventStoreConnectionFactory>();
registry.RegisterSingleton<Accounts.IAccountContactRefresher, Accounts.AccountContactRefresher>();
registry.RegisterSingleton<IContactFeedRepository, Contacts.EventStoreContactFeedRepository>();
registry.RegisterSingleton<IContactRepository, Contacts.EventStoreContactFeedRepository>();//HACK: The EventStore shouldn't be doing this work.
//registry.RegisterType<IAccountContactProvider, Contacts.EventStoreAccountContactProvider>("EventStoreAccountContactProvider");
registry.RegisterSingleton<IUserRepository, Users.UserRepository>();
registry.RegisterType<IProcess, EventStoreProcess>("EventStoreProcess");
}
public void Initialise(ITypeRegistry registry)
{
registry.RegisterType<IAccountContactProvider, GoogleAccountContactProvider>("GoogleContactsProvider");
registry.RegisterType<IAccountAuthentication, GoogleAuthentication>("GoogleAuthentication");
registry.RegisterType<IImapClient, ImapClient>();
registry.RegisterType<IGoogleAccountProvider, GoogleAccountProvider>();
registry.RegisterType<ICommunicationProvider, GmailCommunicationQueryProvider>();
registry.RegisterType<IImapDateTranslator, ImapDateTranslator>();
registry.RegisterType<IGoogleContactProfileTranslator, GoogleContactProfileTranslator>();
registry.RegisterType<IAccountTranslator, AccountTranslator>();
}
public ShellModule(ITypeRegistry typeRegistry)
{
_typeRegistry = typeRegistry;
}
public ToolbarModule(ITypeRegistry typeRegistry, Func<IToolbarController> toolbarControllerFactory)
{
_typeRegistry = typeRegistry;
_toolbarControllerFactory = toolbarControllerFactory;
}
public WelcomeModule(ITypeRegistry typeRegistry, Func<IWelcomeController> welcomeControllerFactory)
{
_typeRegistry = typeRegistry;
_welcomeControllerFactory = welcomeControllerFactory;
}
public SettingsModule(ITypeRegistry registry)
{
_registry = registry;
}
public BluetoothModule(ITypeRegistry registry)
{
_registry = registry;
}
public TypeFilteringService(ITypeRegistry typeRegistry)
{
this.typeRegistry = typeRegistry;
}
public FakeModule(ITypeRegistry typeRegistry)
{
_typeRegistry = typeRegistry;
}
public void Initialise(ITypeRegistry registry)
{
registry.RegisterType<IAccountContactProvider, LinkedInAccountContactProvider>("LinkedInContactsProvider");
registry.RegisterType<IAccountAuthentication, LinkedInAuthentication>("LinkedInAuthentication");
registry.RegisterType<ILinkedInAccountProvider, LinkedInAccountProvider>();
}
