Issues in SqlFile.php (master) - Issues in master - txmodxoops/tdmcreate - Measure and Improve Code Quality continuously with Scrutinizer

Issues (964)

Security Analysis not enabled

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

Header Injection

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

class/Files/Sql/SqlFile.php (1 issue)

Labels

Unused Code 1

Severity

Minor 1

<?php

namespace XoopsModules\Tdmcreate\Files\Sql;

use XoopsModules\Tdmcreate;
use XoopsModules\Tdmcreate\Files;

/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */
/**
 * tdmcreate module.
 *
 * @copyright       XOOPS Project (https://xoops.org)
 * @license         GNU GPL 2 (http://www.gnu.org/licenses/old-licenses/gpl-2.0.html)
 *
 * @since           2.5.0
 *
 * @author          Txmod Xoops http://www.txmodxoops.org
 *
 */

/**
 * Class SqlFile.
 */
class SqlFile extends Files\CreateFile
{
    /**
     * @public function constructor
     *
     * @param null
     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * @static function getInstance
     *
     * @param null
     *
     * @return SqlFile
     */
    public static function getInstance()
    {
        static $instance = false;
        if (!$instance) {
            $instance = new self();
        }

        return $instance;
    }

    /**
     * @public function write
     *
     * @param $module
     * @param $filename
     */
    public function write($module, $filename)
    {
        $this->setModule($module);
        $this->setFileName($filename);
    }

    /**
     * @private function getHeaderSqlComments
     *
     * @param $moduleName
     *
     * @return string
     */
    private function getHeaderSqlComments($moduleName)
    {
        $date          = date('D M d, Y');
        $time          = date('H:i:s');
        $serverName    = \Xmf\Request::getString('SERVER_NAME', '', 'SERVER');
        $serverVersion = $GLOBALS['xoopsDB']->getServerVersion();
        $phpVersion    = PHP_VERSION;
        // Header Sql Comments
        $ret             = null;
        $arrayServerInfo = [
            "# SQL Dump for {$moduleName} module",
            '# PhpMyAdmin Version: 4.0.4',
            '# http://www.phpmyadmin.net',
            '#',
            "# Host: {$serverName}",
            "# Generated on: {$date} to {$time}",
            "# Server version: {$serverVersion}",
            "# PHP Version: {$phpVersion}\n",
        ];
        foreach ($arrayServerInfo as $serverInfo) {
            $ret .= $this->getSimpleString($serverInfo);
        }

        return $ret;
    }

    /**
     * @private function getHeadDatabaseTable
     * @param     $moduleDirname
     * @param     $tableName
     * @param int $fieldsNumb
     *
     *  Unused IF NOT EXISTS
     *
     * @return string
     */
    private function getHeadDatabaseTable($moduleDirname, $tableName, $fieldsNumb)
    {
        $ret          = null;
        $arrayDbTable = [
            '#',
            "# Structure table for `{$moduleDirname}_{$tableName}` {$fieldsNumb}",
            '#',
            "\nCREATE TABLE `{$moduleDirname}_{$tableName}` (",
        ];
        foreach ($arrayDbTable as $dbTable) {
            $ret .= $this->getSimpleString($dbTable);
        }

        return $ret;
    }

    /**
     * @private function getDatabaseTables
     *
     * @param $module
     *
     * @return null|string
     */
    private function getDatabaseTables($module)
    {
        $ret           = null;
        $moduleDirname = mb_strtolower($module->getVar('mod_dirname'));
        $tables        = $this->getTableTables($module->getVar('mod_id'), 'table_order ASC, table_id');
        foreach (array_keys($tables) as $t) {
            $tableId            = $tables[$t]->getVar('table_id');
            $tableMid           = $tables[$t]->getVar('table_mid');
            $tableName          = $tables[$t]->getVar('table_name');
            $tableAutoincrement = $tables[$t]->getVar('table_autoincrement');
            $fieldsNumb         = $tables[$t]->getVar('table_nbfields');
            $ret                .= $this->getDatabaseFields($moduleDirname, $tableMid, $tableId, $tableName, $tableAutoincrement, $fieldsNumb);
        }

        return $ret;
    }

