예제 #1
0
        private string GetSchemaType(ScriptLanguage language)
        {
            if (Schema == null)
            {
                return(Type);
            }
            var result = Schema["$ref"]?.ToObject <string>() ?? null;

            if (result == null)
            {
                return(Type);
            }
            result = result?.Split('/')?.LastOrDefault() ?? null;
            if (Type == "array")
            {
                switch (language)
                {
                case ScriptLanguage.CSharp:
                    return($"List<{QlikApiUtils.GetDotNetType(result)}>");

                case ScriptLanguage.TypeScript:
                    return($"{QlikApiUtils.GetTypeScriptType(result)}[]");

                default:
                    throw new Exception($"Unknown script language {language.ToString()}");
                }
            }
            return(result);
        }
예제 #2
0
        public EngineClass GetMultipleClass()
        {
            try
            {
                var className = $"{Name}Response";
                var result    = new EngineClass()
                {
                    Name = className,
                    Type = "object",
                };
                foreach (var response in Responses)
                {
                    var engineProprty = new EngineProperty()
                    {
                        Name        = response.Name,
                        Description = response.Description,
                        Type        = QlikApiUtils.GetDotNetType(response.GetRealType()),
                        Required    = response.Required,
                        Format      = response.Format,
                    };

                    var serviceType = response.GetServiceType();
                    if (serviceType != null)
                    {
                        engineProprty.Type = serviceType;
                    }
                    result.Properties.Add(engineProprty);
                }
                return(result);
            }
            catch (Exception ex)
            {
                throw new Exception("The method \"GetMultipleClass\" was failed.", ex);
            }
        }
예제 #3
0
        private string GetFormatedEnumBlock(EngineEnum enumObject)
        {
            //enumObject.RenameValues();

            var builder = new StringBuilder();

            builder.Append(QlikApiUtils.Indented($"public enum {enumObject.Name}\r\n", 1));
            builder.AppendLine(QlikApiUtils.Indented("{", 1));
            foreach (var enumValue in enumObject.Values)
            {
                if (enumValue.Value.HasValue)
                {
                    var numValue = $" = {enumValue.Value}";
                    builder.AppendLine(QlikApiUtils.Indented($"{enumValue.Name}{numValue},", 2));
                }
                else
                {
                    builder.AppendLine(QlikApiUtils.Indented($"{enumValue.Name},", 2));
                }

                if (!String.IsNullOrEmpty(enumValue.ShotValue))
                {
                    var shotValue = $"{enumValue.ShotValue} = ";
                    builder.AppendLine(QlikApiUtils.Indented($"{shotValue}{enumValue.Name},", 2));
                }
            }
            builder.AppendLine(QlikApiUtils.Indented("}", 1));
            return(builder.ToString().TrimEnd(',').TrimEnd());
        }
예제 #4
0
        private string GetImplemention(EngineProperty property)
        {
            var result    = new StringBuilder();
            var arrayType = property?.Ref?.Split('/')?.LastOrDefault() ?? null;

            return($" : List<{QlikApiUtils.GetDotNetType(arrayType)}>");
        }
예제 #5
0
        private string GetArrayType()
        {
            if (Items == null)
            {
                return(Type);
            }
            var itemType = Items["type"]?.ToObject <string>() ?? null;

            if (itemType == null)
            {
                return(Type);
            }
            return($"List<{QlikApiUtils.GetDotNetType(itemType)}>");
        }
예제 #6
0
        private string GetSchemaType()
        {
            if (Schema == null)
            {
                return(Type);
            }
            var result = Schema["$ref"]?.ToObject <string>() ?? null;

            if (result == null)
            {
                return(Type);
            }
            result = result?.Split('/')?.LastOrDefault() ?? null;
            if (Type == "array")
            {
                return($"List<{QlikApiUtils.GetDotNetType(result)}>");
            }
            return(result);
        }
예제 #7
0
        private string GetArrayType(ScriptLanguage language)
        {
            if (Items == null)
            {
                return(Type);
            }
            var itemType = Items["type"]?.ToObject <string>() ?? null;

            if (itemType == null)
            {
                return(Type);
            }
            switch (language)
            {
            case ScriptLanguage.CSharp:
                return($"List<{QlikApiUtils.GetDotNetType(itemType)}>");

            case ScriptLanguage.TypeScript:
                return($"{QlikApiUtils.GetTypeScriptType(itemType)}[]");

            default:
                throw new Exception($"Unknown script language {language.ToString()}");
            }
        }
