public Task<ILifecycleContext> Execute(ILifecycleContext context)
        {
            OperationFilter = context.OperationFilter ?? Defaults.DefaultOperationFilter;
            OperationParameterFilter = context.OperationParameterFilter ?? Defaults.DefaultOperationParameterFilter;

            var ctx = new LifecycleContext(context)
            {
                State = LifecycleState.Continue
            };

            foreach (var apiOp in ExtractApiOperations(context))
            {
                if (!OperationFilter(apiOp.JObject)) continue;

                NormalizationApiOperation op = ParseOperationData(apiOp);
                op.ApiNamespace = context.ApiNamespace;
                op.ModelNamespace = context.ModelNamespace;

                op.Response.ApiNamespace = context.ApiNamespace;
                op.Response.ModelNamespace = context.ModelNamespace;

                foreach (var param in op.Parameters)
                {
                    param.ApiNamespace = context.ApiNamespace;
                    param.ModelNamespace = context.ModelNamespace;
                }

                ctx.NormalizationContext.Operations.Add(op);
            }

            return Task.FromResult<ILifecycleContext>(ctx);
        }
        public Task<ILifecycleContext> Execute(ILifecycleContext context)
        {
            var json = context.ResourceListingJson;

            if (!json.ContainsKey("apiVersion") == null || string.IsNullOrWhiteSpace((string) json.apiVersion))
                throw new SwaseyException("apiVersion is required");

            if (!json.ContainsKey("swaggerVersion") == null || string.IsNullOrWhiteSpace((string) json.swaggerVersion))
                throw new SwaseyException("swaggerVersion is required");

            if (!json.ContainsKey("apis") == null)
                throw new SwaseyException("apis is required");

            var ctx = new LifecycleContext(context)
            {
                State = LifecycleState.Continue,
                SwaggerVersion = (string) json.swaggerVersion
            };
            ctx.ServiceMetadata = new ServiceMetadata(ctx.ServiceMetadata)
            {
                ApiVersion = (string) json.apiVersion
            };

            foreach (var item in json.apis)
            {
                if (!item.ContainsKey("path") || string.IsNullOrWhiteSpace((string) item.path))
                    throw new SwaseyException("api.path is required");

                ctx.ApiPathJsonMapping.Add((string) item.path, null);
            }

            return Task.FromResult<ILifecycleContext>(ctx);
        }
示例#3
0
        public async Task<ILifecycleContext> Execute(ILifecycleContext context)
        {
            var ctx = new LifecycleContext(context)
            {
                State = LifecycleState.Continue
            };

            var basePath = context.ResourceListingUri;

            foreach (var path in ctx.ApiPathJsonMapping.Keys.ToList())
            {
                var apiUriBuilder = new UriBuilder(basePath);
                apiUriBuilder.Path += new Uri(path, UriKind.Relative);
                var json = await context.Loader(apiUriBuilder.Uri);
                if (string.IsNullOrWhiteSpace(json))
                    throw new SwaseyException("Invalid JSON for api [{0}]: '{1}'", path, json);

                var obj = JSON.DeserializeDynamic(json);
                if (obj == null)
                    throw new SwaseyException("Unable to parse api definition JSON [{0}]: '{1}'", path, json);

                ctx.ApiPathJsonMapping[path] = obj;
            }

            return ctx;
        }
        public Task<ILifecycleContext> Execute(ILifecycleContext context)
        {
            var ctx = new LifecycleContext(context)
            {
                State = LifecycleState.Continue
            };

            foreach (var modelObj in ExtractModels(context))
            {
                var modelType = (string) modelObj.Model.type;
                var isEnum = "enum".Equals(modelType, StringComparison.InvariantCultureIgnoreCase);

                if (isEnum)
                {
                    var model = ParseEnumData(modelObj);
                    model.ApiNamespace = context.ApiNamespace;
                    model.ModelNamespace = context.ModelNamespace;
                    ctx.NormalizationContext.Enums.Add(model);
                }
                else
                {
                    var model = ParseModelData(modelObj);
                    model.ApiNamespace = context.ApiNamespace;
                    model.ModelNamespace = context.ModelNamespace;

                    foreach (var prop in model.Properties)
                    {
                        prop.ApiNamespace = context.ApiNamespace;
                        prop.ModelNamespace = context.ModelNamespace;
                    }

                    ctx.NormalizationContext.Models.Add(model);
                }
            }

            foreach (var model in ctx.NormalizationContext.Models.Where(x => x.RawSubTypes.Any()))
            {
                foreach (var st in model.RawSubTypes)
                {
                    var sm = ctx.NormalizationContext.Models.FirstOrDefault(x => x.Name.Equals(st, StringComparison.InvariantCultureIgnoreCase));
                    if (sm == null) continue;
                    model.SubTypes.Add(sm);
                }
            }

            var enumNames = ctx.NormalizationContext.Enums.Select(x => x.Name).ToList();
            var modelNames = ctx.NormalizationContext.Models.Select(x => x.Name).ToList();

            // Ensure that Enum Properties are properly indicated
            ctx.NormalizationContext.Models
                .SelectMany(x => x.Properties)
                .Where(x => enumNames.Contains(x.TypeName) && !modelNames.Contains(x.TypeName))
                .ToList()
                .ForEach(x => x.IsEnum = true);

            return Task.FromResult<ILifecycleContext>(ctx);
        }