    /**
     * @private function getDatabaseFields
     *
     * @param $moduleDirname
     * @param $tableMid
     * @param $tableId
     * @param $tableName
     * @param $tableAutoincrement
     * @param $fieldsNumb
     * @return null|string
     */
    private function getDatabaseFields($moduleDirname, $tableMid, $tableId, $tableName, $tableAutoincrement, $fieldsNumb)
    {
        $helper        = Tdmcreate\Helper::getInstance();
        $ret           = null;
        $j             = 0;
        $comma         = [];
        $row           = [];
        //$type          = '';
        $fieldTypeName = '';
        $fields = $this->getTableFields($tableMid, $tableId, 'field_id ASC, field_name');
        foreach (array_keys($fields) as $f) {
            // Creation of database table
            $ret            = $this->getHeadDatabaseTable($moduleDirname, $tableName, $fieldsNumb);
            $fieldName      = $fields[$f]->getVar('field_name');
            $fieldType      = $fields[$f]->getVar('field_type');
            $fieldValue     = $fields[$f]->getVar('field_value');
            $fieldAttribute = $fields[$f]->getVar('field_attribute');
            $fieldNull      = $fields[$f]->getVar('field_null');
            $fieldDefault   = $fields[$f]->getVar('field_default');
            $fieldKey       = $fields[$f]->getVar('field_key');
            if ($fieldType > 1) {
                $fType         = $helper->getHandler('Fieldtype')->get($fieldType);
                $fieldTypeName = $fType->getVar('fieldtype_name');
            } else {
                $fieldType = null;
            }
            if ($fieldAttribute > 1) {
                $fAttribute     = $helper->getHandler('Fieldattributes')->get($fieldAttribute);
                $fieldAttribute = $fAttribute->getVar('fieldattribute_name');
            } else {
                $fieldAttribute = null;
            }
            if ($fieldNull > 1) {
                $fNull     = $helper->getHandler('Fieldnull')->get($fieldNull);
                $fieldNull = $fNull->getVar('fieldnull_name');
            } else {
                $fieldNull = null;
            }
            if (!empty($fieldName)) {
                switch ($fieldType) {
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                        $type = $fieldTypeName . '(' . $fieldValue . ')';
                        if (empty($fieldDefault)) {
                            $default = "DEFAULT '0'";
                        } else {
                            $default = "DEFAULT '{$fieldDefault}'";
                        }
                        break;
                    case 6:
                    case 7:
                    case 8:
                        $type = $fieldTypeName . '(' . $fieldValue . ')';
                        if (empty($fieldDefault)) {
                            $default = "DEFAULT '0.00'"; // From MySQL 5.7 Manual
                        } else {
                            $default = "DEFAULT '{$fieldDefault}'";
                        }
                        break;
                    case 9:
                    case 10:
                        $fValues = str_replace(',', "', '", str_replace(' ', '', $fieldValue));
                        $type    = $fieldTypeName . '(\'' . $fValues . '\')'; // Used with comma separator
                        $default = "DEFAULT '{$fieldDefault}'";
                        break;
                    case 11:
                        $type = $fieldTypeName . '(' . $fieldValue . ')';
                        if (empty($fieldDefault)) {
                            $default = "DEFAULT '[email protected]'";
                        } else {
                            $default = "DEFAULT '{$fieldDefault}'";
                        }
                        break;
                    case 12:
                        $type = $fieldTypeName . '(' . $fieldValue . ')';
                        if (empty($fieldDefault)) {
                            $default = "DEFAULT 'http:\\'";
                        } else {
                            $default = "DEFAULT '{$fieldDefault}'";
                        }
                        break;
                    case 13:
                    case 14:
                        $type    = $fieldTypeName . '(' . $fieldValue . ')';
                        $default = "DEFAULT '{$fieldDefault}'";
                        break;
                    case 15:
                    case 16:
                    case 17:
                    case 18:
                        $type    = $fieldTypeName;
                        $default = null;
                        break;
                    case 19:
                    case 20:
                    case 21:
                    case 22:
                        $type    = $fieldTypeName . '(' . $fieldValue . ')';
                        $default = "DEFAULT '{$fieldDefault}'";
                        break;
                    case 23:
                        $type = $fieldTypeName;
                        if (empty($fieldDefault)) {
                            $default = "DEFAULT '1970'"; // From MySQL 5.7 Manual
                        } else {
                            $default = "DEFAULT '{$fieldDefault}'";
                        }
                        break;
                    default:
                        $type    = $fieldTypeName . '(' . $fieldValue . ')';
                        $default = "DEFAULT '{$fieldDefault}'";
                        break;
                }
                if ((0 == $f) && (1 == $tableAutoincrement)) {
                    $row[]     = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, null, 'AUTO_INCREMENT');
                    $comma[$j] = $this->getKey(2, $fieldName);
                    ++$j;
                } elseif ((0 == $f) && (0 == $tableAutoincrement)) {
                    $row[]     = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
                    $comma[$j] = $this->getKey(2, $fieldName);
                    ++$j;
                } else {
                    if (3 == $fieldKey || 4 == $fieldKey || 5 == $fieldKey || 6 == $fieldKey) {
                        switch ($fieldKey) {
                            case 3:
                                $row[]     = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
                                $comma[$j] = $this->getKey(3, $fieldName);
                                ++$j;
                                break;
                            case 4:
                                $row[]     = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
                                $comma[$j] = $this->getKey(4, $fieldName);
                                ++$j;
                                break;
                            case 5:
                                $row[]     = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
                                $comma[$j] = $this->getKey(5, $fieldName);
                                ++$j;
                                break;
                            case 6:
                                $row[]     = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
                                $comma[$j] = $this->getKey(6, $fieldName);
                                ++$j;
                                break;
                        }
                    } else {
                        $row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
                    }
                }
            }
        }
        // ================= COMMA ================= //
        for ($i = 0; $i < $j; ++$i) {
            if ($i != $j - 1) {
                $row[] = $comma[$i] . ',';
            } else {
                $row[] = $comma[$i];
            }
        }
        // ================= COMMA CICLE ================= //
        $ret .= implode("\n", $row);
        unset($j);
        $ret .= $this->getFootDatabaseTable();

