1: <?php
  2: //  ------------------------------------------------------------------------ //
  3: //                XOOPS - PHP Content Management System                      //
  4: //          Copyright (c) 2000-2016 XOOPS Project (www.xoops.org)            //
  5: //                         <http://xoops.org/>                               //
  6: //  ------------------------------------------------------------------------ //
  7: //  This program is free software; you can redistribute it and/or modify     //
  8: //  it under the terms of the GNU General Public License as published by     //
  9: //  the Free Software Foundation; either version 2 of the License, or        //
 10: //  (at your option) any later version.                                      //
 11: //                                                                           //
 12: //  You may not change or alter any portion of this comment or credits       //
 13: //  of supporting developers from this source code or any supporting         //
 14: //  source code which is considered copyrighted (c) material of the          //
 15: //  original comment or credit authors.                                      //
 16: //                                                                           //
 17: //  This program is distributed in the hope that it will be useful,          //
 18: //  but WITHOUT ANY WARRANTY; without even the implied warranty of           //
 19: //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            //
 20: //  GNU General Public License for more details.                             //
 21: //                                                                           //
 22: //  You should have received a copy of the GNU General Public License        //
 23: //  along with this program; if not, write to the Free Software              //
 24: //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA //
 25: //  ------------------------------------------------------------------------ //
 26: include_once XOOPS_ROOT_PATH . '/class/logger/xoopslogger.php';
 27: include_once XOOPS_ROOT_PATH . '/class/xoopsload.php';
 28: include_once XOOPS_ROOT_PATH . '/class/preload.php';
 29: include_once XOOPS_ROOT_PATH . '/class/database/databasefactory.php';
 30: include_once XOOPS_ROOT_PATH . '/class/database/' . XOOPS_DB_TYPE . 'database.php';
 31: include_once XOOPS_ROOT_PATH . '/class/database/sqlutility.php';
 32: 
 33: /**
 34:  * database manager for XOOPS installer
 35:  *
 36:  * @copyright (c) 2000-2016 XOOPS Project (www.xoops.org)
 37:  * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 38:  * @author    Haruki Setoyama  <haruki@planewave.org>
 39:  **/
 40: class Db_manager
 41: {
 42:     public $s_tables = array();
 43:     public $f_tables = array();
 44:     public $db;
 45: 
 46:     /**
 47:      * Db_manager constructor.
 48:      */
 49:     public function __construct()
 50:     {
 51:         $this->db = XoopsDatabaseFactory::getDatabase();
 52:         $this->db->setPrefix(XOOPS_DB_PREFIX);
 53:         $this->db->setLogger(XoopsLogger::getInstance());
 54:     }
 55: 
 56:     /**
 57:      * @return bool
 58:      */
 59:     public function isConnectable()
 60:     {
 61:         $isConnected = ($this->db->connect(false) !== false);
 62:         if (!$isConnected) {
 63:             $_SESSION['error'] = '(' . $this->db->conn->connect_errno . ') ' . $this->db->conn->connect_error;
 64:         }
 65:         return $isConnected;
 66:     }
 67: 
 68:     /**
 69:      * @return bool
 70:      */
 71:     public function dbExists()
 72:     {
 73:         return ($this->db->connect() != false);// ? true : false;
 74:     }
 75: 
 76:     /**
 77:      * @return bool
 78:      */
 79:     public function createDB()
 80:     {
 81:         $this->db->connect(false);
 82: 
 83:         $result = $this->db->query('CREATE DATABASE ' . XOOPS_DB_NAME);
 84: 
 85:         return ($result != false);// ? true : false;
 86:     }
 87: 
 88:     /**
 89:      * @param $sql_file_path
 90:      *
 91:      * @return bool
 92:      */
 93:     public function queryFromFile($sql_file_path)
 94:     {
 95:         $tables = array();
 96: 
 97:         if (!file_exists($sql_file_path)) {
 98:             return false;
 99:         }
100:         $sql_query = trim(fread(fopen($sql_file_path, 'r'), filesize($sql_file_path)));
101:         SqlUtility::splitMySqlFile($pieces, $sql_query);
102:         $this->db->connect();
103:         foreach ($pieces as $piece) {
104:             $piece = trim($piece);
105:             // [0] contains the prefixed query
106:             // [4] contains unprefixed table name
107:             $prefixed_query = SqlUtility::prefixQuery($piece, $this->db->prefix());
108:             if ($prefixed_query != false) {
109:                 $table = $this->db->prefix($prefixed_query[4]);
110:                 if ($prefixed_query[1] === 'CREATE TABLE') {
111:                     if ($this->db->query($prefixed_query[0]) != false) {
112:                         if (!isset($this->s_tables['create'][$table])) {
113:                             $this->s_tables['create'][$table] = 1;
114:                         }
115:                     } else {
116:                         if (!isset($this->f_tables['create'][$table])) {
117:                             $this->f_tables['create'][$table] = 1;
118:                         }
119:                     }
120:                 } elseif ($prefixed_query[1] === 'INSERT INTO') {
121:                     if ($this->db->query($prefixed_query[0]) != false) {
122:                         if (!isset($this->s_tables['insert'][$table])) {
123:                             $this->s_tables['insert'][$table] = 1;
124:                         } else {
125:                             $this->s_tables['insert'][$table]++;
126:                         }
127:                     } else {
128:                         if (!isset($this->f_tables['insert'][$table])) {
129:                             $this->f_tables['insert'][$table] = 1;
130:                         } else {
131:                             $this->f_tables['insert'][$table]++;
132:                         }
133:                     }
134:                 } elseif ($prefixed_query[1] === 'ALTER TABLE') {
135:                     if ($this->db->query($prefixed_query[0]) != false) {
136:                         if (!isset($this->s_tables['alter'][$table])) {
137:                             $this->s_tables['alter'][$table] = 1;
138:                         }
139:                     } else {
140:                         if (!isset($this->s_tables['alter'][$table])) {
141:                             $this->f_tables['alter'][$table] = 1;
142:                         }
143:                     }
144:                 } elseif ($prefixed_query[1] === 'DROP TABLE') {
145:                     if ($this->db->query('DROP TABLE ' . $table) != false) {
146:                         if (!isset($this->s_tables['drop'][$table])) {
147:                             $this->s_tables['drop'][$table] = 1;
148:                         }
149:                     } else {
150:                         if (!isset($this->s_tables['drop'][$table])) {
151:                             $this->f_tables['drop'][$table] = 1;
152:                         }
153:                     }
154:                 }
155:             }
156:         }
157: 
158:         return true;
159:     }
160: 
161:     public $successStrings = array(
162:         'create' => TABLE_CREATED,
163:         'insert' => ROWS_INSERTED,
164:         'alter'  => TABLE_ALTERED,
165:         'drop'   => TABLE_DROPPED);
166:     public $failureStrings = array(
167:         'create' => TABLE_NOT_CREATED,
168:         'insert' => ROWS_FAILED,
169:         'alter'  => TABLE_NOT_ALTERED,
170:         'drop'   => TABLE_NOT_DROPPED);
171: 
172:     /**
173:      * @return string
174:      */
175:     public function report()
176:     {
177:         $commands = array('create', 'insert', 'alter', 'drop');
178:         $content  = '<ul class="log">';
179:         foreach ($commands as $cmd) {
180:             if (!@empty($this->s_tables[$cmd])) {
181:                 foreach ($this->s_tables[$cmd] as $key => $val) {
182:                     $content .= '<li class="success">';
183:                     $content .= ($cmd !== 'insert') ? sprintf($this->successStrings[$cmd], $key) : sprintf($this->successStrings[$cmd], $val, $key);
184:                     $content .= "</li>\n";
185:                 }
186:             }
187:         }
188:         foreach ($commands as $cmd) {
189:             if (!@empty($this->f_tables[$cmd])) {
190:                 foreach ($this->f_tables[$cmd] as $key => $val) {
191:                     $content .= '<li class="failure">';
192:                     $content .= ($cmd !== 'insert') ? sprintf($this->failureStrings[$cmd], $key) : sprintf($this->failureStrings[$cmd], $val, $key);
193:                     $content .= "</li>\n";
194:                 }
195:             }
196:         }
197:         $content .= '</ul>';
198: 
199:         return $content;
200:     }
201: 
202:     /**
203:      * @param $sql
204:      *
205:      * @return mixed
206:      */
207:     public function query($sql)
208:     {
209:         $this->db->connect();
210: 
211:         return $this->db->query($sql);
212:     }
213: 
214:     /**
215:      * @param $table
216:      *
217:      * @return mixed
218:      */
219:     public function prefix($table)
220:     {
221:         $this->db->connect();
222: 
223:         return $this->db->prefix($table);
224:     }
225: 
226:     /**
227:      * @param $ret
228:      *
229:      * @return mixed
230:      */
231:     public function fetchArray($ret)
232:     {
233:         $this->db->connect();
234: 
235:         return $this->db->fetchArray($ret);
236:     }
237: 
238:     /**
239:      * @param $table
240:      * @param $query
241:      *
242:      * @return bool
243:      */
244:     public function insert($table, $query)
245:     {
246:         $this->db->connect();
247:         $table = $this->db->prefix($table);
248:         $query = 'INSERT INTO ' . $table . ' ' . $query;
249:         if (!$this->db->queryF($query)) {
250:             if (!isset($this->f_tables['insert'][$table])) {
251:                 $this->f_tables['insert'][$table] = 1;
252:             } else {
253:                 $this->f_tables['insert'][$table]++;
254:             }
255: 
256:             return false;
257:         } else {
258:             if (!isset($this->s_tables['insert'][$table])) {
259:                 $this->s_tables['insert'][$table] = 1;
260:             } else {
261:                 $this->s_tables['insert'][$table]++;
262:             }
263: 
264:             return $this->db->getInsertId();
265:         }
266:     }
267: 
268:     /**
269:      * @return bool
270:      */
271:     public function isError()
272:     {
273:         return isset($this->f_tables) ? true : false;
274:     }
275: 
276:     /**
277:      * @param $tables
278:      *
279:      * @return array
280:      */
281:     public function deleteTables($tables)
282:     {
283:         $deleted = array();
284:         $this->db->connect();
285:         foreach ($tables as $key => $val) {
286:             if (!$this->db->query('DROP TABLE ' . $this->db->prefix($key))) {
287:                 $deleted[] = $ct;
288:             }
289:         }
290: 
291:         return $deleted;
292:     }
293: 
294:     /**
295:      * @param $table
296:      *
297:      * @return bool
298:      */
299:     public function tableExists($table)
300:     {
301:         $table = trim($table);
302:         $ret   = false;
303:         if ($table != '') {
304:             $this->db->connect();
305:             $sql = 'SELECT COUNT(*) FROM ' . $this->db->prefix($table);
306:             $ret = $this->db->query($sql);
307:             $ret = !empty($ret);  //return false on error or $table not found
308:         }
309: 
310:         return $ret;
311:     }
312: }
313: