Пример #1
0
        private FluentDefinitionOrUpdateStage FirstDefintionStage(IOrderedEnumerable <FluentModelParentRefMemberVariable> parentRefMemberVariables)
        {
            var pVariables = parentRefMemberVariables
                             .Where(pref => !pref.ParentRefName.Equals(this.FluentMethodGroup.LocalNameInPascalCase, StringComparison.OrdinalIgnoreCase));

            string ancestorWitherSuffix         = FluentMethodGroup.ParentFluentMethodGroup.SingularJavaInterfaceName;
            FluentDefinitionOrUpdateStage stage = new FluentDefinitionOrUpdateStage(this.resourceName, $"With{ancestorWitherSuffix}");

            List <IModelTypeJv> paramTypes              = new List <IModelTypeJv>();
            List <string>       declarations            = new List <string>();
            StringBuilder       setParentRefLocalParams = new StringBuilder();

            var commentFor = new Dictionary <string, string>();

            foreach (var parentRefVar in pVariables)
            {
                commentFor.Add(parentRefVar.VariableName, parentRefVar.FromParameter.Documentation);
                declarations.Add($"{parentRefVar.VariableTypeName} {parentRefVar.VariableName}");
                paramTypes.Add(parentRefVar.VariableType);
                setParentRefLocalParams.AppendLine($"{parentRefVar.VariableAccessor} = {parentRefVar.VariableName};");
            }

            string methodName          = $"withExisting{ancestorWitherSuffix}";
            string methodParameterDecl = string.Join(", ", declarations);

            stage.Methods.Add(new FluentDefinitionOrUpdateStageMethod(methodName, methodParameterDecl, paramTypes)
            {
                CommentFor = commentFor,
                Body       = setParentRefLocalParams.ToString()
            });
            return(stage);
        }
Пример #2
0
        /// <summary>
        /// Derive and return optional definition stages from the create member variables.
        /// </summary>
        protected List <FluentDefinitionOrUpdateStage> OptionalDefinitionStages(List <FluentDefinitionOrUpdateStage> initialStages)
        {
            if (this.optDefStages != null)
            {
                return(this.optDefStages);
            }

            this.optDefStages = new List <FluentDefinitionOrUpdateStage>();
            if (!this.SupportsCreating)
            {
                return(this.optDefStages);
            }

            var dmvs = this.disambiguatedMemberVariables ?? throw new ArgumentNullException("dMemberVariables");

            var payloadInnerModelVariable = this.CompositePayloadVariable;

            // Stages for setting optional properties of "create body payload"
            //
            if (payloadInnerModelVariable != null)
            {
                string payloadInnerModelVariableName = payloadInnerModelVariable.VariableName;

                CompositeTypeJvaf payloadType = (CompositeTypeJvaf)payloadInnerModelVariable.FromParameter.ClientType;

                var payloadOptinalProperties = payloadType
                                               .ComposedProperties
                                               .Where(p => !p.IsReadOnly && !p.IsRequired)
                                               .Where(p => !propertiesOfPayloadToSkip.Contains(p.Name.ToString(), StringComparer.OrdinalIgnoreCase))
                                               .OrderBy(p => p.Name.ToLowerInvariant());

                FluentDefinitionOrUpdateStage creatableStage = new FluentDefinitionOrUpdateStage(this.resourceName, "WithCreate");
                foreach (Property pro in payloadOptinalProperties)
                {
                    string methodName          = $"with{pro.Name.ToPascalCase()}";
                    string parameterName       = pro.Name;
                    string methodParameterDecl = $"{pro.ModelTypeName} {parameterName}";
                    FluentDefinitionOrUpdateStageMethod method = new FluentDefinitionOrUpdateStageMethod(methodName, methodParameterDecl, pro.ModelType as IModelTypeJv)
                    {
                        CommentFor = new Dictionary <string, string> {
                            { parameterName, pro.Documentation }
                        },
                        Body = $"{(dmvs.MemeberVariablesForCreate[payloadInnerModelVariableName]).VariableAccessor}.{methodName}({parameterName});"
                    };

                    string interfaceName = $"With{pro.Name.ToPascalCase()}";
                    FluentDefinitionOrUpdateStage stage = new FluentDefinitionOrUpdateStage(this.resourceName, interfaceName);
                    this.optDefStages.Add(stage);

                    stage.Methods.Add(method);
                    stage.Methods.ForEach(m =>
                    {
                        m.NextStage = creatableStage;
                    });
                }
            }
            return(this.optDefStages);
        }
