@@ -62,7 +62,7 @@ discard block  | 
                                                    ||
| 62 | 62 | * @param $tablename  | 
                                                        
| 63 | 63 | * @param $con  | 
                                                        
| 64 | 64 | *  | 
                                                        
| 65 | - * @return bool  | 
                                                        |
| 65 | + * @return boolean|null  | 
                                                        |
| 66 | 66 | */  | 
                                                        
| 67 | 67 | public function checkTableExist($table, $con=NULL)  | 
                                                        
| 68 | 68 |      { | 
                                                        
@@ -77,7 +77,7 @@ discard block  | 
                                                    ||
| 77 | 77 | /**  | 
                                                        
| 78 | 78 | * checkTableName Return the table name  | 
                                                        
| 79 | 79 | *  | 
                                                        
| 80 | - * @param $tablename  | 
                                                        |
| 80 | + * @param string|false $tablename  | 
                                                        |
| 81 | 81 | * @param $con  | 
                                                        
| 82 | 82 | *  | 
                                                        
| 83 | 83 | * @return string  | 
                                                        
@@ -98,7 +98,7 @@ discard block  | 
                                                    ||
| 98 | 98 | * checkColumn Check if column exist in table  | 
                                                        
| 99 | 99 | *  | 
                                                        
| 100 | 100 | * @param $tableName  | 
                                                        
| 101 | - * @param $columnName  | 
                                                        |
| 101 | + * @param string $columnName  | 
                                                        |
| 102 | 102 | * @param $con  | 
                                                        
| 103 | 103 | *  | 
                                                        
| 104 | 104 | * @return string  | 
                                                        
@@ -191,6 +191,8 @@ discard block  | 
                                                    ||
| 191 | 191 | /**  | 
                                                        
| 192 | 192 | * selectAllQuery  | 
                                                        
| 193 | 193 | *  | 
                                                        
| 194 | + * @param string $tableName  | 
                                                        |
| 195 | + * @param string $field  | 
                                                        |
| 194 | 196 | * @return string  | 
                                                        
| 195 | 197 | */  | 
                                                        
| 196 | 198 | public static function selectAllQuery($tableName, $field)  | 
                                                        
@@ -226,6 +228,9 @@ discard block  | 
                                                    ||
| 226 | 228 | /**  | 
                                                        
| 227 | 229 | * selectQuery  | 
                                                        
| 228 | 230 | *  | 
                                                        
| 231 | + * @param string $tableName  | 
                                                        |
| 232 | + * @param string $fields  | 
                                                        |
| 233 | + * @param string $connection  | 
                                                        |
| 229 | 234 | * @return string  | 
                                                        
| 230 | 235 | */  | 
                                                        
| 231 | 236 | public static function selectQuery($tableName, $fields, $data, $condition, $connection)  | 
                                                        
@@ -253,6 +258,7 @@ discard block  | 
                                                    ||
| 253 | 258 | /**  | 
                                                        
| 254 | 259 | * insertQuery  | 
                                                        
| 255 | 260 | *  | 
                                                        
| 261 | + * @param string $tableName  | 
                                                        |
| 256 | 262 | * @return string  | 
                                                        
| 257 | 263 | */  | 
                                                        
| 258 | 264 | public function insertQuery($tableName)  | 
                                                        
@@ -270,6 +276,7 @@ discard block  | 
                                                    ||
| 270 | 276 | /**  | 
                                                        
| 271 | 277 | * updateQuery  | 
                                                        
| 272 | 278 | *  | 
                                                        
| 279 | + * @param string $tableName  | 
                                                        |
| 273 | 280 | * @return string  | 
                                                        
| 274 | 281 | */  | 
                                                        
| 275 | 282 | public function updateQuery($tableName)  | 
                                                        
@@ -49,7 +49,7 @@ discard block  | 
                                                    ||
| 49 | 49 | */  | 
                                                        
| 50 | 50 | protected static function checkConnection($con)  | 
                                                        
| 51 | 51 |      { | 
                                                        
| 52 | - if( $con === null )  | 
                                                        |
| 52 | + if ($con === null)  | 
                                                        |
| 53 | 53 |          { | 
                                                        
| 54 | 54 | $con = self::connect();  | 
                                                        
| 55 | 55 | }  | 
                                                        
@@ -64,11 +64,11 @@ discard block  | 
                                                    ||
| 64 | 64 | *  | 
                                                        
| 65 | 65 | * @return bool  | 
                                                        
| 66 | 66 | */  | 
                                                        
| 67 | - public function checkTableExist($table, $con=NULL)  | 
                                                        |
| 67 | + public function checkTableExist($table, $con = NULL)  | 
                                                        |
| 68 | 68 |      { | 
                                                        
| 69 | 69 | $connection = $this->checkConnection($con);  | 
                                                        
| 70 | 70 |          $query = $connection->query("SELECT 1 FROM {$table} LIMIT 1"); | 
                                                        
| 71 | - if( $query !== false )  | 
                                                        |
| 71 | + if ($query !== false)  | 
                                                        |
| 72 | 72 |          { | 
                                                        
| 73 | 73 | return true;  | 
                                                        
| 74 | 74 | }  | 
                                                        
@@ -82,12 +82,12 @@ discard block  | 
                                                    ||
| 82 | 82 | *  | 
                                                        
| 83 | 83 | * @return string  | 
                                                        
| 84 | 84 | */  | 
                                                        
| 85 | - public static function checkTableName($tableName, $con=NULL)  | 
                                                        |
| 85 | + public static function checkTableName($tableName, $con = NULL)  | 
                                                        |
| 86 | 86 |      { | 
                                                        
| 87 | 87 | $connection = self::checkConnection($con);  | 
                                                        
| 88 | 88 | |
| 89 | 89 |          $query = $connection->query("SELECT 1 FROM {$tableName} LIMIT 1"); | 
                                                        
| 90 | - if( $query !== false )  | 
                                                        |
| 90 | + if ($query !== false)  | 
                                                        |
| 91 | 91 |          { | 
                                                        
| 92 | 92 | return $tableName;  | 
                                                        
| 93 | 93 | }  | 
                                                        
@@ -103,13 +103,13 @@ discard block  | 
                                                    ||
| 103 | 103 | *  | 
                                                        
| 104 | 104 | * @return string  | 
                                                        
| 105 | 105 | */  | 
                                                        
| 106 | - protected static function checkColumn($tableName, $columnName, $con=NULL)  | 
                                                        |
| 106 | + protected static function checkColumn($tableName, $columnName, $con = NULL)  | 
                                                        |
| 107 | 107 |      { | 
                                                        
| 108 | 108 | $connection = self::checkConnection($con);  | 
                                                        
| 109 | 109 | |
| 110 | 110 |              $result = $connection->prepare("SELECT {$columnName} FROM {$tableName}"); | 
                                                        
| 111 | 111 | $result->execute();  | 
                                                        
| 112 | - if ( ! $result->columnCount() )  | 
                                                        |
| 112 | + if ( ! $result->columnCount())  | 
                                                        |
| 113 | 113 |              { | 
                                                        
| 114 | 114 | throw new ColumnNotExistExeption();  | 
                                                        
| 115 | 115 | }  | 
                                                        
@@ -129,11 +129,11 @@ discard block  | 
                                                    ||
| 129 | 129 | $insertQuery = "";  | 
                                                        
| 130 | 130 | $arraySize = count($data);  | 
                                                        
| 131 | 131 | |
| 132 | - foreach ( $data as $key => $value )  | 
                                                        |
| 132 | + foreach ($data as $key => $value)  | 
                                                        |
| 133 | 133 |          { | 
                                                        
| 134 | 134 | $counter++;  | 
                                                        
| 135 | 135 | $insertQuery .= self::sanitize($key);  | 
                                                        
| 136 | - if( $arraySize > $counter )  | 
                                                        |
| 136 | + if ($arraySize > $counter)  | 
                                                        |
| 137 | 137 | $insertQuery .= ", ";  | 
                                                        
| 138 | 138 | }  | 
                                                        
| 139 | 139 | return $insertQuery;  | 
                                                        
@@ -152,11 +152,11 @@ discard block  | 
                                                    ||
| 152 | 152 | $insertQuery = "";  | 
                                                        
| 153 | 153 | $arraySize = count($data);  | 
                                                        
| 154 | 154 | |
| 155 | - foreach ( $data as $key => $value )  | 
                                                        |
| 155 | + foreach ($data as $key => $value)  | 
                                                        |
| 156 | 156 |          { | 
                                                        
| 157 | 157 | $counter++;  | 
                                                        
| 158 | - $insertQuery .= "'".self::sanitize($value) ."'";  | 
                                                        |
| 159 | - if( $arraySize > $counter )  | 
                                                        |
| 158 | + $insertQuery .= "'".self::sanitize($value)."'";  | 
                                                        |
| 159 | + if ($arraySize > $counter)  | 
                                                        |
| 160 | 160 | $insertQuery .= ", ";  | 
                                                        
| 161 | 161 | }  | 
                                                        
| 162 | 162 | return $insertQuery;  | 
                                                        
@@ -175,12 +175,12 @@ discard block  | 
                                                    ||
| 175 | 175 | $updateQuery = "";  | 
                                                        
| 176 | 176 | $arraySize = count($data);  | 
                                                        
| 177 | 177 | |
| 178 | - foreach ( $data as $key => $value )  | 
                                                        |
| 178 | + foreach ($data as $key => $value)  | 
                                                        |
| 179 | 179 |          { | 
                                                        
| 180 | 180 | $counter++;  | 
                                                        
| 181 | 181 | $columnName = self::checkColumn($tableName, self::sanitize($key));  | 
                                                        
| 182 | - $updateQuery .= $columnName ." = '".self::sanitize($value)."'";  | 
                                                        |
| 183 | - if ( $arraySize > $counter )  | 
                                                        |
| 182 | + $updateQuery .= $columnName." = '".self::sanitize($value)."'";  | 
                                                        |
| 183 | + if ($arraySize > $counter)  | 
                                                        |
| 184 | 184 |              { | 
                                                        
| 185 | 185 | $updateQuery .= ", ";  | 
                                                        
| 186 | 186 | }  | 
                                                        
@@ -209,14 +209,14 @@ discard block  | 
                                                    ||
| 209 | 209 | $counter = 0;  | 
                                                        
| 210 | 210 | $arraySize = count($data);  | 
                                                        
| 211 | 211 | |
| 212 | - foreach ( $data as $key => $value )  | 
                                                        |
| 212 | + foreach ($data as $key => $value)  | 
                                                        |
| 213 | 213 |          { | 
                                                        
| 214 | 214 | $counter++;  | 
                                                        
| 215 | 215 | $columnName = self::checkColumn($tableName, self::sanitize($key));  | 
                                                        
| 216 | - $where .= $columnName ." = '".self::sanitize($value)."'";  | 
                                                        |
| 217 | - if ( $arraySize > $counter )  | 
                                                        |
| 216 | + $where .= $columnName." = '".self::sanitize($value)."'";  | 
                                                        |
| 217 | + if ($arraySize > $counter)  | 
                                                        |
| 218 | 218 |              { | 
                                                        
| 219 | - $where .= " " . $condition . " ";  | 
                                                        |
| 219 | + $where .= " ".$condition." ";  | 
                                                        |
| 220 | 220 | }  | 
                                                        
| 221 | 221 | }  | 
                                                        
| 222 | 222 | |
@@ -234,16 +234,16 @@ discard block  | 
                                                    ||
| 234 | 234 | try  | 
                                                        
| 235 | 235 |          { | 
                                                        
| 236 | 236 | $arraySize = count($data);  | 
                                                        
| 237 | - if( $arraySize > 1 && $condition == NULL)  | 
                                                        |
| 237 | + if ($arraySize > 1 && $condition == NULL)  | 
                                                        |
| 238 | 238 |              { | 
                                                        
| 239 | 239 | $query = "Please Supply the condition";  | 
                                                        
| 240 | 240 | }  | 
                                                        
| 241 | 241 | else  | 
                                                        
| 242 | 242 |              { | 
                                                        
| 243 | 243 | $columnName = self::whereAndClause($tableName, $data, $condition);  | 
                                                        
| 244 | - $query = "SELECT $fields FROM $tableName WHERE $columnName";  | 
                                                        |
| 244 | + $query = "SELECT $fields FROM $tableName WHERE $columnName";  | 
                                                        |
| 245 | 245 | }  | 
                                                        
| 246 | -        } catch ( PDOException $e ) { | 
                                                        |
| 246 | +        } catch (PDOException $e) { | 
                                                        |
| 247 | 247 | $query = $e->getMessage();  | 
                                                        
| 248 | 248 | }  | 
                                                        
| 249 | 249 | |
@@ -257,7 +257,7 @@ discard block  | 
                                                    ||
| 257 | 257 | */  | 
                                                        
| 258 | 258 | public function insertQuery($tableName)  | 
                                                        
| 259 | 259 |      { | 
                                                        
| 260 | - $data = ( array )$this;  | 
                                                        |
| 260 | + $data = (array)$this;  | 
                                                        |
| 261 | 261 | array_shift($data);  | 
                                                        
| 262 | 262 | |
| 263 | 263 | $columnNames = self::buildColumn($data);  | 
                                                        
@@ -274,11 +274,11 @@ discard block  | 
                                                    ||
| 274 | 274 | */  | 
                                                        
| 275 | 275 | public function updateQuery($tableName)  | 
                                                        
| 276 | 276 |      { | 
                                                        
| 277 | - $data = ( array ) $this;  | 
                                                        |
| 278 | - $data = array_slice ($data, 2);  | 
                                                        |
| 277 | + $data = (array)$this;  | 
                                                        |
| 278 | + $data = array_slice($data, 2);  | 
                                                        |
| 279 | 279 | |
| 280 | 280 | $values = self::buildClause($tableName, $data);  | 
                                                        
| 281 | -        $updateQuery = "UPDATE $tableName SET {$values} WHERE id = ". self::sanitize($this->id); | 
                                                        |
| 281 | +        $updateQuery = "UPDATE $tableName SET {$values} WHERE id = ".self::sanitize($this->id); | 
                                                        |
| 282 | 282 | |
| 283 | 283 | return $updateQuery;  | 
                                                        
| 284 | 284 | }  |