        return $ret;
    }

    /**
     * @private function getFootDatabaseTable
     *
     * @param null
     *
     * @return string
     */
    private function getFootDatabaseTable()
    {
        return "\n) ENGINE=InnoDB;\n\n";
    }

    /**
     * @private function getFieldRow
     *
     * @param $fieldName
     * @param $fieldTypeValue
     * @param $fieldAttribute
     * @param $fieldNull
     * @param $fieldDefault
     * @param $autoincrement
     *
     * @return string
     */
    private function getFieldRow($fieldName, $fieldTypeValue, $fieldAttribute = null, $fieldNull = null, $fieldDefault = null, $autoincrement = null)
    {
        $retAutoincrement  = "  `{$fieldName}` {$fieldTypeValue} {$fieldAttribute} {$fieldNull} {$autoincrement},";
        $retFieldAttribute = "  `{$fieldName}` {$fieldTypeValue} {$fieldAttribute} {$fieldNull} {$fieldDefault},";
        $fieldDefault      = "  `{$fieldName}` {$fieldTypeValue} {$fieldNull} {$fieldDefault},";
        $retShort          = "  `{$fieldName}` {$fieldTypeValue},";

        $ret = $retShort;
        if (null != $autoincrement) {
            $ret = $retAutoincrement;
        } elseif (null != $fieldAttribute) {
            $ret = $retFieldAttribute;
        } elseif (null === $fieldAttribute) {
            $ret = $fieldDefault;
        }

        return $ret;
    }

    /**
     * @private function getKey
     *
     * @param $key
     * @param $fieldName
     * @return string
     */
    private function getKey($key, $fieldName)
    {
        $ret = null;
        switch ($key) {
            case 2: // PRIMARY KEY
                $ret = "  PRIMARY KEY (`{$fieldName}`)";
                break;
            case 3: // UNIQUE KEY
                $ret = "  UNIQUE KEY `{$fieldName}` (`{$fieldName}`)";
                break;
            case 4: // KEY
                $ret = "  KEY `{$fieldName}` (`{$fieldName}`)";
                break;
            case 5: // INDEX
                $ret = "  INDEX (`{$fieldName}`)";
                break;
            case 6: // FULLTEXT KEY
                $ret = "  FULLTEXT KEY `{$fieldName}` (`{$fieldName}`)";
                break;
        }

        return $ret;
    }

    /**
     * @private function getComma
     *
     * @param $row
     * @param $comma
     *
     * @return string
     */
    private function getComma($row, $comma = null)

    {
        return " {$row}{$comma}";
    }

    /**
     * @public function render
     *
     * @param null
     *
     * @return bool|string
     */
    public function render()
    {
        $module        = $this->getModule();
        $filename      = $this->getFileName();
        $moduleName    = mb_strtolower($module->getVar('mod_name'));
        $moduleDirname = mb_strtolower($module->getVar('mod_dirname'));
        $content       = $this->getHeaderSqlComments($moduleName);
        $content       .= $this->getDatabaseTables($module);

        $this->create($moduleDirname, 'sql', $filename, $content, _AM_TDMCREATE_FILE_CREATED, _AM_TDMCREATE_FILE_NOTCREATED);

        return $this->renderFile();
    }
}


