/// <summary>
        /// Generates the blocks definition.
        /// </summary>
        /// <returns></returns>
        public string GenerateBlocksValueDefinition()
        {
            var globalVars = "var glbVar=function(workspace){";
            var types      = this.Types()
                             .Where(it => it.Item2 == null)
                             .Select(it => it.Item1)
                             .ToArray();
            string blockText = "";

            foreach (var type in types)
            {
                globalVars += $"workspace.createVariable('var_{type.Name}', '{nameType(type)}');";
                blockText  += $@"{Environment.NewLine}
                
                var blockText_{type.Name} = '<block type=""{nameType(type)}"">';";
                foreach (var item in type.GetProperties())
                {
                    if (item.GetSetMethod() == null)
                    {
                        continue;
                    }
                    var typeProp = item.PropertyType;
                    var existing = ListOfBlockly.BlocklyTypeTranslator(typeProp);
                    if (existing == null)
                    {
                        continue;
                    }

                    var blockShadow = ListOfBlockly.BlocklyTypeBlocks(typeProp);
                    blockText += $@"{Environment.NewLine}
 var blockTextLocalSiteFunctions = '<value name=""val_{item.Name}"">';
blockTextLocalSiteFunctions += '<shadow type=""{blockShadow}"">';";
                    blockText += generateShadow(blockShadow);
                    blockText += $@"
 blockTextLocalSiteFunctions += '</shadow></value>';
 ";
                    blockText += $"blockText_{type.Name} += blockTextLocalSiteFunctions;";
                }
                blockText += $"blockText_{type.Name} += '</block>';";

                blockText += $@"block_{type.Name} = Blockly.Xml.textToDom(blockText_{type.Name});
                xmlList.push(block_{type.Name});";
                blockText += ";";

                blockText += $@"var block_{type.Name}Set='<block type=""variables_set""><field name=""VAR"">var_{type.Name}</field></block>';";
                blockText += $@"block_{type.Name}Set = Blockly.Xml.textToDom(block_{type.Name}Set);
                xmlList.push(block_{type.Name}Set);";
            }
            var strDef = $@"
 var registerValues = function() {{
        var xmlList = [];
        {blockText}
                
return xmlList;
              }};  ";

            globalVars += "}";
            strDef     += globalVars;
            return(strDef);
        }
        /// <summary>
        /// Finds the web API.
        /// </summary>
        /// <returns></returns>
        public ListOfBlockly FindWebAPI()
        {
            var allCommands = new ListOfBlockly();

            //var allAdresses = addresses.ToArray();


            var groups = api.ApiDescriptionGroups;

            foreach (var g in groups.Items)
            {
                foreach (var api in g.Items)
                {
                    //foreach (var adress in allAdresses)
                    {
                        //var ad = new Uri(adress);
                        var v1 = new BlocklyGenerator();
                        v1.NameCommand = api.RelativePath;
                        v1.Verb        = api.HttpMethod ?? "GET";
                        //v1.Host = ad.GetLeftPart(UriPartial.Scheme);
                        v1.RelativeRequestUrl = api.RelativePath;

                        v1.Params = GetParameters(api.ParameterDescriptions.ToArray());
                        var c = api.ActionDescriptor as ControllerActionDescriptor;


                        v1.ReturnType = c?.MethodInfo?.ReturnType;
                        var type = v1.ReturnType;
                        if (type != null && type.IsGenericType)
                        {
                            if (type.IsSubclassOf(typeof(Task)))
                            {
                                type          = type.GetGenericArguments()[0];//TODO: get all
                                v1.ReturnType = type;
                            }
                        }
                        v1.ControllerName = c?.ControllerName;
                        allCommands.Add(v1);
                    }
                }
            }
            return(allCommands);
        }
        internal string GenerateBlocksFunctionsDefinition()
        {
            string blockText = "var blockTextLocalSiteFunctions='';";

            foreach (var cmdAll in this.GroupBy(it => it.ControllerName))
            {
                var key = cmdAll.Key;
                blockText += $"blockTextLocalSiteFunctions += '<category name=\"{key}\">';";
                foreach (var cmd in cmdAll)
                {
                    blockText += $@"{Environment.NewLine}
                        blockTextLocalSiteFunctions += '<block type=""{cmd.nameCommand()}"">';";
                    if (cmd.ExistsParams)
                    {
                        foreach (var param in cmd.Params)
                        {
                            var type     = param.Value.type;
                            var existing = ListOfBlockly.BlocklyTypeTranslator(type);
                            if (existing == null)
                            {
                                var tuple = TypesGenerateArray().FirstOrDefault(it => it.Item1 == type);
                                if (tuple != null)
                                {
                                    var blockShadow = nameType(type);
                                    blockText += $@"{Environment.NewLine}
 blockTextLocalSiteFunctions += '<value name=""val_{param.Key}"">';
blockTextLocalSiteFunctions += '<shadow type=""{blockShadow}"">';";
                                    //blockText += generateShadow(blockShadow);
                                    blockText += $@"
 blockTextLocalSiteFunctions += '</shadow></value>';
 ";
                                }
                            }
                            if (existing != null)
                            {
                                var blockShadow = ListOfBlockly.BlocklyTypeBlocks(type);
                                blockText += $@"{Environment.NewLine}
 blockTextLocalSiteFunctions += '<value name=""val_{param.Key}"">';
blockTextLocalSiteFunctions += '<shadow type=""{blockShadow}"">';";
                                blockText += generateShadow(blockShadow);
                                blockText += $@"
 blockTextLocalSiteFunctions += '</shadow></value>';
 ";
                            }
                        }
                    }
                    blockText += "blockTextLocalSiteFunctions += '</block>';";
                }
                blockText += $"blockTextLocalSiteFunctions+='</category>';";
                //blockText += $"blockText_{key} +='</category>';";
                //blockText += $"xmlList.push(Blockly.Xml.textToDom(blockText_{key}));";
            }
            //blockText += $"console.log(blockTextLocalSiteFunctions);";

            return(blockText);

//            var strDef = $@"
// var registerFunctions = function() {{
//        var xmlList = [];
//        {blockText}

//return xmlList;
//              }}  ";
//            return strDef;
        }