Пример #3
0
        /// <summary>
        /// Prepare and return the initial defintion stages that exposes methods to specify the ancestors of the 'Non-Groupable TopLevel Resource'.
        /// </summary>
        /// <param name="parentRefMemberVariables">the member vaiables that corrosonds to ancestors of the resource</param>
        /// <returns></returns>
        private List <FluentDefinitionOrUpdateStage> FirstDefintionStages(IOrderedEnumerable <FluentModelParentRefMemberVariable> parentRefMemberVariables)
        {
            var dmvs = this.DisambiguatedMemberVariables ?? throw new ArgumentNullException("dMemberVariables");

            List <FluentDefinitionOrUpdateStage> initalStages = new List <FluentDefinitionOrUpdateStage>();
            FluentDefinitionOrUpdateStage        currentStage = null;

            foreach (FluentModelParentRefMemberVariable memberVariable in parentRefMemberVariables)
            {
                if (memberVariable.ParentRefName.EqualsIgnoreCase(this.FluentMethodGroup.LocalNameInPascalCase))
                {
                    // Exclude self from parent ref member variables
                    continue;
                }
                else
                {
                    string methodName          = $"with{memberVariable.FromParameter.Name.ToPascalCase()}";
                    string parameterName       = memberVariable.VariableName;
                    string methodParameterDecl = $"{memberVariable.VariableTypeName} {parameterName}";
                    FluentDefinitionOrUpdateStageMethod method = new FluentDefinitionOrUpdateStageMethod(methodName, methodParameterDecl, memberVariable.VariableType)
                    {
                        CommentFor = new Dictionary <string, string> {
                            { parameterName, memberVariable.FromParameter.Documentation }
                        },
                        Body = $"{(dmvs.MemeberVariablesForCreate[memberVariable.VariableName]).VariableAccessor} = {parameterName};"
                    };

                    string interfaceName = $"With{memberVariable.FromParameter.Name.ToPascalCase()}";
                    FluentDefinitionOrUpdateStage nextStage = new FluentDefinitionOrUpdateStage(this.resourceName, interfaceName);
                    //
                    initalStages.Add(nextStage);
                    //
                    nextStage.Methods.Add(method);
                    //
                    if (currentStage != null)
                    {
                        currentStage.Methods.ForEach(m =>
                        {
                            m.NextStage = nextStage;
                        });
                    }
                    currentStage = nextStage;
                }
            }
            return(initalStages);
        }
