/// <inheritdoc />
        public override void OnBeforeCompleteType(
            ITypeCompletionContext completionContext,
            DefinitionBase?definition,
            IDictionary <string, object?> contextData)
        {
            ISpatialConvention convention = completionContext.GetSpatialConvention();

            if (convention.TransformerFactory.HasCoordinateSystems() &&
                convention.DefaultSrid > 0)
            {
                if (!convention.TransformerFactory.ContainsCoordinateSystem(convention.DefaultSrid))
                {
                    throw ThrowHelper.Transformation_DefaultCRSNotFound(convention.DefaultSrid);
                }

                switch (definition)
                {
                case ObjectTypeDefinition def:
                    HandleObjectType(completionContext, def, convention);
                    break;

                case InputObjectTypeDefinition def:
                    HandleInputObjectType(completionContext, def, convention);
                    break;

                case DirectiveTypeDefinition def:
                    HandleDirectiveType(completionContext, def, convention);
                    break;
                }
            }
        }
Example #2
0
 private static void HandleDirectiveType(
     ITypeCompletionContext completionContext,
     DirectiveTypeDefinition definition,
     ISpatialConvention convention)
 {
     foreach (var arg in definition.Arguments)
     {
         if (completionContext.IsNamedType <IGeoJsonInputType>(arg.Type))
         {
             arg.Formatters.Add(
                 new GeometryTransformerInputFormatter(
                     convention.TransformerFactory,
                     convention.DefaultSrid));
         }
     }
 }
Example #3
0
 private static void HandleInputObjectType(
     ITypeCompletionContext completionContext,
     InputObjectTypeDefinition definition,
     ISpatialConvention convention)
 {
     foreach (var field in definition.Fields)
     {
         if (completionContext.IsNamedType <IGeoJsonInputType>(field.Type))
         {
             field.Formatters.Add(
                 new GeometryTransformerInputFormatter(
                     convention.TransformerFactory,
                     convention.DefaultSrid));
         }
     }
 }
        private static void HandleObjectType(
            ITypeCompletionContext completionContext,
            ObjectTypeDefinition definition,
            ISpatialConvention convention)
        {
            foreach (var field in definition.Fields)
            {
                foreach (var arg in field.Arguments)
                {
                    if (arg.Type is not null &&
                        completionContext.IsNamedType <IGeoJsonInputType>(arg.Type))
                    {
                        arg.Formatters.Add(
                            new GeometryTransformerInputFormatter(
                                convention.TransformerFactory,
                                convention.DefaultSrid));
                    }
                }

                if (field.Type is not null &&
                    completionContext.IsNamedType <IGeoJsonObjectType>(field.Type))
                {
                    var argument =
                        ArgumentDescriptor.New(
                            completionContext.DescriptorContext,
                            CrsFieldName);

                    argument
                    .Type <IntType>()
                    .Description(Transformation_Argument_Crs_Description);

                    field.Arguments.Add(argument.CreateDefinition());
                    field.MiddlewareDefinitions.Insert(0,
                                                       new(FieldClassMiddlewareFactory.Create <GeometryTransformationMiddleware>(
                                                               (typeof(IGeometryTransformerFactory), convention.TransformerFactory),
                                                               (typeof(int), convention.DefaultSrid))));
                }
            }
        }