public dynamic repositoryGrab(databaseTable DBT)
 {
     switch (DBT)
     {
         case databaseTable.PrimaryAccount:
             return PAR;
         case databaseTable.Sessions:
             return SR;
         case databaseTable.CoinBank:
             return CBR;
         case databaseTable.TotalCoins:
             return TCR;
         case databaseTable.CoinOrder:
             return COR;
         case databaseTable.Logs:
             return LR;
         default:
             return null;
     }
 }
 public dynamic mapGrab(databaseTable DBT)
 {
     switch (DBT)
     {
         case databaseTable.PrimaryAccount:
             return PAM;
         case databaseTable.Sessions:
             return SM;
         case databaseTable.CoinBank:
             return CBM;
         case databaseTable.TotalCoins:
             return TCM;
         case databaseTable.CoinOrder:
             return COM;
         case databaseTable.Logs:
             return LM;
         default:
             return null;
     }
 }
 public RepoMapConnect(databaseTable DBT)
 {
     CompiledRepositories CR = new CompiledRepositories();
     this.map = CR.mapGrab(DBT);
     this.repo = CR.repositoryGrab(DBT);
 }
Exemple #4
0
    public void insertData(T value, databaseTable dbTable)
    {
        SqlCommand query = new SqlCommand(dbq.insertBuilder(dbTable));

        queryExecution(value, query, dbTable);
    }
Exemple #5
0
 SqlCommand sqlParamPopulate(T value, SqlCommand command, databaseTable dbTable)
 {
     return(gfunc.processTableFunction(dbTable, tableFunction.sqlParamPopulate, value, command));
 }
Exemple #6
0
    internal dynamic processTableFunction(databaseTable dbt, tableFunction tfunc, params dynamic[] args)
    {
        CompiledRepositories CR = new CompiledRepositories();
        dynamic      repo       = CR.repositoryGrab(dbt);
        tableFormats tf         = new tableFormats();

        if (tfunc == tableFunction.paramArray || tfunc == tableFunction.processRow)
        {
            switch (tfunc)
            {
            case tableFunction.processRow:
                return(conversion(repo.populateMap(args[0])));

            case tableFunction.paramArray:
                return(repo.ParamArray);

            default:
                return(conversion(null));
            }
        }
        else
        {
            switch (dbt)
            {
            case databaseTable.PrimaryAccount:
                switch (tfunc)
                {
                case tableFunction.sqlParamPopulate:
                    return(repo.sqlParamPopulate((PrimaryAccountMap)(object)args[0], args[1]));

                case tableFunction.tableFormatChoose:
                    return(conversion(tf.PrimaryAccount()));

                default:
                    return(conversion(null));
                }

            case databaseTable.Sessions:
                switch (tfunc)
                {
                case tableFunction.sqlParamPopulate:
                    return(repo.sqlParamPopulate((SessionsMap)(object)args[0], args[1]));

                case tableFunction.tableFormatChoose:
                    return(conversion(tf.Sessions()));

                default:
                    return(conversion(null));
                }

            case databaseTable.CoinBank:
                switch (tfunc)
                {
                case tableFunction.sqlParamPopulate:
                    return(repo.sqlParamPopulate((CoinBankMap)(object)args[0], args[1]));

                case tableFunction.tableFormatChoose:
                    return(conversion(tf.CoinBank()));

                default:
                    return(conversion(null));
                }

            case databaseTable.TotalCoins:
                switch (tfunc)
                {
                case tableFunction.sqlParamPopulate:
                    return(repo.sqlParamPopulate((TotalCoinsMap)(object)args[0], args[1]));

                case tableFunction.tableFormatChoose:
                    return(conversion(tf.TotalCoins()));

                default:
                    return(conversion(null));
                }

            case databaseTable.CoinOrder:
                switch (tfunc)
                {
                case tableFunction.sqlParamPopulate:
                    return(repo.sqlParamPopulate((CoinOrderMap)(object)args[0], args[1]));

                case tableFunction.tableFormatChoose:
                    return(conversion(tf.CoinOrder()));

                default:
                    return(conversion(null));
                }

            case databaseTable.Logs:
                switch (tfunc)
                {
                case tableFunction.sqlParamPopulate:
                    return(repo.sqlParamPopulate((LogsMap)(object)args[0], args[1]));

                case tableFunction.tableFormatChoose:
                    return(conversion(tf.Logs()));

                default:
                    return(conversion(null));
                }

            default:
                return(conversion(null));
            }
        }
    }