예제 #8
0
        public void SaveToCSharp(QlikApiConfig config, List <IEngineObject> engineObjects, string savePath)
        {
            try
            {
                var enumList    = new List <string>();
                var fileContent = new StringBuilder();
                fileContent.Append($"namespace {config.NamespaceName}");
                fileContent.AppendLine();
                fileContent.AppendLine("{");
                fileContent.AppendLine(QlikApiUtils.Indented("#region Usings", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using System;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using System.ComponentModel;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using System.Collections.Generic;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using Newtonsoft.Json;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using Newtonsoft.Json.Linq;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using System.Threading.Tasks;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using System.Threading;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("using enigma;", 1));
                fileContent.AppendLine(QlikApiUtils.Indented("#endregion", 1));
                fileContent.AppendLine();
                var lineCounter = 0;
                var enumObjects = engineObjects.Where(d => d.EngType == EngineType.ENUM).ToList();
                if (enumObjects.Count > 0)
                {
                    fileContent.AppendLine(QlikApiUtils.Indented("#region Enums", 1));
                    logger.Debug($"Write Enums {enumObjects.Count}");
                    foreach (EngineEnum enumValue in enumObjects)
                    {
                        lineCounter++;
                        var enumResult = GetFormatedEnumBlock(enumValue);
                        fileContent.AppendLine(enumResult);
                        if (lineCounter < enumObjects.Count)
                        {
                            fileContent.AppendLine();
                        }
                    }
                    fileContent.AppendLine(QlikApiUtils.Indented("#endregion", 1));
                    fileContent.AppendLine();
                }
                var interfaceObjects = engineObjects.Where(d => d.EngType == EngineType.INTERFACE).ToList();
                if (interfaceObjects.Count > 0)
                {
                    logger.Debug($"Write Interfaces {interfaceObjects.Count}");
                    fileContent.AppendLine(QlikApiUtils.Indented("#region Interfaces", 1));
                    lineCounter = 0;
                    foreach (EngineInterface interfaceObject in interfaceObjects)
                    {
                        lineCounter++;

                        if (interfaceObject.Name == "IObjectInterface")
                        {
                            continue;
                        }
                        // TODO fix that simple workaround to remove the ObjectInterface

                        //Special for ObjectInterface => Add IObjectInterface
                        var implInterface = String.Empty;
                        if (Config.BaseObjectInterfaceName != interfaceObject.Name)
                        {
                            implInterface = $" : {Config.BaseObjectInterfaceName}";
                        }

                        fileContent.AppendLine(QlikApiUtils.Indented($"public interface {interfaceObject.Name}{implInterface}", 1));
                        fileContent.AppendLine(QlikApiUtils.Indented("{", 1));
                        foreach (var property in interfaceObject.Properties)
                        {
                            fileContent.AppendLine(QlikApiUtils.Indented($"{QlikApiUtils.GetDotNetType(property.Type)} {property.Name} {{ get; set; }}", 2));
                        }
                        foreach (var methodObject in interfaceObject.Methods)
                        {
                            fileContent.AppendLine(GetFormatedMethod(methodObject));
                        }

                        if (Config.BaseObjectInterfaceName == interfaceObject.Name)
                        {
                            fileContent.AppendLine(QlikApiUtils.Indented("event EventHandler Changed;", 2));
                            fileContent.AppendLine(QlikApiUtils.Indented("event EventHandler Closed;", 2));
                            fileContent.AppendLine(QlikApiUtils.Indented("void OnChanged();", 2));
                        }

                        fileContent.AppendLine(QlikApiUtils.Indented("}", 1));
                        if (lineCounter < interfaceObjects.Count)
                        {
                            fileContent.AppendLine();
                        }
                    }
                    fileContent.AppendLine(QlikApiUtils.Indented("#endregion", 2));
                    fileContent.AppendLine();
                }
                var classObjects = engineObjects.Where(d => d.EngType == EngineType.CLASS).ToList();
                if (classObjects.Count > 0)
                {
                    fileContent.AppendLine(QlikApiUtils.Indented("#region Classes", 1));
                    logger.Debug($"Write Classes {classObjects.Count}");
                    lineCounter = 0;
                    var descBuilder = new DescritpionBuilder(Config.UseDescription);
                    foreach (EngineClass classObject in classObjects)
                    {
                        lineCounter++;
                        descBuilder.Summary = classObject.Description;
                        descBuilder.SeeAlso = classObject.SeeAlso;
                        var desc = descBuilder.Generate(1);
                        if (!String.IsNullOrEmpty(desc))
                        {
                            fileContent.AppendLine(desc);
                        }
                        fileContent.AppendLine(QlikApiUtils.Indented($"public class {classObject.Name}<###implements###>", 1));
                        fileContent.AppendLine(QlikApiUtils.Indented("{", 1));
                        if (classObject.Properties.Count > 0)
                        {
                            fileContent.AppendLine(QlikApiUtils.Indented("#region Properties", 2));
                            var propertyCount = 0;
                            foreach (var property in classObject.Properties)
                            {
                                propertyCount++;
                                if (!String.IsNullOrEmpty(property.Description))
                                {
                                    var builder = new DescritpionBuilder(Config.UseDescription)
                                    {
                                        Summary = property.Description,
                                    };
                                    var description = builder.Generate(2);
                                    if (!String.IsNullOrEmpty(description))
                                    {
                                        fileContent.AppendLine(description);
                                    }
                                }

                                var dValue = String.Empty;
                                if (property.Default != null)
                                {
                                    dValue = property.Default.ToLowerInvariant();
                                    if (property.IsEnumType)
                                    {
                                        dValue = GetEnumDefault(property.Type, property.Default);
                                    }
                                    fileContent.AppendLine(QlikApiUtils.Indented($"[DefaultValue({dValue})]", 2));
                                }

                                var implements = String.Empty;
                                var refType    = property.GetRefType();
                                if (classObject.Type == "array")
                                {
                                    implements = GetImplemention(property);
                                    fileContent.Replace("<###implements###>", implements);
                                }
                                else if (property.Type == "array")
                                {
                                    fileContent.AppendLine(QlikApiUtils.Indented($"public List<{QlikApiUtils.GetDotNetType(refType)}> {property.Name} {{ get; set; }}", 2));
                                }
                                else
                                {
                                    var resultType = QlikApiUtils.GetDotNetType(property.Type);
                                    if (!String.IsNullOrEmpty(refType))
                                    {
                                        resultType = refType;
                                    }
                                    var propertyText = QlikApiUtils.Indented($"public {resultType} {property.Name} {{ get; set; }}", 2);
                                    if (property.Default != null)
                                    {
                                        propertyText += $" = {dValue};";
                                    }
                                    fileContent.AppendLine(propertyText);
                                }

                                if (propertyCount < classObject.Properties.Count)
                                {
                                    fileContent.AppendLine();
                                }
                            }
                            fileContent.AppendLine(QlikApiUtils.Indented("#endregion", 2));
                        }
                        fileContent.Replace("<###implements###>", "");
                        fileContent.AppendLine(QlikApiUtils.Indented("}", 1));
                        if (lineCounter < classObjects.Count)
                        {
                            fileContent.AppendLine();
                        }
                    }
                    fileContent.AppendLine(QlikApiUtils.Indented("#endregion", 1));
                }
                fileContent.AppendLine("}");
                var content = fileContent.ToString().Trim();
                File.WriteAllText(savePath, content);
            }
            catch (Exception ex)
            {
                logger.Error(ex, $"The .NET file could not create.");
            }
        }
예제 #9
0
        private string GetFormatedMethod(EngineMethod method)
        {
            var response    = method.Responses.FirstOrDefault() ?? null;
            var descBuilder = new DescritpionBuilder(Config.UseDescription)
            {
                Summary = method.Description,
                SeeAlso = method.SeeAlso,
                Param   = method.Parameters,
            };

            if (response != null)
            {
                descBuilder.Return = response.Description;
            }
            var description = descBuilder.Generate(2);
            var returnType  = "Task";

            if (response != null)
            {
                returnType = $"Task<{QlikApiUtils.GetDotNetType(response.GetRealType())}>";
                var serviceType = response.GetServiceType();
                if (serviceType != null)
                {
                    returnType = $"Task<{serviceType}>";
                }

                if (method?.Responses?.Count > 1 || !Config.UseQlikResponseLogic)
                {
                    logger.Debug($"The method {method?.Name} has {method?.Responses?.Count} responses.");
                    var resultClass = method.GetMultipleClass();
                    EngineObjects.Add(resultClass);
                    returnType = $"Task<{resultClass.Name}>";
                }
            }
            if (method.UseGeneric)
            {
                returnType = "Task<T>";
            }
            var methodBuilder = new StringBuilder();

            if (!String.IsNullOrEmpty(description))
            {
                methodBuilder.AppendLine(description);
            }
            var asyncValue = String.Empty;

            switch (Config.AsyncMode)
            {
            case AsyncMode.NONE:
                asyncValue = String.Empty;
                break;

            case AsyncMode.SHOW:
                asyncValue = "Async";
                break;

            default:
                asyncValue = String.Empty;
                break;
            }
            var cancellationToken = String.Empty;
            var parameter         = new StringBuilder();

            if (method.Parameters.Count > 0)
            {
                //Sort parameters by required
                var parameters = method.Parameters.OrderBy(p => p.Required == false);
                foreach (var para in parameters)
                {
                    var defaultValue = String.Empty;
                    if (!para.Required)
                    {
                        defaultValue = $" = {QlikApiUtils.GetDefaultValue(para.Type, para.Default)}";
                    }
                    parameter.Append($"{QlikApiUtils.GetDotNetType(para.Type)} {para.Name}{defaultValue}, ");
                }
            }
            var parameterValue = parameter.ToString().TrimEnd().TrimEnd(',');

            if (Config.GenerateCancelationToken)
            {
                if (String.IsNullOrEmpty(parameterValue.Trim()))
                {
                    cancellationToken = "CancellationToken? token = null";
                }
                else
                {
                    cancellationToken = ", CancellationToken? token = null";
                }
            }
            if (method.Deprecated)
            {
                methodBuilder.AppendLine(QlikApiUtils.Indented("[ObsoleteAttribute]", 2));
            }
            var tvalue = String.Empty;

            if (method.UseGeneric)
            {
                tvalue = "<T>";
            }
            methodBuilder.AppendLine(QlikApiUtils.Indented($"{returnType} {method.Name}{asyncValue}{tvalue}({parameterValue}{cancellationToken});", 2));
            return(methodBuilder.ToString());
        }