1			<?php
2
3			namespace XoopsModules\Tdmcreate\Files\Sql;
4
5			use XoopsModules\Tdmcreate;
6			use XoopsModules\Tdmcreate\Files;
7
8			/*
9			You may not change or alter any portion of this comment or credits
10			of supporting developers from this source code or any supporting source code
11			which is considered copyrighted (c) material of the original comment or credit authors.
12
13			This program is distributed in the hope that it will be useful,
14			but WITHOUT ANY WARRANTY; without even the implied warranty of
15			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16			*/
17			/**
18			* tdmcreate module.
19			*
20			* @copyright XOOPS Project (https://xoops.org)
21			* @license GNU GPL 2 (http://www.gnu.org/licenses/old-licenses/gpl-2.0.html)
22			*
23			* @since 2.5.0
24			*
25			* @author Txmod Xoops http://www.txmodxoops.org
26			*
27			*/
28
29			/**
30			* Class SqlFile.
31			*/
32			class SqlFile extends Files\CreateFile
33			{
34			/**
35			* @public function constructor
36			*
37			* @param null
38			*/
39			public function __construct()
40			{
41			parent::__construct();
42			}
43
44			/**
45			* @static function getInstance
46			*
47			* @param null
48			*
49			* @return SqlFile
50			*/
51			public static function getInstance()
52			{
53			static $instance = false;
54			if (!$instance) {
55			$instance = new self();
56			}
57
58			return $instance;
59			}
60
61			/**
62			* @public function write
63			*
64			* @param $module
65			* @param $filename
66			*/
67			public function write($module, $filename)
68			{
69			$this->setModule($module);
70			$this->setFileName($filename);
71			}
72
73			/**
74			* @private function getHeaderSqlComments
75			*
76			* @param $moduleName
77			*
78			* @return string
79			*/
80			private function getHeaderSqlComments($moduleName)
81			{
82			$date = date('D M d, Y');
83			$time = date('H:i:s');
84			$serverName = \Xmf\Request::getString('SERVER_NAME', '', 'SERVER');
85			$serverVersion = $GLOBALS['xoopsDB']->getServerVersion();
86			$phpVersion = PHP_VERSION;
87			// Header Sql Comments
88			$ret = null;
89			$arrayServerInfo = [
90			"# SQL Dump for {$moduleName} module",
91			'# PhpMyAdmin Version: 4.0.4',
92			'# http://www.phpmyadmin.net',
93			'#',
94			"# Host: {$serverName}",
95			"# Generated on: {$date} to {$time}",
96			"# Server version: {$serverVersion}",
97			"# PHP Version: {$phpVersion}\n",
98			];
99			foreach ($arrayServerInfo as $serverInfo) {
100			$ret .= $this->getSimpleString($serverInfo);
101			}
102
103			return $ret;
104			}
105
106			/**
107			* @private function getHeadDatabaseTable
108			* @param $moduleDirname
109			* @param $tableName
110			* @param int $fieldsNumb
111			*
112			* Unused IF NOT EXISTS
113			*
114			* @return string
115			*/
116			private function getHeadDatabaseTable($moduleDirname, $tableName, $fieldsNumb)
117			{
118			$ret = null;
119			$arrayDbTable = [
120			'#',
121			"# Structure table for `{$moduleDirname}_{$tableName}` {$fieldsNumb}",
122			'#',
123			"\nCREATE TABLE `{$moduleDirname}_{$tableName}` (",
124			];
125			foreach ($arrayDbTable as $dbTable) {
126			$ret .= $this->getSimpleString($dbTable);
127			}
128
129			return $ret;
130			}
131
132			/**
133			* @private function getDatabaseTables
134			*
135			* @param $module
136			*
137			* @return null\|string
138			*/
139			private function getDatabaseTables($module)
140			{
141			$ret = null;
142			$moduleDirname = mb_strtolower($module->getVar('mod_dirname'));
143			$tables = $this->getTableTables($module->getVar('mod_id'), 'table_order ASC, table_id');
144			foreach (array_keys($tables) as $t) {
145			$tableId = $tables[$t]->getVar('table_id');
146			$tableMid = $tables[$t]->getVar('table_mid');
147			$tableName = $tables[$t]->getVar('table_name');
148			$tableAutoincrement = $tables[$t]->getVar('table_autoincrement');
149			$fieldsNumb = $tables[$t]->getVar('table_nbfields');
150			$ret .= $this->getDatabaseFields($moduleDirname, $tableMid, $tableId, $tableName, $tableAutoincrement, $fieldsNumb);
151			}
152
153			return $ret;
154			}
155
156			/**
157			* @private function getDatabaseFields
158			*
159			* @param $moduleDirname
160			* @param $tableMid
161			* @param $tableId
162			* @param $tableName
163			* @param $tableAutoincrement
164			* @param $fieldsNumb
165			* @return null\|string
166			*/
167			private function getDatabaseFields($moduleDirname, $tableMid, $tableId, $tableName, $tableAutoincrement, $fieldsNumb)
168			{
169			$helper = Tdmcreate\Helper::getInstance();
170			$ret = null;
171			$j = 0;
172			$comma = [];
173			$row = [];
174			//$type = '';
175			$fieldTypeName = '';
176			$fields = $this->getTableFields($tableMid, $tableId, 'field_id ASC, field_name');
177			foreach (array_keys($fields) as $f) {
178			// Creation of database table
179			$ret = $this->getHeadDatabaseTable($moduleDirname, $tableName, $fieldsNumb);
180			$fieldName = $fields[$f]->getVar('field_name');
181			$fieldType = $fields[$f]->getVar('field_type');
182			$fieldValue = $fields[$f]->getVar('field_value');
183			$fieldAttribute = $fields[$f]->getVar('field_attribute');
184			$fieldNull = $fields[$f]->getVar('field_null');
185			$fieldDefault = $fields[$f]->getVar('field_default');
186			$fieldKey = $fields[$f]->getVar('field_key');
187			if ($fieldType > 1) {
188			$fType = $helper->getHandler('Fieldtype')->get($fieldType);
189			$fieldTypeName = $fType->getVar('fieldtype_name');
190			} else {
191			$fieldType = null;
192			}
193			if ($fieldAttribute > 1) {
194			$fAttribute = $helper->getHandler('Fieldattributes')->get($fieldAttribute);
195			$fieldAttribute = $fAttribute->getVar('fieldattribute_name');
196			} else {
197			$fieldAttribute = null;
198			}
199			if ($fieldNull > 1) {
200			$fNull = $helper->getHandler('Fieldnull')->get($fieldNull);
201			$fieldNull = $fNull->getVar('fieldnull_name');
202			} else {
203			$fieldNull = null;
204			}
205			if (!empty($fieldName)) {
206			switch ($fieldType) {
207			case 2:
208			case 3:
209			case 4:
210			case 5:
211			$type = $fieldTypeName . '(' . $fieldValue . ')';
212			if (empty($fieldDefault)) {
213			$default = "DEFAULT '0'";
214			} else {
215			$default = "DEFAULT '{$fieldDefault}'";
216			}
217			break;
218			case 6:
219			case 7:
220			case 8:
221			$type = $fieldTypeName . '(' . $fieldValue . ')';
222			if (empty($fieldDefault)) {
223			$default = "DEFAULT '0.00'"; // From MySQL 5.7 Manual
224			} else {
225			$default = "DEFAULT '{$fieldDefault}'";
226			}
227			break;
228			case 9:
229			case 10:
230			$fValues = str_replace(',', "', '", str_replace(' ', '', $fieldValue));
231			$type = $fieldTypeName . '(\'' . $fValues . '\')'; // Used with comma separator
232			$default = "DEFAULT '{$fieldDefault}'";
233			break;
234			case 11:
235			$type = $fieldTypeName . '(' . $fieldValue . ')';
236			if (empty($fieldDefault)) {
237			$default = "DEFAULT '[email protected]'";
238			} else {
239			$default = "DEFAULT '{$fieldDefault}'";
240			}
241			break;
242			case 12:
243			$type = $fieldTypeName . '(' . $fieldValue . ')';
244			if (empty($fieldDefault)) {
245			$default = "DEFAULT 'http:\\'";
246			} else {
247			$default = "DEFAULT '{$fieldDefault}'";
248			}
249			break;
250			case 13:
251			case 14:
252			$type = $fieldTypeName . '(' . $fieldValue . ')';
253			$default = "DEFAULT '{$fieldDefault}'";
254			break;
255			case 15:
256			case 16:
257			case 17:
258			case 18:
259			$type = $fieldTypeName;
260			$default = null;
261			break;
262			case 19:
263			case 20:
264			case 21:
265			case 22:
266			$type = $fieldTypeName . '(' . $fieldValue . ')';
267			$default = "DEFAULT '{$fieldDefault}'";
268			break;
269			case 23:
270			$type = $fieldTypeName;
271			if (empty($fieldDefault)) {
272			$default = "DEFAULT '1970'"; // From MySQL 5.7 Manual
273			} else {
274			$default = "DEFAULT '{$fieldDefault}'";
275			}
276			break;
277			default:
278			$type = $fieldTypeName . '(' . $fieldValue . ')';
279			$default = "DEFAULT '{$fieldDefault}'";
280			break;
281			}
282			if ((0 == $f) && (1 == $tableAutoincrement)) {
283			$row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, null, 'AUTO_INCREMENT');
284			$comma[$j] = $this->getKey(2, $fieldName);
285			++$j;
286			} elseif ((0 == $f) && (0 == $tableAutoincrement)) {
287			$row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
288			$comma[$j] = $this->getKey(2, $fieldName);
289			++$j;
290			} else {
291			if (3 == $fieldKey \|\| 4 == $fieldKey \|\| 5 == $fieldKey \|\| 6 == $fieldKey) {
292			switch ($fieldKey) {
293			case 3:
294			$row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
295			$comma[$j] = $this->getKey(3, $fieldName);
296			++$j;
297			break;
298			case 4:
299			$row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
300			$comma[$j] = $this->getKey(4, $fieldName);
301			++$j;
302			break;
303			case 5:
304			$row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
305			$comma[$j] = $this->getKey(5, $fieldName);
306			++$j;
307			break;
308			case 6:
309			$row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
310			$comma[$j] = $this->getKey(6, $fieldName);
311			++$j;
312			break;
313			}
314			} else {
315			$row[] = $this->getFieldRow($fieldName, $type, $fieldAttribute, $fieldNull, $default);
316			}
317			}
318			}
319			}
320			// ================= COMMA ================= //
321			for ($i = 0; $i < $j; ++$i) {
322			if ($i != $j - 1) {
323			$row[] = $comma[$i] . ',';
324			} else {
325			$row[] = $comma[$i];
326			}
327			}
328			// ================= COMMA CICLE ================= //
329			$ret .= implode("\n", $row);
330			unset($j);
331			$ret .= $this->getFootDatabaseTable();
332
333			return $ret;
334			}
335
336			/**
337			* @private function getFootDatabaseTable
338			*
339			* @param null
340			*
341			* @return string
342			*/
343			private function getFootDatabaseTable()
344			{
345			return "\n) ENGINE=InnoDB;\n\n";
346			}
347
348			/**
349			* @private function getFieldRow
350			*
351			* @param $fieldName
352			* @param $fieldTypeValue
353			* @param $fieldAttribute
354			* @param $fieldNull
355			* @param $fieldDefault
356			* @param $autoincrement
357			*
358			* @return string
359			*/
360			private function getFieldRow($fieldName, $fieldTypeValue, $fieldAttribute = null, $fieldNull = null, $fieldDefault = null, $autoincrement = null)
361			{
362			$retAutoincrement = " `{$fieldName}` {$fieldTypeValue} {$fieldAttribute} {$fieldNull} {$autoincrement},";
363			$retFieldAttribute = " `{$fieldName}` {$fieldTypeValue} {$fieldAttribute} {$fieldNull} {$fieldDefault},";
364			$fieldDefault = " `{$fieldName}` {$fieldTypeValue} {$fieldNull} {$fieldDefault},";
365			$retShort = " `{$fieldName}` {$fieldTypeValue},";
366
367			$ret = $retShort;
368			if (null != $autoincrement) {
369			$ret = $retAutoincrement;
370			} elseif (null != $fieldAttribute) {
371			$ret = $retFieldAttribute;
372			} elseif (null === $fieldAttribute) {
373			$ret = $fieldDefault;
374			}
375
376			return $ret;
377			}
378
379			/**
380			* @private function getKey
381			*
382			* @param $key
383			* @param $fieldName
384			* @return string
385			*/
386			private function getKey($key, $fieldName)
387			{
388			$ret = null;
389			switch ($key) {
390			case 2: // PRIMARY KEY
391			$ret = " PRIMARY KEY (`{$fieldName}`)";
392			break;
393			case 3: // UNIQUE KEY
394			$ret = " UNIQUE KEY `{$fieldName}` (`{$fieldName}`)";
395			break;
396			case 4: // KEY
397			$ret = " KEY `{$fieldName}` (`{$fieldName}`)";
398			break;
399			case 5: // INDEX
400			$ret = " INDEX (`{$fieldName}`)";
401			break;
402			case 6: // FULLTEXT KEY
403			$ret = " FULLTEXT KEY `{$fieldName}` (`{$fieldName}`)";
404			break;
405			}
406
407			return $ret;
408			}
409
410			/**
411			* @private function getComma
412			*
413			* @param $row
414			* @param $comma
415			*
416			* @return string
417			*/
418			private function getComma($row, $comma = null)
			0 ignored issues – show Unused Code introduced 2020-04-30 09:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `getComma()` is not used, and could be removed. This check looks for private methods that have been defined, but are not used inside the class. Loading history...
419			{
420			return " {$row}{$comma}";
421			}
422
423			/**
424			* @public function render
425			*
426			* @param null
427			*
428			* @return bool\|string
429			*/
430			public function render()
431			{
432			$module = $this->getModule();
433			$filename = $this->getFileName();
434			$moduleName = mb_strtolower($module->getVar('mod_name'));
435			$moduleDirname = mb_strtolower($module->getVar('mod_dirname'));
436			$content = $this->getHeaderSqlComments($moduleName);
437			$content .= $this->getDatabaseTables($module);
438
439			$this->create($moduleDirname, 'sql', $filename, $content, _AM_TDMCREATE_FILE_CREATED, _AM_TDMCREATE_FILE_NOTCREATED);
440
441			return $this->renderFile();
442			}
443			}
444

txmodxoops / tdmcreate

Issues (964)

Security Analysis not enabled

class/Files/Sql/SqlFile.php (1 issue)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like