public NamesStorage(INameValidation nameValidation, INameConverter nameConverter, INameSorter nameSorter)
{
_nameValidation = nameValidation;
_nameConverter = nameConverter;
_names = new List <Name>();
_nameSorter = nameSorter;
}
public ISchema build_schema(INameConverter converter = null, string argument = "Id")
{
var schema = new Schema
{
NameConverter = converter ?? CamelCaseNameConverter.Instance
};
var person = new ObjectGraphType {
Name = "Person"
};
person.Field("Name", new StringGraphType());
var query = new ObjectGraphType {
Name = "Query"
};
query.Field(
"PeRsoN",
person,
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = argument
}),
resolve: ctx => new Person {
Name = "Quinn"
});
schema.Query = query;
return(schema);
}
private SchemaTypes(ISchema schema)
{
_introspectionTypes = CreateIntrospectionTypes(schema.Features.AppliedDirectives, schema.Features.RepeatableDirectives);
_context = new TypeCollectionContext(
type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)),
(name, type, ctx) =>
{
lock (_lock)
{
SetGraphType(name, type);
}
ctx.AddType(name, type, null);
});
// Add introspection types. Note that introspection types rely on the
// CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name)
_nameConverter = CamelCaseNameConverter.Instance;
foreach (var introspectionType in _introspectionTypes.Values)
{
AddType(introspectionType, _context);
}
// set the name converter properly
_nameConverter = schema.NameConverter ?? CamelCaseNameConverter.Instance;
}
public GraphTypesLookup(INameConverter nameConverter)
{
if (nameConverter == null)
{
throw new ArgumentNullException(nameof(nameConverter));
}
_context = new TypeCollectionContext(
type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)),
(name, type, ctx) =>
{
string trimmed = name.TrimGraphQLTypes();
lock (_lock)
{
SetGraphType(trimmed, type);
}
ctx.AddType(trimmed, type, null);
});
// Add introspection types. Note that introspection types rely on the
// CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name)
NameConverter = CamelCaseNameConverter.Instance;
foreach (var introspectionType in _introspectionTypes.Values)
{
AddType(introspectionType, _context);
}
// set the name converter properly
NameConverter = nameConverter;
}
/// <summary>
/// Initalizes a new instance with the specified <see cref="INameConverter"/>.
/// </summary>
public GraphTypesLookup(INameConverter nameConverter)
{
#pragma warning disable IDE0016 // Use 'throw' expression; if this rule is applied here, then the null check is moved to the very end of the method - this is not what we want
if (nameConverter == null)
{
throw new ArgumentNullException(nameof(nameConverter));
}
#pragma warning restore IDE0016
_context = new TypeCollectionContext(
type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)),
(name, type, ctx) =>
{
string trimmed = name.TrimGraphQLTypes();
lock (_lock)
{
SetGraphType(trimmed, type);
}
ctx.AddType(trimmed, type, null);
});
// Add introspection types. Note that introspection types rely on the
// CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name)
NameConverter = CamelCaseNameConverter.Instance;
foreach (var introspectionType in _introspectionTypes.Values)
{
AddType(introspectionType, _context);
}
// set the name converter properly
NameConverter = nameConverter;
}
public DictService(IDictFor dictFor, INameConverter nameConverter, DictSettings settings)
{
_dictFor = dictFor;
_db = DBFactory.CreateDBHelper("Default");
_db.DbNameConverter = null; //不转换字典sql中输出的字段名
_nameConverter = nameConverter;
_settings = settings;
}
public ValueOperation(
[NotNull] Expression expression,
[NotNull] string name,
[NotNull] ISqlDialect dialect,
[NotNull] INameConverter nameConverter
) : base(name, dialect, nameConverter)
{
_expression = expression ?? throw new ArgumentNullException(nameof(expression));
}
public NotOperation(
[NotNull] IAssigmentOperation assigmentOperation,
[NotNull] string name,
[NotNull] ISqlDialect dialect,
[NotNull] INameConverter nameConverter
) : base(name, dialect, nameConverter)
{
_operation = assigmentOperation ?? throw new ArgumentNullException(nameof(assigmentOperation));
}
/// <summary>
/// Initializes a new instance for the specified graph types and directives, and with the specified type resolver and name converter.
/// </summary>
/// <param name="types">A list of graph type instances to register in the lookup table.</param>
/// <param name="directives">A list of directives to register.</param>
/// <param name="resolveType">A delegate which returns an instance of a graph type from its .NET type.</param>
/// <param name="nameConverter">A name converter to use for the specified graph types.</param>
/// <param name="seal">Prevents additional types from being added to the lookup table.</param>
public static GraphTypesLookup Create(
IEnumerable <IGraphType> types,
IEnumerable <DirectiveGraphType> directives,
Func <Type, IGraphType> resolveType,
INameConverter nameConverter,
bool seal = false)
{
var lookup = nameConverter == null ? new GraphTypesLookup() : new GraphTypesLookup(nameConverter);
var ctx = new TypeCollectionContext(t => lookup._builtInScalars.TryGetValue(t, out var graphType) ? graphType : resolveType(t), (name, graphType, context) =>
{
if (lookup[name] == null)
{
lookup.AddType(graphType, context);
}
});
foreach (var type in types)
{
lookup.AddType(type, ctx);
}
// these fields must not have their field names translated by INameConverter; see HandleField
lookup.HandleField(null, lookup.SchemaMetaFieldType, ctx, false);
lookup.HandleField(null, lookup.TypeMetaFieldType, ctx, false);
lookup.HandleField(null, lookup.TypeNameMetaFieldType, ctx, false);
foreach (var directive in directives)
{
if (directive.Arguments == null)
{
continue;
}
foreach (var arg in directive.Arguments)
{
if (arg.ResolvedType != null)
{
lookup.AddTypeIfNotRegistered(arg.ResolvedType, ctx);
arg.ResolvedType = lookup.ConvertTypeReference(directive, arg.ResolvedType);
}
else
{
lookup.AddTypeIfNotRegistered(arg.Type, ctx);
arg.ResolvedType = lookup.BuildNamedType(arg.Type, ctx.ResolveType);
}
}
}
lookup.ApplyTypeReferences();
Debug.Assert(ctx.InFlightRegisteredTypes.Count == 0);
lookup._sealed = seal;
return(lookup);
}
public ParameterRefOperation(
[NotNull] MemberExpression expression,
[NotNull] ISqlDialect dialect,
[NotNull] INameConverter nameConverter
) : base(dialect)
{
_expression = expression ?? throw new ArgumentNullException(nameof(expression));
_nameConverter = nameConverter ?? throw new ArgumentNullException(nameof(nameConverter));
if (_expression.Expression.NodeType != ExpressionType.Parameter)
{
throw new ArgumentException($"Invalid expression type {_expression.Expression.NodeType}", nameof(expression));
}
}
private static string ConvertDirectoryName(string path, INameConverter converter)
{
string parentDirPath = Path.GetDirectoryName(path);
if (parentDirPath == null)
{
throw new Exception("Invalid path to convert!");
}
string dirName = Path.GetFileName(path);
return(Path.Combine(parentDirPath, converter.Convert(dirName)));
}
/// <summary>
/// Sincronizza la strutture delle directory di 2 folder.
/// Specchio da sorgente --> destinazione.
/// </summary>
public static void SyncFolderStructure(string sourceFolderPath, string destinationFolderPath, bool canCreateDestination = false, INameConverter nameConverter = null)
{
INameConverter converter = nameConverter ?? new IdentityNameConverter();
if (Directory.Exists(sourceFolderPath) == false)
{
throw new Exception("Source directory not exist!");
}
string destPath = ConvertDirectoryName(destinationFolderPath, converter);
if (Directory.Exists(destPath) == false)
{
if (canCreateDestination == false)
{
throw new Exception("Destination directory not exist!");
}
else
{
Directory.CreateDirectory(destPath);
}
}
// Recurse into subdirectories of this directory.
List <string> sourceDirectories = Directory.EnumerateDirectories(sourceFolderPath).ToList();
foreach (var dir in sourceDirectories)
{
string directoryName = Path.GetFileName(dir);
if (directoryName == null)
{
continue;
}
SyncFolderStructure(dir, Path.Combine(destinationFolderPath, directoryName), true, converter);
}
// Dopo aver generato tutto elimino le cartelle che non centrano nulla
List <string> newDirectories = Directory.EnumerateDirectories(destPath).ToList();
List <string> localFolderDirectoriesName = sourceDirectories.Select(Path.GetFileName).Select(name => converter.Convert(name)).ToList();
foreach (var dir in newDirectories)
{
bool exists = localFolderDirectoriesName.Contains(Path.GetFileName(dir));
if (exists == false)
{
Directory.Delete(dir);
}
}
}
public NotOperation(
[NotNull] UnaryExpression expression,
[NotNull] string name,
[NotNull] ISqlDialect dialect,
[NotNull] INameConverter nameConverter,
[NotNull] AssigmentParseHelpers assigmentParseHelpers
) : base(name, dialect, nameConverter)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
_operation = assigmentParseHelpers.ParseExpression(expression.Operand.UnwrapConvert(), name, true);
}
public BinaryOperation(
[NotNull] BinaryExpression expression,
[NotNull] Expression originalExpression,
[NotNull] string name,
[NotNull] ISqlDialect dialect,
[NotNull] AssigmentParseHelpers assigmentParseHelpers,
[NotNull] INameConverter nameConverter,
bool skipBrackets
) : base(name, dialect, nameConverter)
{
_expression = expression ?? throw new ArgumentNullException(nameof(expression));
_originalExpression = originalExpression ?? throw new ArgumentNullException(nameof(originalExpression));
_skipBrackets = skipBrackets;
_left = assigmentParseHelpers.ParseExpression(_expression.Left, name);
_right = assigmentParseHelpers.ParseExpression(_expression.Right, name);
}
/// <inheritdoc />
public CustomColumnOperation(
[NotNull] MethodCallExpression expression,
[NotNull] ISqlDialect dialect,
[NotNull] INameConverter nameConverter,
[NotNull] AssigmentParseHelpers assigmentParseHelpers
) : base(null, dialect, nameConverter)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
Name = expression.Arguments[1].NodeType == ExpressionType.Constant
? ((ConstantExpression)expression.Arguments[1]).Value as string
: throw new InvalidOperationException();
_operation = assigmentParseHelpers.ParseExpression(expression.Arguments[2], Name, true);
}
public GraphTypesLookup(INameConverter nameConverter)
{
if (nameConverter == null)
{
throw new ArgumentNullException(nameof(nameConverter));
}
// standard scalars https://graphql.github.io/graphql-spec/June2018/#sec-Scalars
AddType <StringGraphType>();
AddType <BooleanGraphType>();
AddType <FloatGraphType>();
AddType <IntGraphType>();
AddType <IdGraphType>();
// .NET custom scalars
AddType <DateGraphType>();
AddType <DateTimeGraphType>();
AddType <DateTimeOffsetGraphType>();
AddType <TimeSpanSecondsGraphType>();
AddType <TimeSpanMillisecondsGraphType>();
AddType <DecimalGraphType>();
AddType <UriGraphType>();
AddType <GuidGraphType>();
AddType <ShortGraphType>();
AddType <UShortGraphType>();
AddType <UIntGraphType>();
AddType <LongGraphType>();
AddType <BigIntGraphType>();
AddType <ULongGraphType>();
AddType <ByteGraphType>();
AddType <SByteGraphType>();
// Add introspection types. Note that introspection types rely on the
// CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name)
NameConverter = CamelCaseNameConverter.Instance;
AddType <__Schema>();
AddType <__Type>();
AddType <__Directive>();
AddType <__Field>();
AddType <__EnumValue>();
AddType <__InputValue>();
AddType <__TypeKind>();
// set the name converter properly
NameConverter = nameConverter;
}
public SqlGenerator(
[NotNull] ISqlDialect dialect,
[NotNull] INameConverter nameConverter,
[CanBeNull] ILoggerFactory loggerFactory
)
{
if (dialect == null)
{
throw new ArgumentNullException(nameof(dialect));
}
if (nameConverter == null)
{
throw new ArgumentNullException(nameof(nameConverter));
}
_dialect = dialect;
_logger = loggerFactory?.CreateLogger <SqlGenerator>();
_filterParseHelpers = new FilterParseHelpers(_dialect, nameConverter);
_assigmentParseHelpers = new AssigmentParseHelpers(_dialect, nameConverter);
}
/// <summary>
/// Initializes a new instance for the specified schema, and with the specified type resolver.
/// </summary>
/// <param name="schema">A schema for which this instance is created.</param>
/// <param name="serviceProvider">A service provider used to resolve graph types.</param>
public SchemaTypes(ISchema schema, IServiceProvider serviceProvider)
{
if (schema == null)
{
throw new ArgumentNullException(nameof(schema));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
var types = GetSchemaTypes(schema, serviceProvider);
var typeMappingsEnumerable = schema.TypeMappings ?? throw new ArgumentNullException(nameof(schema) + "." + nameof(ISchema.TypeMappings));
var typeMappings = typeMappingsEnumerable is List <(Type, Type)> typeMappingsList ? typeMappingsList : typeMappingsEnumerable.ToList();
var directives = schema.Directives ?? throw new ArgumentNullException(nameof(schema) + "." + nameof(ISchema.Directives));
_typeDictionary = new Dictionary <Type, IGraphType>();
_introspectionTypes = CreateIntrospectionTypes(schema.Features.AppliedDirectives, schema.Features.RepeatableDirectives);
_context = new TypeCollectionContext(
type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)),
(name, type, ctx) =>
{
SetGraphType(name, type);
ctx.AddType(name, type, null);
},
typeMappings);
// Add manually-added scalar types. To allow overriding of built-in scalars, these must be added
// prior to adding any other types (including introspection types).
foreach (var type in types)
{
if (type is ScalarGraphType)
{
AddType(type, _context);
}
}
// Add introspection types. Note that introspection types rely on the
// CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name)
_nameConverter = CamelCaseNameConverter.Instance;
foreach (var introspectionType in _introspectionTypes.Values)
{
AddType(introspectionType, _context);
}
// set the name converter properly
_nameConverter = schema.NameConverter ?? CamelCaseNameConverter.Instance;
var ctx = new TypeCollectionContext(
t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : (IGraphType)serviceProvider.GetRequiredService(t),
(name, graphType, context) =>
{
if (this[name] == null)
{
AddType(graphType, context);
}
},
typeMappings);
foreach (var type in types)
{
if (!(type is ScalarGraphType))
{
AddType(type, ctx);
}
}
// these fields must not have their field names translated by INameConverter; see HandleField
HandleField(null, SchemaMetaFieldType, ctx, false);
HandleField(null, TypeMetaFieldType, ctx, false);
HandleField(null, TypeNameMetaFieldType, ctx, false);
foreach (var directive in directives)
{
if (directive.Arguments?.Count > 0)
{
foreach (var arg in directive.Arguments.List)
{
if (arg.ResolvedType != null)
{
AddTypeIfNotRegistered(arg.ResolvedType, ctx);
arg.ResolvedType = ConvertTypeReference(directive, arg.ResolvedType);
}
else
{
AddTypeIfNotRegistered(arg.Type, ctx);
arg.ResolvedType = BuildNamedType(arg.Type, ctx.ResolveType);
}
}
}
}
ApplyTypeReferences();
Debug.Assert(ctx.InFlightRegisteredTypes.Count == 0);
_typeDictionary = null;
}
public void Initialize()
{
_nameConverter = new DefaultNameConverter();
}
public ConditionConverter(INameConverter nameConverter, IValueConverter valueConverter)
{
NameConverter = nameConverter;
ValueConverter = valueConverter;
}
public ConditionConverter(INameConverter nameConvertor, IValueConverter valueConverter)
: base(nameConvertor, valueConverter)
{
}
public CodeState(INameConverter inConverter, List <string> inUsingList)
{
_converter = inConverter;
_usingList = inUsingList;
}
public static SyncInfo SyncFolderStructureUsingNamespace(Assembly assembly, string destinationFolderPath, INameConverter nameConverter = null)
{
INameConverter converter = nameConverter ?? (INameConverter) new IdentityNameConverter();
string destPath = destinationFolderPath;
if (Directory.Exists(destPath) == false)
{
Directory.CreateDirectory(destPath);
}
// Create a directory for each namespace
List <string> namespaces = assembly.GetNamespaces().ToList();
// Mapping fra un tipo e la sua locazione nel disco
Dictionary <Type, string> typeToFolder = new Dictionary <Type, string>();
// Mapping fra un path ed una lista di tipi
Dictionary <string, List <Type> > folderToTypes = new Dictionary <string, List <Type> >();
List <string> allNewFolders = new List <string>();
char[] separator = { '.' };
StringBuilder pathBuilder = new StringBuilder();
foreach (string ns in namespaces)
{
string[] nsFolders = ns.Split(separator);
pathBuilder.Clear();
pathBuilder.Append(destPath);
foreach (string folder in nsFolders)
{
pathBuilder.Append(Path.DirectorySeparatorChar).Append(converter.Convert(folder));
}
string path = pathBuilder.ToString();
// Calling Create() will not error if the path already exists.
if (Directory.Exists(path) == false)
{
Directory.CreateDirectory(path);
}
// Add the path to the all folders list
allNewFolders.Add(path);
// Mappo i tipi con la cartella e viceversa
List <Type> typesInFolder = assembly.GetTypesInNamespace(ns).ToList();
foreach (Type t in typesInFolder)
{
typeToFolder.Add(t, path);
}
folderToTypes.Add(path, typesInFolder);
}
// Dopo aver generato tutto elimino le cartelle che non centrano nulla
List <string> newDirectories = GetAllSubfoldersPaths(destinationFolderPath);
foreach (var dir in newDirectories)
{
bool exists = allNewFolders.Contains(dir) || allNewFolders.Any(f => f.StartsWith(dir));
if (exists == false)
{
Directory.Delete(dir);
}
}
// Ritorno il risultato del mapping
return(new SyncInfo(destPath, allNewFolders, folderToTypes, typeToFolder));
}
protected AssigmentOperationBase(string name, [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter)
{
Name = name;
_nameConverter = nameConverter ?? throw new ArgumentNullException(nameof(nameConverter));
Dialect = dialect ?? throw new ArgumentNullException(nameof(dialect));
}
// ReSharper restore MemberCanBePrivate.Global
public SqlConverter(INameConverter newNameConverter, IValueConverter newValueConverter, IConditionConverter newConditionConverter)
{
_nameConverter = newNameConverter;
_valueConverter = newValueConverter;
_conditionConverter = newConditionConverter;
}
// ReSharper disable MemberCanBePrivate.Global
protected SqlConverter(INameConverter nameConverter, IValueConverter valueConverter, IConditionConverter conditionConverter = null)
// ReSharper restore MemberCanBePrivate.Global
: base(nameConverter, valueConverter, conditionConverter)
{
}
protected SqlConverter(INameConverter nameConverter, IValueConverter valueConverter, IConditionConverter conditionConverter = null)
: base(nameConverter, valueConverter, conditionConverter ?? new ConditionConverter(nameConverter, valueConverter))
{
}
public IImmutableDictionary <string, object> GetUpdates(INameConverter nameConverter) =>
_set.ToImmutableDictionary(
prop => nameConverter.GetName(prop),
prop => Property.Get(prop, _proxy));