Пример #4
0
        /// <summary>
        /// Derive and return required definition stages from the create member variables.
        /// </summary>
        protected List <FluentDefinitionOrUpdateStage> RequiredDefinitionStages(List <FluentDefinitionOrUpdateStage> initialStages)
        {
            if (this.reqDefStages != null)
            {
                return(this.reqDefStages);
            }

            this.reqDefStages = new List <FluentDefinitionOrUpdateStage>();
            if (!this.SupportsCreating)
            {
                return(this.reqDefStages);
            }

            var dmvs = this.disambiguatedMemberVariables ?? throw new ArgumentNullException("dMemberVariables");
            FluentDefinitionOrUpdateStage currentStage = null;

            if (initialStages != null)
            {
                this.reqDefStages.AddRange(initialStages);
                currentStage = this.reqDefStages.LastOrDefault();
            }

            // 1. stages for setting create arguments except "create body payload"
            //
            foreach (var memberVariable in this.NotParentRefNotCompositePayloadButPositionalAndOtherMemberVariables)
            {
                string methodName          = $"with{memberVariable.FromParameter.Name.ToPascalCase()}";
                string parameterName       = memberVariable.VariableName;
                string methodParameterDecl = $"{memberVariable.VariableTypeName} {parameterName}";
                FluentDefinitionOrUpdateStageMethod method = new FluentDefinitionOrUpdateStageMethod(methodName, methodParameterDecl, memberVariable.VariableType)
                {
                    CommentFor = new Dictionary <string, string> {
                        { parameterName, memberVariable.FromParameter.Documentation }
                    },
                    Body = $"{(dmvs.MemeberVariablesForCreate[memberVariable.VariableName]).VariableAccessor} = {parameterName};"
                };

                string interfaceName = $"With{memberVariable.FromParameter.Name.ToPascalCase()}";
                FluentDefinitionOrUpdateStage nextStage = new FluentDefinitionOrUpdateStage(this.resourceName, interfaceName);
                this.reqDefStages.Add(nextStage);
                nextStage.Methods.Add(method);
                //
                if (currentStage != null)
                {
                    currentStage.Methods.ForEach(m =>
                    {
                        m.NextStage = nextStage;
                    });
                }
                currentStage = nextStage;
            }

            // 2. stages for setting required properties of "create body composite payload"
            //
            var compositePayloadVariable = this.CompositePayloadVariable;

            if (compositePayloadVariable != null)
            {
                string payloadInnerModelVariableName = compositePayloadVariable.VariableName;

                CompositeTypeJvaf payloadType = (CompositeTypeJvaf)compositePayloadVariable.FromParameter.ClientType;

                var payloadRequiredProperties = payloadType.ComposedProperties
                                                .Where(p => !p.IsReadOnly && p.IsRequired)
                                                .Where(p => !propertiesOfPayloadToSkip.Contains(p.Name.ToString(), StringComparer.OrdinalIgnoreCase))
                                                .OrderBy(p => p.Name.ToLowerInvariant());

                foreach (Property pro in payloadRequiredProperties)
                {
                    string methodName          = $"with{pro.Name.ToPascalCase()}";
                    string parameterName       = pro.Name;
                    string methodParameterDecl = $"{pro.ModelTypeName} {parameterName}";
                    FluentDefinitionOrUpdateStageMethod method = new FluentDefinitionOrUpdateStageMethod(methodName, methodParameterDecl, pro.ModelType as IModelTypeJv)
                    {
                        CommentFor = new Dictionary <string, string> {
                            { parameterName, pro.Documentation }
                        },
                        Body = $"{(dmvs.MemeberVariablesForCreate[payloadInnerModelVariableName]).VariableAccessor}.{methodName}({parameterName});"
                    };

                    string interfaceName = $"With{pro.Name.ToPascalCase()}";
                    FluentDefinitionOrUpdateStage nextStage = new FluentDefinitionOrUpdateStage(this.resourceName, interfaceName);
                    this.reqDefStages.Add(nextStage);

                    nextStage.Methods.Add(method);
                    if (currentStage != null)
                    {
                        currentStage.Methods.ForEach(m =>
                        {
                            m.NextStage = nextStage;
                        });
                    }
                    currentStage = nextStage;
                }
            }

            FluentDefinitionOrUpdateStage creatableStage = new FluentDefinitionOrUpdateStage(this.resourceName, "WithCreate");

            if (currentStage != null)
            {
                currentStage.Methods.ForEach(m =>
                {
                    m.NextStage = creatableStage;
                });
            }
            return(this.reqDefStages);
        }
        /// <summary>
        /// Create and return "Update Stages" from the member variables.
        /// </summary>
        public virtual List <FluentDefinitionOrUpdateStage> UpdateStages()
        {
            if (this.updateStages != null)
            {
                return(this.updateStages);
            }

            this.updateStages = new List <FluentDefinitionOrUpdateStage>();
            if (!this.SupportsUpdating)
            {
                return(this.updateStages);
            }

            var dmvs = this.disambiguatedMemberVariables ?? throw new ArgumentNullException("dMemberVariables");

            FluentDefinitionOrUpdateStage updateGrouping = new FluentDefinitionOrUpdateStage(this.resourceName, "Update");

            // During resource update changing parent ref properties and other path properties are not allowed
            //
            IEnumerable <FluentModelMemberVariable> nonExpandableUpdatableMemberVariables = this.NotParentRefNotPositionalPathAndNotCompositePayloadMemberVariables;

            foreach (var memberVariable in nonExpandableUpdatableMemberVariables)
            {
                string methodName          = $"with{memberVariable.FromParameter.Name.ToPascalCase()}";
                string parameterName       = memberVariable.VariableName;
                string methodParameterDecl = $"{memberVariable.VariableTypeName} {parameterName}";
                FluentDefinitionOrUpdateStageMethod method = new FluentDefinitionOrUpdateStageMethod(methodName, methodParameterDecl, memberVariable.VariableType)
                {
                    CommentFor = new Dictionary <string, string> {
                        { parameterName, memberVariable.FromParameter.Documentation }
                    },
                    Body = $"{(dmvs.MemeberVariablesForUpdate[memberVariable.VariableName]).VariableAccessor} = {parameterName};"
                };

                string interfaceName = $"With{memberVariable.FromParameter.Name.ToPascalCase()}";
                FluentDefinitionOrUpdateStage stage = new FluentDefinitionOrUpdateStage(this.resourceName, interfaceName);
                this.updateStages.Add(stage);

                stage.Methods.Add(method);
                stage.Methods.ForEach(m =>
                {
                    m.NextStage = updateGrouping;
                });
            }

            var payloadInnerModelVariable = this.CompositePayloadVariable;

            if (payloadInnerModelVariable != null)
            {
                string payloadInnerModelVariableName = payloadInnerModelVariable.VariableName;

                CompositeTypeJvaf payloadType = (CompositeTypeJvaf)payloadInnerModelVariable.FromParameter.ClientType;

                var payloadOptionalProperties = payloadType
                                                .ComposedProperties
                                                .Where(p => !p.IsReadOnly && !p.IsRequired)
                                                .Where(p => !propertiesOfPayloadToSkip.Contains(p.Name.ToString(), StringComparer.OrdinalIgnoreCase))
                                                .OrderBy(p => p.Name.ToLowerInvariant());

                foreach (Property pro in payloadOptionalProperties)
                {
                    string methodName          = $"with{pro.Name.ToPascalCase()}";
                    string parameterName       = pro.Name;
                    string methodParameterDecl = $"{pro.ModelTypeName} {parameterName}";
                    FluentDefinitionOrUpdateStageMethod method = new FluentDefinitionOrUpdateStageMethod(methodName, methodParameterDecl, pro.ModelType as IModelTypeJv)
                    {
                        CommentFor = new Dictionary <string, string> {
                            { parameterName, pro.Documentation }
                        },
                        Body = $"{(dmvs.MemeberVariablesForUpdate[payloadInnerModelVariableName]).VariableAccessor}.{methodName}({parameterName});"
                    };

                    string interfaceName = $"With{pro.Name.ToPascalCase()}";
                    FluentDefinitionOrUpdateStage stage = new FluentDefinitionOrUpdateStage(this.resourceName, interfaceName);
                    this.updateStages.Add(stage);

                    stage.Methods.Add(method);
                    stage.Methods.ForEach(m =>
                    {
                        m.NextStage = updateGrouping;
                    });
                }
            }
            return(this.updateStages);
        }