public string InsertUser(string Username,string Mailid)
        {
            string Result = "a";
            DBManager DbObj=new DBManager();

            DbParameter[] dbparms = new DbParameter[2];

            dbparms[0] = DbObj.CreateParameter("@Username", Username);
            dbparms[1] = DbObj.CreateParameter("@UserMail", Mailid);
            Result = DbObj.ExecuteScalar("InsertUser", dbparms, CommandType.StoredProcedure).ToString();

            return Result;
        }

 public void Save()
 {
     DBManager db = new DBManager();
     db.Connect();
     db.Insert(String.Format("insert into product_image VALUES (null,'{0}','{1}','{2}')", productID, url, orderOfDisplay));
     db.Close();
 }

        public EditParametersForm(DBManager aDBManager)
        {
            InitializeComponent();
            mDBManager = aDBManager;
            if (mDBManager.AlgorithmParameters == null)
            {
                mDBManager.AlgorithmParameters = new AlgorithmParameters();
            }

            ControlGroups.Add(new Control[] { firstLow, firstMedium, firstHigh});
            ControlGroups.Add(new Control[] { secondLow, secondMedium, secondHigh });
            ControlGroups.Add(new Control[] { thirdLow, thirdMedium, thirdHigh });
            ControlGroups.Add(new Control[] { fourthLow, fourthMedium, fourthHigh });
            ControlGroups.Add(new Control[] { fifthLow, fifthMedium, fifthHigh });
            ControlGroups.Add(new Control[] { sixthLow, sixthMedium, sixthHigh });
            ControlGroups.Add(new Control[] { seventhLow, seventhMedium, seventhHigh });

            for (int i = 0; i < 7; i++)
            {
                foreach (var item in ControlGroups[i])
                {
                    item.Enabled = false;
                }
            }
        }

 public void Save()
 {
     DBManager db = new DBManager();
     db.Connect();
     db.Insert(String.Format("insert into size VALUES (null,'{0}')", sizeLabel));
     db.Close();
 }

 public EnableFeatureInfoRec GetFeatureInfo(DBManager dbManager, FeatureType type, string subType)
 {
     using (IDBProvider dbInstance = SP.DB.GetInstance(dbManager))
     {
         return dbInstance._<EnableFeatureAccessor>().SelectInfoByType(GetFeatureTypeKey(type, subType));
     }
 }

        private void InitConfiguration(DBManager dbManager)
        {
            //init vars
            List<APITimeoutConfigRec> tmpConfigList;
            Dictionary<APIG, APITimeoutConfigRec> tmpMapByGroup = new Dictionary<APIG, APITimeoutConfigRec>();

            //get list
            using (IDBProvider dbInstance = SP.DB.GetInstance(dbManager))
            {
                tmpConfigList = dbInstance._<APITimeoutConfigAccessor>().SelectList();
                foreach (var record in tmpConfigList)
                {
                    tmpMapByGroup.Add(record.Type, record);
                }
            }

            //first init (if no data in the database)
            Util.Enum.GetValues<APIG>().ForEach(item =>
                {
                    if (!tmpMapByGroup.ContainsKey(item))
                    {
                        var record = new APITimeoutConfigRec
                            {
                                Type = item,
                                TimeoutMs = DEFAULT_TIMEOUT_MS
                            };
                        tmpConfigList.Add(record);
                        tmpMapByGroup.Add(item, record);
                    }
                });

            //result
            Interlocked.Exchange(ref _configList, tmpConfigList);
            Interlocked.Exchange(ref _mapByGroup, tmpMapByGroup);
        }

        public static DataRowCollection SelectFromDB(String query, String database)
        {
            DBManager dbManager = new DBManager();
            MySqlConnection con = null;

            try
            {
                String ip = DBConst.kDbIp;
                con = dbManager.CreateConnection(ip, database);
                con.Open();

                MySqlCommand cmd = new MySqlCommand(query, con);
                MySqlDataAdapter dataAdapter = new MySqlDataAdapter(cmd);

                DataSet ds = new DataSet("data");

                dataAdapter.Fill(ds, "data");
                DataRowCollection drc = ds.Tables["data"].Rows;

                return drc;
            }
            catch (System.Exception ex)
            {
                logger.Warn(ex.ToString());
            }
            finally
            {
                dbManager.Close(con);
            }
            return null;
        }

 public void Save()
 {
     DBManager db = new DBManager();
     db.Connect();
     db.Insert(String.Format("insert into size_map VALUES (null,'{0}','{1}')", productID, sizeID));
     db.Close();
 }

 public void Save()
 {
     DBManager db = new DBManager();
     db.Connect();
     db.Insert(String.Format("insert into product_detail VALUES (null,'{0}')", description));
     db.Close();
 }

        public static int Execute(String query, String database)
        {
            DBManager dbManager = new DBManager();
            MySqlConnection con = null;

            try
            {
                String ip = DBConst.kDbIp;
                con = dbManager.CreateConnection(ip, database);
                con.Open();

                MySqlCommand cmd = new MySqlCommand(query, con);

                int ret = cmd.ExecuteNonQuery();
                return ret;
            }
            catch (System.Exception ex)
            {
                logger.Warn(ex.ToString());
            }
            finally
            {
                dbManager.Close(con);
            }
            return -1;
        }

    public bool checkForErrors(DBManager dbManager)
    {
        //this should wipe error messages first
        removeNotificationsByType(typeof(NotifyError));

        foreach (Supervillain s in dbManager.SupervillainDB.listOfSupervillains()){
            //check for undecided students
            if (s.Age.GetType() == typeof(Student)){
                if (((Student) s.Age).School.GetType() == typeof (Undecided)) {
                    addNotification(new Notification(new NotifyError(),
                        "Assign " + s.SuperhumanName + " a school!"));
                }
            }
            //check for unemployed adults
            else if (s.Age.GetType() == typeof(Adult)) {
                if (((Adult)s.Age).Occupation.GetType() == typeof(Unemployed)) {
                    addNotification(new Notification(new NotifyError(),
                        "Assign " + s.SuperhumanName + " an occupation!"));
                }
            }
        }

        //more than 4 classes in a cirrculum
        //...
        return findErrorNotifications();
    }

 static public DataTable   GetAllDataListCategory()
 {
     String SQL = "select Category, Category from Sch.DesignformDatalist group by category";
     DBManager db = new DBManager();
     return  db.GetDataTableFromSQL(SQL);
     
 }

        public EditGroupsForm(DBManager aDBManager, int classID)
        {
            InitializeComponent();

            mDBManager = aDBManager;
            mClass = mDBManager.Classes[0];
            foreach(var c in mDBManager.Classes){
                if(c.ID == classID){
                    mClass = c;
                    break;
                }
            }

            gridviewGroups.Columns.Add("Име");
            gridviewGroups.AllowAutoSizeColumns = true;
            gridviewGroups.AutoSizeColumnsMode = Telerik.WinControls.UI.GridViewAutoSizeColumnsMode.Fill;
            gridviewGroups.AllowDrop = false;
            gridviewGroups.AllowMultiColumnSorting = false;
            gridviewGroups.AllowDragToGroup = false;
            gridviewGroups.ShowGroupPanel = false;

            try
            {
                foreach (var group in mClass.Groups)
                {
                    gridviewGroups.Rows.Add(group);
                }
            }
            catch {
                mClass.Groups = new List<string>();
            }
        }

        public AddOrEditClassForm(DBManager dbManag)
        {
            InitializeComponent();
            mDBManager = dbManag;

            this.Text = FormTitles.ClassForm.Add;
            mFormState = FormState.AddingNew;

            RadListDataItem dropDownItem = new RadListDataItem("1");
            dropDownItem.Value = 1;
            dropDownItem.Selected = true;
            gradeDropdownlist.Items.Add(dropDownItem);
            for (int i = 2; i <= 12; ++i)
            {
                dropDownItem = new RadListDataItem(i.ToString());
                dropDownItem.Value = i;
                gradeDropdownlist.Items.Add(dropDownItem);
            }

            importTeachersFromTheDatabase();

            changingHeadteacherReadyButton.Visible = false;
            teachersDropdownlist.Visible = false;

            changeHeadTeacherButton.Visible = false;
            changingHeadteacherReadyButton.Visible = true;
            teachersDropdownlist.Visible = true;

            colorPanel.BackColor = RandomColor.GetRandomColor();

            gradeDropdownlist.DropDownStyle = RadDropDownStyle.DropDownList;
            teachersDropdownlist.DropDownStyle = RadDropDownStyle.DropDownList;
        }

        private void AssemblyDetailsForm_Load(object sender, EventArgs e)
        {
            manager = new DBManager(RevitDocument);

            //if (this.IsAdd)
            //{
            //    lblTitle.Text = "";
            //}
            //else
            //{
                toSwap = CurrentAssembly;
            //    lblToSwap.Text = toSwap.AssemblyName;
                loadInformation(toSwap);
            //}
            List<Assembly> fromModel = manager.RetrieveWallInfo();
            //List<Assembly> options = null;
            //if (this.IsAdd)
            //options = manager.getAllAssemblies();
            //options.AddRange(fromModel);

            //else
            //    options = manager.getAssembliesByCode(toSwap.AssemblyCode);
            //if (options != null)
            //{
            //    foreach (Assembly a in options)
            //        cboAlternatives.Items.Add(a);
            //}
        }

 public void Save()
 {
     DBManager db = new DBManager();
     db.Connect();
     db.Insert(String.Format("insert into product VALUES (null,'{0}','{1}','{2}','{3}')", name, collectionID, price, description));
     db.Close();
 }

        private void InitConfiguration(DBManager dbManager)
        {
            var tmpAccountTypeList = new Dictionary<long, List<VendorAccountTypeInfoRec>>();
            var tmpAccessList = new Dictionary<long, List<VendorAccountTypeAccessRec>>();

            using (IDBProvider dbInstance = SP.DB.GetInstance(dbManager))
            {
                var domainList = SP.DomainProvider.Domains;
                foreach (var domainRec in domainList)
                {
                    var domainID = domainRec.DomainID;

                    SP.SessionContext.ExecuteInSystemSessionContext(domainID, () =>
                    {
                        //start tx
                        dbInstance.BeginTransaction();

                        //translock
                        var dummy = Entity<DomainRec>.SelectForUpdate(dbInstance.Get, domainRec.ID);

                        //read config
                        tmpAccountTypeList.Add(domainID, dbInstance._<VendorAccountTypeAccessor>().AccountTypeList());
                        tmpAccessList.Add(domainID, dbInstance._<VendorAccountTypeAccessor>().AccessList());

                        //commit tx
                        dbInstance.CommitTransaction();
                    });
                }
            }

            //result
            Interlocked.Exchange(ref _accountTypeList, tmpAccountTypeList);
            Interlocked.Exchange(ref _accessList, tmpAccessList);
        }

 public static DBManager sharedManager()
 {
     if (_sharedDBManager == null) {
         GameObject obj = new GameObject();
         _sharedDBManager = obj.AddComponent<DBManager>();
     }
     return _sharedDBManager;
 }

 public void Update(DBManager dbManager,List<APITimeoutConfigRec> data)
 {
     //lock to avoid concurrent actions
     lock (_locker)
     {
         UpdateConfiguration(dbManager, data);
     }
 }

 public void Update(DBManager dbManager, List<VendorAccountTypeRec> accountTypeList, List<VendorAccountTypeAccessRec> accessList, string note)
 {
     //lock to avoid concurrent actions
     lock (_locker)
     {
         UpdateConfiguration(dbManager, accountTypeList, accessList, note);
     }
 }