示例#5
0
        public Task<ILifecycleContext> Execute(ILifecycleContext context)
        {
            var serviceDefinition = new ServiceDefinition(context.ServiceDefinition);

            foreach (var normalModel in context.NormalizationContext.Models)
            {
                var normalModelName = new NormalModelName(normalModel.ResourcePath, normalModel.Name);
                _modelNameMaps.Add(normalModelName);

                var modelDef = new ModelDefinition(normalModel.AsMetadata())
                {
                    ContextName = normalModel.ResourceName,
                    Description = normalModel.Description,
                    Name = normalModel.Name.MapDataTypeName(),
                    ResourceName = normalModel.ResourcePath.ResourceNameFromPath()
                };
                normalModelName.New = modelDef.Name;

                modelDef.Properties.AddRange(ExtractModelProperties(normalModel.Properties));

                serviceDefinition.AddModel(modelDef);
            }

            var resourceModelLookup = _modelNameMaps.ToLookup(x => x.ResourcePath);

            // Ensure all Operations refer to the proper model names
            foreach (var op in context.NormalizationContext.Operations)
            {
                if (!resourceModelLookup.Contains(op.ResourcePath)) { continue; }

                var resourceModels = resourceModelLookup[op.ResourcePath].ToList();

                var returnItem = resourceModels.SingleOrDefault(x => op.Response.TypeName.Equals(x.Old));
                if (returnItem != null)
                {
                    op.Response.SetTypeName(returnItem.New);
                }

                foreach (var opParam in op.Parameters)
                {
                    var paramItem = resourceModels.SingleOrDefault(x => opParam.TypeName.Equals(x.Old));
                    if (paramItem != null)
                    {
                        opParam.SetTypeName(paramItem.New);
                    }
                }
            }

            var ctx = new LifecycleContext(context)
            {
                ServiceDefinition = serviceDefinition,
                State = LifecycleState.Continue
            };
            return Task.FromResult<ILifecycleContext>(ctx);
        }
        public Task<ILifecycleContext> Execute(ILifecycleContext context)
        {
            var serviceDefinition = new ServiceDefinition(context.ServiceDefinition);

            foreach (var normalOp in context.NormalizationContext.Operations)
            {
                var op = new OperationDefinition(NormalizeOperationPath(normalOp), normalOp.AsMetadata())
                {
                    ConsumesOctetStream = normalOp.SupportsStreaming,
                    Description = normalOp.Description,
                    HttpMethod = normalOp.HttpMethod,
                    Name = ExtractName(normalOp),
                    ResourceName = normalOp.ResourcePath.ResourceNameFromPath(),
                    Response = NormalizeResponseDefinition(normalOp)
                };

                normalOp.Parameters
                    .Select(NormalizeParameterDefinition)
                    .ToList()
                    .ForEach(x => op.AddParameter(x));

                if (serviceDefinition.Operations.Any(x => x.ResourceName == op.ResourceName && x.Name == op.Name))
                {
                    var pathParams = op.Parameters.Where(x => x.Type == ParameterType.Path && x.IsRequired).OrderBy(x => x.Name);
                    op.Name += string.Join("And", pathParams.Select(x => "By" + x.Name.UCFirst()));
                }

                serviceDefinition.AddOperation(op);
            }

            var ctx = new LifecycleContext(context)
            {
                ServiceDefinition = serviceDefinition,
                State = LifecycleState.Continue
            };
            return Task.FromResult<ILifecycleContext>(ctx);
        }