Example #1
0
        /// <summary>
        /// Checks if the request is allowable,returns true if it's allowable, else, returns false
        /// </summary>
        /// <param name="request_id">The id of the request in the request table.</param>
        /// <param name="request_type">The type of request,if it's for test,purchase,etc.</param>
        /// <param name="current_user">the current user logged in</param>
        /// <returns>returns true if it's allowable, else, returns false</returns>
        public bool CheckRequest(int request_id, int request_type, int current_user)
        {
            this.request_id   = request_id;
            this.request_type = request_type;

            Query r_que = new Query();

            //query the request table and make sure it's a request that is accepted
            r_que.Get("SELECT * FROM requests WHERE request_id = '" + this.request_id + "' AND accepted = '1'");
            //check if  the query returns true
            if (r_que.CountRows() < 1)
            {
                return(false);
            }
            else
            {//THERE'S A RECORD
                r_que.Record();

                //GET THE PROCESSING REQUEST METHOD.
                Query t_que = new Query();
                //

                string[] r_stuff = this.ProcessingRequests(request_type, "WHERE _editors LIKE '" + request_id + "'");
                //column numbers are different, so to get the exact column for _added_by and _editors,
                int cols = (r_stuff.Length - 1);
                //now loop to get the exact column
                int editors_col = 0;
                int adder_col   = 0;
                int pos         = 0;
                for (int i = cols; i >= 0; i--, pos++)
                {
                    if (pos == 1)
                    {//its the _editors column
                        editors_col = i;
                    }
                    else if (pos == 2)
                    {//its the _added_by column
                        adder_col = i;
                    }
                    if (pos > 2)
                    {
                        break;
                    }
                }

                //check if the the request has exceeded it's allowance.
                int r_amount = Convert.ToInt32(r_que.Result[4]);
                int e_amount = 0;
                //get the value from the editors column

                //search for the id, and check if the id appears more or less time than the amount value in the request table
                Split s = new Split();
                s.Divide(r_que.Result[4], '|');

                for (int i = 0; i < s.Value_array.Length; i++)
                {
                    if (f.Search(s.Value_array[i], r_que.Result[0]) == true)
                    {//The id was found,
                        e_amount += 1;
                    }
                }


                if (e_amount < r_amount)
                {//its still possible, the amount is less than what is allowed
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Example #2
0
        /// <summary>
        /// method for updating a record in a table
        /// </summary>
        /// <param name="table">the name of the table</param>
        /// <param name="columns">the column(s) to be edited.</param>
        /// <param name="values">the value of the column(s) listed</param>
        /// <param name="condition">the conditon, e.g set bla = 'bla' where bla_id = 'bla'</param>
        public void Change(string table, string columns, string[] values, string condition)
        {
            //filter values
            Filter filter = new Filter();

            this.table     = table;
            this.condition = condition;

            //CHECK IF THE column is empty
            string col = string.Empty;

            if (filter.Trim(columns) == "" || filter.Trim(table) == "" || filter.Trim(condition) == "")
            {
                //IT CAN'T BE EMPTY
                if (columns == "")
                {
                    box = new PopUp("Columns can't be empty in the current Change() method.");
                }
                else if (table == "")
                {
                    box = new PopUp("table can't be empty in the current Change() method.");
                }
                else if (condition == "")
                {
                    box = new PopUp("condition can't be empty  in the current Change() method.");
                }
                else
                {
                    box = new PopUp("A value is empty, can't work. I don't even know what is wrong sef, oh, find the problem yourself, i cannot come and be killing myself.");
                }
            }
            else
            {                              //COLUMN HAS SOME VALUES,make sure the number of columns are equal to the number of values
                #region handling the columns stuff
                Split split = new Split(); //divide
                split.Divide(columns, ',');
                //set the start first, we'll accomplish this at the end, under the looping ish.
                //col = bla = 'bla',bla = 'bla';
                //make sure before counting the array, they must not be empty.
                string comma = "";
                //CHECK IF THE COLUMNS LENGTH AND VALUE LENGTH ARE THE SAME.
                if (split.Length == values.Length)
                {
                    //now store
                    for (int i = 0; i < split.Value_array.Length; i++) //keep adding to the col variable with comma
                    {                                                  //actually this is unecessary work, but it's just to make sure
                        int j = 0;
                        if (filter.Trim(split.Value_array[i]) != "")
                        {//NOW THIS IS WHAT MAKES THE CODE USEFUL
                         /*
                          * SOMEONE MIGHT PUT COMMA AT THE END OR IN BETWEEN BY MISTAKE,
                          * AND THAT COULD DESTROY EVERYTHING, THEN THAT
                          * STUPID ERROR STARTS SHOWING AGAIN.
                          * THIS PREVENTS THAT :)
                          */
                         //ADD THE VALUE

                            //FILTER THE VALUES ISH PROPERLY TO INSERT INTO THE QUERY

                            /*
                             * THERE COULD BE SOME CONDITIONS.
                             * the string[] values variable holds values in string, so even if you input a sql functional value like "NOW()"
                             * it will be passed as a string, which would not turn out good, if we don't handle it properly.
                             * so we're going to set up an array that holds functional values to determine when we would remove string nature
                             * what i mean is we'll create an array that holds values of functions in sql command, so when we are looking through
                             * the string[] value values, we can check if any functional sql value is part of the values, by comparing the values
                             * with the values inside the other array that stores functional values
                             */
                            //THE ARRAY THAT STORES THE FUNCTIONAL VALUES, any sql functional values used in queries should be added here. :)
                            // string[] func_val = { "NOW()" };
                            //THE VARIABLE THAT WILL STORE UP string[] value values

                            //NOW WHILE CHECKING THROUGH THE VALUES, ALSO CHECK FOR FUNCTIONAL VALUES TO REMOVE THE QUOTES
                            for (j = 0; j < func_val.Length; j++)
                            {//STORE THE VALUE
                                //CHECK IF THE VALUE ISN'T THE LAST ARRAY SO THAT WE DON'T PUT COMMA IN THE LAST VALUE
                                int calc = values.Length - i;
                                if (calc == 1)//its the last value, remove the comma
                                {
                                    comma = "";
                                }
                                else
                                {
                                    comma = ",";
                                }

                                if (filter.Trim(values[i]).ToUpper() == filter.Trim(func_val[j].ToUpper()) /*making sure they're all uppercase to perfect comparising*/)
                                {//it's a functional value, remove the quotes
                                    col += filter.Trim(split.Value_array[i]) + " = " + filter.Trim(values[i]) + "" + comma;
                                }
                                else
                                {//ITS NOT A FUNCTIONAL value, leave the quotes
                                    col += filter.Trim(split.Value_array[i]) + " = '" + filter.Trim(values[i]) + "'" + comma;
                                }
                            }
                            //reset j to keep checking if the values match the functional values.
                        }
                        else
                        {//do nothing
                        }
                    }

                    #endregion

                    //update
                    string q = "UPDATE " + this.table + " SET " + col + " " + this.condition;
                    //
                    this.Quering(update, q);
                }
                else
                {//THE COLUMN AND VALUE ARE NOT THE SAME, THAT WILL BE AN ISSUE
                    box = new PopUp("Internal Error: the number of columns and the number of values aren't equivalent in the recent Change() Method.");
                }
            }
        }
Example #3
0
        /// <summary>
        /// Converts the date to the format you want
        /// </summary>
        /// <param name="date">the string date you want to change, the default format it recognises is MM/dd/yyyy</param>
        /// <param name="format">the format you want, this recognises the different date formats</param>
        /// <returns>returns the formatted result. :)</returns>
        public string Date(string date, string format)
        {
            string return_date = "";

            //SINCE THE DATE STRING IN CSHARP COMES AS 03/30/2017 12:00:00 AM
            //we have to seperate the year,month and day
            if ((this.Trim(format) == "" || format == null) || (this.Trim(date) == "" || date == null))
            {
                // PopUp p = new PopUp("");
                return_date = date;
            }
            else
            {
                Split fs = new Split();
                fs.Divide(date, ' ');
                //second split
                //FIRST HAS A VALUE OF SPLIT /
                //SECOND HAS A VALUE OF :
                //THIRD IS AM  OR PM.
                int year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0;

                //check the length of the returned array.

                for (int i = 0; i < fs.Value_array.Length; i++)
                {
                    if (fs.Value_array.Length > 0)
                    {
                        Split ffs = new Split();
                        ffs.Divide(fs.Value_array[0], '/');

                        //some laptops formats could be dd/mm/yyyy or mm/dd/yyyy.
                        //so lets see if the first value is greater than 12 so that we know its days, not month
                        int d_or_m = Convert.ToInt32(ffs.Value_array[0]);

                        if (d_or_m > 12)//the first value is days , not month, so forcefully change
                        {
                            month = Convert.ToInt32(ffs.Value_array[1]);
                            day   = Convert.ToInt32(ffs.Value_array[0]);
                        }
                        else//the first value is months, not days
                        {
                            month = Convert.ToInt32(ffs.Value_array[0]);
                            day   = Convert.ToInt32(ffs.Value_array[1]);
                        }
                        /////////////////////////////////////////////////
                        year = Convert.ToInt32(ffs.Value_array[2]);
                        ////////////////////////////////////////////////
                        //SECOND OF FIRST SPLIT
                        if (i == 1)
                        {
                            if (fs.Value_array[i] != "")
                            {
                                Split sfs = new Split();
                                sfs.Divide(fs.Value_array[i], ':');

                                hour   = Convert.ToInt32(sfs.Value_array[0]);
                                minute = Convert.ToInt32(sfs.Value_array[1]);
                                second = Convert.ToInt32(sfs.Value_array[2]);
                            }
                        }
                        //////////////////////////////////////////////////
                    }
                }
                DateTime dt = new DateTime(year, month, day, hour, minute, second);

                return_date = dt.ToString(format);
            }
            return(return_date);
        }
Example #4
0
        /// <summary>
        /// for adding details into the database.
        /// </summary>
        /// <param name="table">The name of the table</param>
        /// <param name="values">the values to be entered using comma as the separator must be exactly the number
        /// of columns entered. this is of type array, so values should be inputed like an array
        /// e.g {"value1","value2","value3"}
        /// </param>
        /// <param name="columns">the columns needed, should be seperated with comma. e.g : name,id...
        /// or you can leave it empty .
        /// </param>
        public void Add(string table, string[] values, string columns = "")
        {
            //filter values
            Filter filter = new Filter();

            this.table = table;
            #region CHECK IF THE column is empty
            //CHECK IF THE column is empty
            string col = string.Empty;

            if (filter.Trim(columns) == "")
            {
                col = "";
            }
            else
            {                              //COLUMN HAS SOME VALUES,make sure the number of columns are equal to the number of values
                #region handling the columns stuff
                Split split = new Split(); //divide
                split.Divide(columns, ',');
                //set the start first, we'll accomplish this at the end, under the looping ish.
                //col = (bla,bla,bla,bla,bla);
                col = "(";
                //now store
                for (int i = 0; i < split.Value_array.Length; i++) //keep adding to the col variable with comma
                {                                                  //actually this is unecessary work, but it's just to make sure
                    if (filter.Trim(split.Value_array[i]) != "")
                    {                                              //NOW THIS IS WHAT MAKES THE CODE USEFUL
                     /*
                      * SOMEONE MIGHT PUT COMMA AT THE END OR IN BETWEEN BY MISTAKE,
                      * AND THAT COULD DESTROY EVERYTHING, THEN THAT
                      * STUPID ERROR STARTS SHOWING AGAIN.
                      * THIS PREVENTS THAT :)
                      */
                     //ADD THE VALUE

                        //CHECK IF THE VALUE ISN'T THE LAST ARRAY SO THAT WE DON'T PUT COMMA IN THE LAST VALUE
                        int calc = split.Value_array.Length - i;
                        if (calc == 1)
                        {//its the last value, don't put the comma
                            col += split.Value_array[i];
                        }
                        else
                        {
                            col += split.Value_array[i] + " , ";
                        }
                    }
                    else
                    {//do nothing
                    }
                }

                col += ") ";
            }


            #endregion


            #endregion

            #region FILTER THE VALUES ISH PROPERLY TO INSERT INTO THE QUERY
            //FILTER THE VALUES ISH PROPERLY TO INSERT INTO THE QUERY

            /*
             * THERE COULD BE SOME CONDITIONS.
             * the string[] values variable holds values in string, so even if you input a sql functional value like "NOW()"
             * it will be passed as a string, which would not turn out good, if we don't handle it properly.
             * so we're going to set up an array that holds functional values to determine when we would remove string nature
             * what i mean is we'll create an array that holds values of functions in sql command, so when we are looking through
             * the string[] value values, we can check if any functional sql value is part of the values, by comparing the values
             * with the values inside the other array that stores functional values
             */
            //THE ARRAY THAT STORES THE FUNCTIONAL VALUES, any sql functional values used in queries should be added here. :)
            // string[] func_val = { "NOW()" };
            //THE VARIABLE THAT WILL STORE UP string[] value values
            string val = "";
            //for storing
            string _func_or_val = "";
            string comma        = ",";
            int    j            = 0;
            //ORDINARY VALUES
            //  string ord_val = "";
            for (int i = 0; i < values.Length; i++)
            {    //start looping through the values to store properly
                //NOW WHILE CHECKING THROUGH THE VALUES, ALSO CHECK FOR FUNCTIONAL VALUES TO REMOVE THE QUOTES
                for (j = 0; j < func_val.Length; j++)
                {    //STORE THE VALUE
                    //check if it's the last value
                    int calc = values.Length - i;
                    if (calc == 1)    //its the last value, remove the comma
                    {
                        comma = "";
                    }
                    else
                    {
                        comma = ",";
                    }

                    if (filter.Trim(values[i]).ToUpper() == filter.Trim(func_val[j].ToUpper()) /*making sure they're all uppercase to perfect comparising*/)
                    {    //it's a functional value, remove the quotes
                        _func_or_val += filter.Trim(values[i]) + comma;
                    }
                    else
                    {    //ITS NOT A FUNCTIONAL value, leave the quotes
                        _func_or_val += "'" + filter.Trim(values[i]) + "'" + comma;
                    }
                }
                //reset j to keep checking if the values match the functional values.
                j = 0;
            }
            #endregion


            //FOR THE VALUES,
            //ADD THE WHOLE RESULTS TOGETHER.
            val = _func_or_val;
            string q = "INSERT INTO " + this.table + col + " VALUES(" + val + ")";
            //CALL IN THE QUERYing method
            this.Quering(insert, q);
        }