//delete param
        public static bool DeleteParam(DataSItem parent, DataParam delParam)
        {
            bool res = false;

            if (IsDocLoaded)
            {
                try
                {
                    XmlNode node =
                        ConfigurationDocument.SelectSingleNode(
                            SettingsHelperManager.QueryOfSelectingParametrOfTheProcedureByPval(parent.Value, delParam.Name));

                    if (node == null)
                    {
                        return(false);
                    }

                    node.ParentNode.RemoveChild(node);

                    if (Save())
                    {
                        res = true;
                        ReadAllProcedures();
                    }
                }
                catch
                {
                }
            }
            return(res);
        }
        //add param
        public static bool AddParam(DataSItem parent, DataParam newparam)
        {
            bool res = false;

            if (IsDocLoaded)
            {
                try
                {
                    XmlNode procParent =
                        _doc.SelectSingleNode(SettingsHelperManager.QueryOfSelectinProcedureByValue(parent.Value));

                    if (procParent != null)
                    {
                        procParent.AppendChild(newparam.ToXmlNode());


                        if (Save())
                        {
                            res = true;
                            ReadAllProcedures();
                        }
                    }
                }
                catch
                {
                    return(false);
                }
            }

            return(res);
        }
        //<param name="" type="0" IsOutput="0"/>
        public static DataParam GetparamFromXmlNode(XmlNode node)
        {
            DataParam res = new DataParam();

            res.Name = node.Attributes["name"].Value;
            int type = Convert.ToInt16(node.Attributes["type"].Value);

            res.Type = (CustomSqlTypes)type;
            int a = Convert.ToInt32(node.Attributes["direction"].Value);

            res.Direction = (ParamDirection)a;
            res.Default   = node.Attributes["default"].Value;
            return(res);
        }
        public DataParam GetParamByName(string name)
        {
            DataParam param = null;

            foreach (DataParam prm in _params.Values)
            {
                if (prm.Name.Trim() == name.Trim())
                {
                    return(prm);
                }
            }

            return(param);
        }
        public void AddParam(DataParam param)
        {
            if (_hasReturnParam && param.Direction == ParamDirection.Return)
            {
                throw new ReturnValueUniqueException();
            }

            if (!_hasReturnParam && param.Direction == ParamDirection.Return)
            {
                _hasReturnParam = true;
            }

            if (param.Direction == ParamDirection.Output)
            {
                _outputParams.Add(param.Name, param);
            }

            _params.Add(param.Name, param);
        }
        /*
         * <item name="" schema=""  constr="">
         * <param name="" type="0" IsOutput="0"/>
         * </item>*/
        public void ReadParamsFromXml(XmlNode xmlItem)
        {
            if (xmlItem != null && xmlItem.Name == "item")
            {
                _params.Clear();
                Name = xmlItem.Attributes["name"].Value;
                //  Value = xmlItem.Attributes["value"].Value;
                Schema           = xmlItem.Attributes["schema"].Value;
                ConnectionString = xmlItem.Attributes["constr"].Value;

                if (xmlItem.HasChildNodes)
                {
                    foreach (XmlNode node in xmlItem.ChildNodes)
                    {
                        DataParam prm = new DataParam();
                        prm = DataParam.GetparamFromXmlNode(node);
                        prm.SetParent(this);

                        AddParam(prm);
                    }
                }
            }
        }
        //update param
        public static bool UpdateParam(DataSItem parent, string oldParamname, DataParam unewparam)
        {
            bool res = false;

            if (IsDocLoaded)
            {
                try
                {
                    string  test = SettingsHelperManager.QueryOfSelectingParametrOfTheProcedureByPval(parent.Value, oldParamname);
                    XmlNode node =
                        ConfigurationDocument.SelectSingleNode(test);
                    if (node == null)
                    {
                        return(false);
                    }
                    //<param name="@action_name" type="4" IsOutput="True" default="asdasd" />
                    node.Attributes["name"].Value      = unewparam.Name;
                    node.Attributes["type"].Value      = ((int)unewparam.Type).ToString();
                    node.Attributes["direction"].Value = ((int)unewparam.Direction).ToString();
                    node.Attributes["default"].Value   = unewparam.Default;


                    if (Save())
                    {
                        res = true;
                        ReadAllProcedures();
                    }
                }
                catch
                {
                    return(false);
                }
            }

            return(res);
        }
        //<param name="" type="0" IsOutput="0"/>
        public static bool UpDateProcedureParametr(string procedureVal, string ParamName, DataParam newparam)
        {
            bool res = false;

            if (IsDocLoaded)
            {
                try
                {
                    XmlNode node =
                        ConfigurationDocument.SelectSingleNode(
                            SettingsHelperManager.QueryOfSelectingParametrOfTheProcedureByPval(procedureVal, ParamName));
                    if (node == null)
                    {
                        return(false);
                    }

                    node.Attributes["name"].Value      = newparam.Name;
                    node.Attributes["type"].Value      = ((int)newparam.Type).ToString();
                    node.Attributes["direction"].Value = newparam.Direction.ToString();

                    if (Save())
                    {
                        res = true;
                        ReadAllProcedures();
                    }
                }
                catch
                {
                    return(false);
                }
            }
            return(res);
        }