mirror of
https://github.com/VTECRM/vtenext.git
synced 2026-02-26 16:18:47 +00:00
1082 lines
44 KiB
PHP
1082 lines
44 KiB
PHP
<?php
|
|
/*************************************
|
|
* SPDX-FileCopyrightText: 2009-2020 Vtenext S.r.l. <info@vtenext.com>
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
************************************/
|
|
|
|
/* crmv@198038 */
|
|
|
|
include_once('vtlib/Vtecrm/PackageExport.php');
|
|
include_once('vtlib/Vtecrm/Unzip.php');
|
|
include_once('vtlib/Vtecrm/Module.php');
|
|
include_once('vtlib/Vtecrm/Event.php');
|
|
|
|
/* crmv@104975 crmv@146434 */
|
|
|
|
/**
|
|
* Provides API to import module into Vtenext
|
|
* @package vtlib
|
|
*/
|
|
class Vtecrm_PackageImport extends Vtecrm_PackageExport {
|
|
|
|
/**
|
|
* Module Meta XML File (Parsed)
|
|
* @access private
|
|
*/
|
|
var $_modulexml;
|
|
/**
|
|
* Module Fields mapped by [modulename][fieldname] which
|
|
* will be used to create customviews.
|
|
* @access private
|
|
*/
|
|
var $_modulefields_cache = Array();
|
|
|
|
/**
|
|
* License of the package.
|
|
* @access private
|
|
*/
|
|
var $_licensetext = false;
|
|
|
|
protected $firstPanel;
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
function __construct() {
|
|
parent::__construct();
|
|
}
|
|
|
|
/**
|
|
* Parse the manifest file
|
|
* @access private
|
|
*/
|
|
function __parseManifestFile($unzip) {
|
|
$manifestfile = $this->__getManifestFilePath();
|
|
$unzip->unzip('manifest.xml', $manifestfile);
|
|
$this->_modulexml = simplexml_load_file($manifestfile);
|
|
unlink($manifestfile);
|
|
}
|
|
|
|
/**
|
|
* Get type of package (as specified in manifest)
|
|
*/
|
|
function type() {
|
|
if(!empty($this->_modulexml) && !empty($this->_modulexml->type)) {
|
|
return $this->_modulexml->type;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* XPath evaluation on the root module node.
|
|
* @param String Path expression
|
|
*/
|
|
function xpath($path) {
|
|
return $this->_modulexml->xpath($path);
|
|
}
|
|
|
|
/**
|
|
* Get the value of matching path (instead of complete xpath result)
|
|
* @param String Path expression for which value is required
|
|
*/
|
|
function xpath_value($path) {
|
|
$xpathres = $this->xpath($path);
|
|
foreach($xpathres as $pathkey=>$pathvalue) {
|
|
if($pathkey == $path) return $pathvalue;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Are we trying to import language package?
|
|
*/
|
|
function isLanguageType($zipfile =null) {
|
|
if(!empty($zipfile)) {
|
|
if(!$this->checkZip($zipfile)) {
|
|
return false;
|
|
}
|
|
}
|
|
$packagetype = $this->type();
|
|
|
|
if($packagetype) {
|
|
$lcasetype = strtolower($packagetype);
|
|
if($lcasetype == 'language') return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* checks whether a package is module bundle or not.
|
|
* @param String $zipfile - path to the zip file.
|
|
* @return Boolean - true if given zipfile is a module bundle and false otherwise.
|
|
*/
|
|
function isModuleBundle($zipfile = null) {
|
|
// If data is not yet available
|
|
if(!empty($zipfile)) {
|
|
if(!$this->checkZip($zipfile)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return (boolean)$this->_modulexml->modulebundle;
|
|
}
|
|
|
|
/**
|
|
* @return Array module list available in the module bundle.
|
|
*/
|
|
function getAvailableModuleInfoFromModuleBundle() {
|
|
$list = (Array)$this->_modulexml->modulelist;
|
|
return (Array)$list['dependent_module'];
|
|
}
|
|
|
|
/**
|
|
* Get the license of this package
|
|
* NOTE: checkzip should have been called earlier.
|
|
*/
|
|
function getLicense() {
|
|
return $this->_licensetext;
|
|
}
|
|
|
|
/**
|
|
* Check if zipfile is a valid package
|
|
* @access private
|
|
*/
|
|
function checkZip($zipfile, &$error='') { // crmv@195213
|
|
$unzip = new Vtecrm_Unzip($zipfile);
|
|
$filelist = $unzip->getList();
|
|
|
|
$manifestxml_found = false;
|
|
$languagefile_found = false;
|
|
$vtenextversion_found = false;
|
|
|
|
$modulename = null;
|
|
$language_modulename = null;
|
|
|
|
foreach($filelist as $filename=>$fileinfo) {
|
|
$matches = Array();
|
|
preg_match('/manifest.xml/', $filename, $matches);
|
|
if(count($matches)) {
|
|
$manifestxml_found = true;
|
|
$this->__parseManifestFile($unzip);
|
|
$modulename = $this->_modulexml->name;
|
|
$isModuleBundle = (string)$this->_modulexml->modulebundle;
|
|
|
|
if($isModuleBundle === 'true' && (!empty($this->_modulexml)) &&
|
|
(!empty($this->_modulexml->dependencies)) &&
|
|
(!empty($this->_modulexml->dependencies->vtenext_version || !empty($this->_modulexml->dependencies->vtiger_version)))) {//crmv@207991
|
|
return true;
|
|
}
|
|
|
|
// Do we need to check the zip further?
|
|
if($this->isLanguageType()) {
|
|
$languagefile_found = true; // No need to search for module language file.
|
|
break;
|
|
} else {
|
|
// crmv@195213
|
|
if (isset($this->_modulexml->cf_prefix)) {
|
|
global $cf_prefix;
|
|
$package_cf_prefix = strval($this->_modulexml->cf_prefix);
|
|
if ($package_cf_prefix == $cf_prefix) {
|
|
$error = getTranslatedString('LBL_IMPORT_CF_PREFIX_ERROR', 'Settings');
|
|
}
|
|
}
|
|
if (empty($error) && !$this->checkPicklistDuplicates($this->_modulexml, Vtecrm_Module::getInstance($modulename))) {
|
|
$error = getTranslatedString('LBL_IMPORT_PICKLIST_DUPLICATES_ERROR', 'Settings');
|
|
}
|
|
// crmv@195213e
|
|
// crmv@197127
|
|
if (empty($error) && !$this->checkModlights($this->_modulexml, Vtecrm_Module::getInstance($modulename))) {
|
|
$error = getTranslatedString('LBL_IMPORT_MODLIGHTS_ERROR', 'Settings');
|
|
}
|
|
// crmv@197127e
|
|
continue;
|
|
}
|
|
}
|
|
// Check for language file.
|
|
preg_match("/modules\/([^\/]+)\/language\/en_us.lang.php/", $filename, $matches);
|
|
if(count($matches)) { $language_modulename = $matches[1]; continue; }
|
|
}
|
|
|
|
// Verify module language file.
|
|
if(!empty($language_modulename) && $language_modulename == $modulename) {
|
|
$languagefile_found = true;
|
|
}
|
|
|
|
if(!empty($this->_modulexml) &&
|
|
!empty($this->_modulexml->dependencies) &&
|
|
(!empty($this->_modulexml->dependencies->vtenext_version) || !empty($this->_modulexml->dependencies->vtiger_version))) {//crmv@207991
|
|
$vtenextversion_found = true;
|
|
}
|
|
|
|
$validzip = false;
|
|
if($manifestxml_found && $languagefile_found && $vtenextversion_found)
|
|
$validzip = true;
|
|
|
|
if($validzip) {
|
|
if(!empty($this->_modulexml->license)) {
|
|
if(!empty($this->_modulexml->license->inline)) {
|
|
$this->_licensetext = $this->_modulexml->license->inline;
|
|
} else if(!empty($this->_modulexml->license->file)) {
|
|
$licensefile = $this->_modulexml->license->file;
|
|
$licensefile = "$licensefile";
|
|
if(!empty($filelist[$licensefile])) {
|
|
$this->_licensetext = $unzip->unzip($licensefile);
|
|
} else {
|
|
$this->_licensetext = "Missing $licensefile!";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if($unzip) $unzip->close();
|
|
|
|
return $validzip;
|
|
}
|
|
|
|
// crmv@195213
|
|
function checkPicklistDuplicates($modulenode, $moduleInstance=null) {
|
|
global $adb, $table_prefix;
|
|
$system_shared_picklists = array(
|
|
'carrier' => array('Quotes','PurchaseOrder','SalesOrder'),
|
|
'glacct' => array('Vendors','Products'),
|
|
'industry' => array('Accounts','Leads'),
|
|
'invoicestatus' => array('Invoice','SalesOrder'),
|
|
'leadsource' => array('Leads','Contacts','Potentials'),
|
|
'rating' => array('Leads','Accounts'),
|
|
'ticketstatus' => array('HelpDesk','Timecards'),
|
|
);
|
|
if (!empty($modulenode->panels) && !empty($modulenode->panels->panel)) {
|
|
foreach($modulenode->panels->panel as $panelnode) {
|
|
if (!empty($panelnode->blocks) && !empty($panelnode->blocks->block)) {
|
|
foreach($panelnode->blocks->block as $blocknode) {
|
|
if (!empty($blocknode->fields) && !empty($blocknode->fields->field)) {
|
|
foreach($blocknode->fields->field as $fieldnode) {
|
|
$fieldname = strval($fieldnode->fieldname);
|
|
if (!empty($moduleInstance) && isset($system_shared_picklists[$fieldname]) && in_array($moduleInstance->name,$system_shared_picklists[$fieldname])) continue;
|
|
|
|
$result = $adb->pquery("select fieldtype from {$table_prefix}_ws_fieldtype where uitype = ?", array($fieldnode->uitype));
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
$fieldtype = $adb->query_result($result,0,'fieldtype');
|
|
if ($fieldtype == 'picklist' || $fieldtype == 'multipicklist') {
|
|
$query = "select tabid, fieldid
|
|
from {$table_prefix}_field
|
|
inner join {$table_prefix}_ws_fieldtype on {$table_prefix}_ws_fieldtype.uitype = {$table_prefix}_field.uitype
|
|
where fieldtype in (?,?) and fieldname = ?";
|
|
$params = array('picklist','multipicklist',$fieldname);
|
|
if (!empty($moduleInstance)) {
|
|
$query .= ' and tabid <> ?';
|
|
$params[] = $moduleInstance->id;
|
|
}
|
|
$result = $adb->pquery($query,$params);
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// check orphaned blocks
|
|
if (!empty($modulenode->blocks) && !empty($modulenode->blocks->block)) {
|
|
foreach($modulenode->blocks->block as $blocknode) {
|
|
if (!empty($blocknode->fields) && !empty($blocknode->fields->field)) {
|
|
foreach($blocknode->fields->field as $fieldnode) {
|
|
$fieldname = strval($fieldnode->fieldname);
|
|
if (!empty($moduleInstance) && isset($system_shared_picklists[$fieldname]) && in_array($moduleInstance->name,$system_shared_picklists[$fieldname])) continue;
|
|
|
|
$result = $adb->pquery("select fieldtype from {$table_prefix}_ws_fieldtype where uitype = ?", array($fieldnode->uitype));
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
$fieldtype = $adb->query_result($result,0,'fieldtype');
|
|
if ($fieldtype == 'picklist' || $fieldtype == 'multipicklist') {
|
|
$query = "select tabid, fieldid
|
|
from {$table_prefix}_field
|
|
inner join {$table_prefix}_ws_fieldtype on {$table_prefix}_ws_fieldtype.uitype = {$table_prefix}_field.uitype
|
|
where fieldtype in (?,?) and fieldname = ?";
|
|
$params = array('picklist','multipicklist',$fieldname);
|
|
if (!empty($moduleInstance)) {
|
|
$query .= ' and tabid <> ?';
|
|
$params[] = $moduleInstance->id;
|
|
}
|
|
$result = $adb->pquery($query,$params);
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
// crmv@195213e
|
|
|
|
// crmv@197127
|
|
function checkModlights($modulenode, $moduleInstance=null) {
|
|
global $adb, $table_prefix;
|
|
|
|
// in update mode skip the check
|
|
if (!empty($moduleInstance)) return true;
|
|
|
|
if (!empty($modulenode->panels) && !empty($modulenode->panels->panel)) {
|
|
foreach($modulenode->panels->panel as $panelnode) {
|
|
if (!empty($panelnode->blocks) && !empty($panelnode->blocks->block)) {
|
|
foreach($panelnode->blocks->block as $blocknode) {
|
|
if (!empty($blocknode->fields) && !empty($blocknode->fields->field)) {
|
|
foreach($blocknode->fields->field as $fieldnode) {
|
|
$fieldname = strval($fieldnode->fieldname);
|
|
|
|
$result = $adb->pquery("select fieldtype from {$table_prefix}_ws_fieldtype where uitype = ?", array($fieldnode->uitype));
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
$fieldtype = $adb->query_result($result,0,'fieldtype');
|
|
if ($fieldtype == 'table') {
|
|
$query = "select tabid, fieldid
|
|
from {$table_prefix}_field
|
|
inner join {$table_prefix}_ws_fieldtype on {$table_prefix}_ws_fieldtype.uitype = {$table_prefix}_field.uitype
|
|
where fieldtype = ? and fieldname = ?";
|
|
$params = array('table',$fieldname);
|
|
/*if (!empty($moduleInstance)) {
|
|
$query .= ' and tabid <> ?';
|
|
$params[] = $moduleInstance->id;
|
|
}*/
|
|
$result = $adb->pquery($query,$params);
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// check orphaned blocks
|
|
if (!empty($modulenode->blocks) && !empty($modulenode->blocks->block)) {
|
|
foreach($modulenode->blocks->block as $blocknode) {
|
|
if (!empty($blocknode->fields) && !empty($blocknode->fields->field)) {
|
|
foreach($blocknode->fields->field as $fieldnode) {
|
|
$fieldname = strval($fieldnode->fieldname);
|
|
|
|
$result = $adb->pquery("select fieldtype from {$table_prefix}_ws_fieldtype where uitype = ?", array($fieldnode->uitype));
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
$fieldtype = $adb->query_result($result,0,'fieldtype');
|
|
if ($fieldtype == 'table') {
|
|
$query = "select tabid, fieldid
|
|
from {$table_prefix}_field
|
|
inner join {$table_prefix}_ws_fieldtype on {$table_prefix}_ws_fieldtype.uitype = {$table_prefix}_field.uitype
|
|
where fieldtype = ? and fieldname = ?";
|
|
$params = array('table',$fieldname);
|
|
/*if (!empty($moduleInstance)) {
|
|
$query .= ' and tabid <> ?';
|
|
$params[] = $moduleInstance->id;
|
|
}*/
|
|
$result = $adb->pquery($query,$params);
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
// crmv@197127e
|
|
|
|
/**
|
|
* Get module name packaged in the zip file
|
|
* @access private
|
|
*/
|
|
// crmv@195213
|
|
function getModuleNameFromZip($zipfile, &$error='') {
|
|
if(!$this->checkZip($zipfile,$error)) return null;
|
|
|
|
return (string)$this->_modulexml->name;
|
|
}
|
|
// crmv@195213e
|
|
|
|
/**
|
|
* returns the name of the module.
|
|
* @return String - name of the module as given in manifest file.
|
|
*/
|
|
function getModuleName() {
|
|
return (string)$this->_modulexml->name;
|
|
}
|
|
|
|
/**
|
|
* Cache the field instance for re-use
|
|
* @access private
|
|
*/
|
|
function __AddModuleFieldToCache($moduleInstance, $fieldname, $fieldInstance) {
|
|
$this->_modulefields_cache["$moduleInstance->name"]["$fieldname"] = $fieldInstance;
|
|
}
|
|
|
|
/**
|
|
* Get field instance from cache
|
|
* @access private
|
|
*/
|
|
function __GetModuleFieldFromCache($moduleInstance, $fieldname) {
|
|
return $this->_modulefields_cache["$moduleInstance->name"]["$fieldname"];
|
|
}
|
|
|
|
/**
|
|
* Initialize Import
|
|
* @access private
|
|
*/
|
|
function initImport($zipfile, $overwrite) {
|
|
$module = $this->getModuleNameFromZip($zipfile);
|
|
if($module != null) {
|
|
|
|
$unzip = new Vtecrm_Unzip($zipfile, $overwrite);
|
|
|
|
// Unzip selectively
|
|
$unzip->unzipAllEx( ".",
|
|
Array(
|
|
// Include only file/folders that need to be extracted
|
|
'include' => Array('templates', "modules/$module", 'cron', 'sdk'), //crmv@sdk
|
|
//'exclude' => Array('manifest.xml')
|
|
// NOTE: If excludes is not given then by those not mentioned in include are ignored.
|
|
),
|
|
// What files needs to be renamed?
|
|
Array(
|
|
// Templates folder
|
|
'templates' => "Smarty/templates/modules/$module",
|
|
// Cron folder
|
|
'cron' => "cron/modules/$module",
|
|
'sdk' => 'modules/SDK/tmp' //crmv@sdk
|
|
)
|
|
);
|
|
|
|
if($unzip) $unzip->close();
|
|
}
|
|
return $module;
|
|
}
|
|
|
|
function getTemporaryFilePath($filepath=false) {
|
|
return 'cache/'. $filepath;
|
|
}
|
|
/**
|
|
* Get dependent version
|
|
* @access private
|
|
*/
|
|
function getDependentVersion() {//crmv@207991
|
|
return $this->_modulexml->dependencies->vtenext_version;//crmv@207991
|
|
}
|
|
|
|
/**
|
|
* Get dependent Maximum version
|
|
* @access private
|
|
*/
|
|
function getDependentMaxVersion() {
|
|
return $this->_modulexml->dependencies->vtenext_max_version;//crmv@207991
|
|
}
|
|
|
|
/**
|
|
* Get package version
|
|
* @access private
|
|
*/
|
|
function getVersion() {
|
|
return $this->_modulexml->version;
|
|
}
|
|
|
|
/**
|
|
* Import Module from zip file
|
|
* @param String Zip file name
|
|
* @param Boolean True for overwriting existing module
|
|
*
|
|
* @todo overwrite feature is not functionally currently.
|
|
*/
|
|
function import($zipfile, $overwrite=false,$tabidtouse=false) { //crmv@36557
|
|
$module = $this->getModuleNameFromZip($zipfile);
|
|
if($module != null) {
|
|
// If data is not yet available
|
|
if(empty($this->_modulexml)) {
|
|
$this->__parseManifestFile($unzip);
|
|
}
|
|
|
|
$buildModuleArray = array();
|
|
$installSequenceArray = array();
|
|
$moduleBundle = (boolean)$this->_modulexml->modulebundle;
|
|
if($moduleBundle == true) {
|
|
$moduleList = (Array)$this->_modulexml->modulelist;
|
|
foreach($moduleList as $moduleInfos) {
|
|
foreach($moduleInfos as $moduleInfo) {
|
|
$moduleInfo = (Array)$moduleInfo;
|
|
$buildModuleArray[] = $moduleInfo;
|
|
$installSequenceArray[] = $moduleInfo['install_sequence'];
|
|
}
|
|
}
|
|
sort($installSequenceArray);
|
|
$unzip = new Vtecrm_Unzip($zipfile);
|
|
$unzip->unzipAllEx($this->getTemporaryFilePath());
|
|
foreach ($installSequenceArray as $sequence) {
|
|
foreach ($buildModuleArray as $moduleInfo) {
|
|
if($moduleInfo['install_sequence'] == $sequence) {
|
|
$this->import($this->getTemporaryFilePath($moduleInfo['filepath']), $overwrite);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
$module = $this->initImport($zipfile, $overwrite);
|
|
// Call module import function
|
|
$this->import_Module($tabidtouse); //crmv@36557
|
|
}
|
|
}
|
|
}
|
|
|
|
//crmv@2963m
|
|
function importByManifest($moduleName) {
|
|
$manifestfile = "modules/$moduleName/manifest.xml";
|
|
if (file_exists($manifestfile)) {
|
|
$this->_modulexml = simplexml_load_file($manifestfile);
|
|
$this->import_Module();
|
|
@rename($manifestfile,$manifestfile.'.installed');
|
|
}
|
|
}
|
|
//crmv@2963me
|
|
|
|
/**
|
|
* Import Module
|
|
* @access private
|
|
*/
|
|
function import_Module($tabidtouse=false) { //crmv@36557
|
|
global $adb, $table_prefix;
|
|
$tabname = $this->_modulexml->name;
|
|
//crmv@30456
|
|
if(strpos($tabname, 'TABLEPREFIX') !== false){
|
|
$tabname=str_replace('TABLEPREFIX', $table_prefix, $tabname);
|
|
}
|
|
//crmv@30456e
|
|
$parenttab=(string)$this->_modulexml->parent;
|
|
//crmv@30456
|
|
if(strpos($parenttab, 'TABLEPREFIX') !== false){
|
|
$parenttab=str_replace('TABLEPREFIX', $table_prefix, $parenttab);
|
|
}
|
|
//crmv@30456e
|
|
$tabversion=$this->_modulexml->version;
|
|
|
|
$isextension= false;
|
|
if(!empty($this->_modulexml->type)) {
|
|
$type = strtolower($this->_modulexml->type);
|
|
if($type == 'extension' || $type == 'language')
|
|
$isextension = true;
|
|
}
|
|
|
|
$MinVersion = $this->_modulexml->dependencies->vtenext_version ?: $this->_modulexml->dependencies->vtiger_version;//crmv@207991
|
|
$MaxVersion = $this->_modulexml->dependencies->vtenext_max_version ?: $this->_modulexml->dependencies->vtiger_max_version;//crmv@207991
|
|
|
|
$moduleInstance = new Vtecrm_Module();
|
|
$moduleInstance->name = $tabname;
|
|
$moduleInstance->label= $tablabel;
|
|
$moduleInstance->isentitytype = ($isextension != true);
|
|
$moduleInstance->version = (!$tabversion)? 0 : $tabversion;
|
|
$moduleInstance->minversion = (!$MinVersion)? false : $MinVersion;
|
|
$moduleInstance->maxversion = (!$MaxVersion)? false : $MaxVersion;
|
|
// import info
|
|
if (!empty($this->_modulexml->info)) {
|
|
foreach($this->_modulexml->info as $info) {
|
|
foreach($info as $name => $value) {
|
|
if (isset($moduleInstance->$name)) $moduleInstance->$name = strval($value);
|
|
}
|
|
}
|
|
}
|
|
$moduleInstance->save($tabidtouse); //crmv@36557
|
|
|
|
if(!empty($parenttab)) {
|
|
$menuInstance = Vtecrm_Menu::getInstance($parenttab);
|
|
$menuInstance->addModule($moduleInstance);
|
|
}
|
|
|
|
if (isset($this->_modulexml->info->is_mod_light) && $this->_modulexml->info->is_mod_light == '1') {
|
|
VteSession::set('skip_recalculate', true);
|
|
@mkdir("modules/{$moduleInstance->name}");
|
|
}
|
|
|
|
$this->import_Tables($this->_modulexml);
|
|
$this->import_Panels($this->_modulexml, $moduleInstance);
|
|
$this->import_Orphaned_Blocks($this->_modulexml, $moduleInstance);
|
|
$this->import_CustomViews($this->_modulexml, $moduleInstance);
|
|
$this->import_SharingAccess($this->_modulexml, $moduleInstance);
|
|
$this->import_Events($this->_modulexml, $moduleInstance);
|
|
$this->import_Actions($this->_modulexml, $moduleInstance);
|
|
$this->import_RelatedLists($this->_modulexml, $moduleInstance);
|
|
$this->import_CustomLinks($this->_modulexml, $moduleInstance);
|
|
$this->import_Modlights($this->_modulexml, $moduleInstance); // crmv@197127
|
|
|
|
if (isset($this->_modulexml->info->is_mod_light) && $this->_modulexml->info->is_mod_light == '1') {
|
|
|
|
$modulelightid = str_replace('ModLight','',$moduleInstance->name);
|
|
$result = $adb->pquery("select fieldlabel from {$table_prefix}_field where fieldname = ? and uitype = ?", array('ml'.$modulelightid,'220'));
|
|
($result && $adb->num_rows($result) > 0) ? $fieldlabel = $adb->query_result($result,0,'fieldlabel') : $fieldlabel = $moduleInstance->name;
|
|
|
|
require_once('include/utils/ModLightUtils.php');
|
|
$MLUtils = ModLightUtils::getInstance();
|
|
|
|
require_once('modules/Settings/ModuleMaker/ModuleMakerUtils.php');
|
|
require_once('modules/Settings/ProcessMaker/ProcessMakerUtils.php');
|
|
require_once('modules/Settings/ModuleMaker/ModuleMakerGenerator.php');
|
|
$MMUtils = new ModuleMakerUtils();
|
|
$MMSteps = new ProcessModuleMakerSteps($MMUtils);
|
|
$MMGen = new ModuleMakerGenerator($MMUtils, $MMSteps);
|
|
|
|
// init ModuleMakerGenerator
|
|
$MMGen->setModuleName($moduleInstance->name);
|
|
$result = $adb->pquery("SELECT {$table_prefix}_field.fieldname, {$table_prefix}_field.fieldlabel
|
|
FROM {$table_prefix}_entityname
|
|
INNER JOIN {$table_prefix}_field ON {$table_prefix}_entityname.fieldname = {$table_prefix}_field.fieldname AND {$table_prefix}_field.tabid = {$table_prefix}_entityname.tabid
|
|
WHERE {$table_prefix}_entityname.modulename = ?", array($moduleInstance->name));
|
|
$MMGen->mainField = array('fieldname'=>$adb->query_result($result,0,'fieldname'),'fieldlabel'=>$adb->query_result($result,0,'fieldlabel'));
|
|
|
|
$result = $adb->pquery("SELECT fieldname, fieldlabel FROM {$table_prefix}_field WHERE tabid = ?", array($moduleInstance->id));
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
while($row=$adb->fetchByAssoc($result)) {
|
|
$MMGen->moduleInfo['fields'][0]['fields'][] = array('fieldname'=>$row['fieldname'],'fieldlabel'=>$row['fieldlabel']);
|
|
}
|
|
}
|
|
$result = $adb->pquery("select columnname from {$table_prefix}_cvcolumnlist
|
|
inner join {$table_prefix}_customview on {$table_prefix}_customview.cvid = {$table_prefix}_cvcolumnlist.cvid
|
|
where entitytype = ?
|
|
order by columnindex", array($moduleInstance->name));
|
|
if ($result && $adb->num_rows($result) > 0) {
|
|
while($row=$adb->fetchByAssoc($result)) {
|
|
$t = explode(':',$row['columnname']);
|
|
$MMGen->moduleInfo['filters'][0]['columns'][] = $t[2];
|
|
}
|
|
}
|
|
|
|
$MLUtils->generateFileStructure($moduleInstance->name, $fieldlabel, $MMGen);
|
|
|
|
VteSession::remove('skip_recalculate');
|
|
create_tab_data_file();
|
|
create_parenttab_data_file();
|
|
}
|
|
|
|
SDK::importPackage($this->_modulexml, $moduleInstance); //crmv@sdk
|
|
|
|
$moduleInstance->initWebservice();
|
|
Vtecrm_Module::fireEvent($moduleInstance->name, Vtecrm_Module::EVENT_MODULE_POSTINSTALL);
|
|
}
|
|
|
|
/**
|
|
* Import Tables of the module
|
|
* @access private
|
|
*/
|
|
function import_Tables($modulenode) {
|
|
global $table_prefix;
|
|
if(empty($modulenode->tables) || empty($modulenode->tables->table)) return;
|
|
|
|
/**
|
|
* Record the changes in schema file
|
|
*/
|
|
$schemafile = fopen("modules/$modulenode->name/schema.xml", 'w');
|
|
if($schemafile) {
|
|
fwrite($schemafile, "<?xml version='1.0'?>\n");
|
|
fwrite($schemafile, "<schema>\n");
|
|
fwrite($schemafile, "\t<tables>\n");
|
|
}
|
|
|
|
// Import the table via queries
|
|
foreach($modulenode->tables->table as $tablenode) {
|
|
$tablename = $tablenode->name;
|
|
//crmv@30456
|
|
if(strpos($tablename, 'TABLEPREFIX') !== false){
|
|
$tablename=str_replace('TABLEPREFIX', $table_prefix, $tablename);
|
|
}
|
|
//crmv@30456e
|
|
$tablesql = "$tablenode->sql"; // Convert to string format
|
|
//crmv@30456
|
|
if(strpos($tablesql, 'TABLEPREFIX') !== false){
|
|
$tablesql=str_replace('TABLEPREFIX', $table_prefix, $tablesql);
|
|
}
|
|
//crmv@30456e
|
|
// Save the information in the schema file.
|
|
fwrite($schemafile, "\t\t<table>\n");
|
|
fwrite($schemafile, "\t\t\t<name>$tablename</name>\n");
|
|
fwrite($schemafile, "\t\t\t<sql><![CDATA[$tablesql]]></sql>\n");
|
|
fwrite($schemafile, "\t\t</table>\n");
|
|
|
|
// Avoid executing SQL that will DELETE or DROP table data
|
|
if(Vtecrm_Utils::IsCreateSql($tablesql)) {
|
|
if(!Vtecrm_Utils::checkTable($tablename)) {
|
|
self::log("SQL: $tablesql ... ", false);
|
|
Vtecrm_Utils::ExecuteSchema($tablesql);
|
|
self::log("DONE");
|
|
}
|
|
} else {
|
|
if(Vtecrm_Utils::IsDestructiveSql($tablesql)) {
|
|
self::log("SQL: $tablesql ... SKIPPED");
|
|
} else {
|
|
self::log("SQL: $tablesql ... ", false);
|
|
Vtecrm_Utils::ExecuteSchema($tablesql);
|
|
self::log("DONE");
|
|
}
|
|
}
|
|
}
|
|
if($schemafile) {
|
|
fwrite($schemafile, "\t</tables>\n");
|
|
fwrite($schemafile, "</schema>\n");
|
|
fclose($schemafile);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Panels of the module
|
|
* @access private
|
|
*/
|
|
function import_Panels($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->panels) || empty($modulenode->panels->panel)) return;
|
|
foreach($modulenode->panels->panel as $panelnode) {
|
|
$panelInstance = $this->import_Panel($modulenode, $moduleInstance, $panelnode);
|
|
if (!$this->firstPanel) {
|
|
// save a reference to the first panel
|
|
$this->firstPanel = $panelInstance;
|
|
}
|
|
$this->import_Blocks($panelnode, $panelInstance, $moduleInstance);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Panel of the module
|
|
* @access private
|
|
*/
|
|
function import_Panel($modulenode, $moduleInstance, $panelnode) {
|
|
$panellabel = $panelnode->label;
|
|
|
|
$panelInstance = new Vtecrm_Panel();
|
|
$panelInstance->label = $panellabel;
|
|
$moduleInstance->addPanel($panelInstance);
|
|
return $panelInstance;
|
|
}
|
|
|
|
/**
|
|
* Create the main panel for a module
|
|
*/
|
|
function create_Main_Panel($moduleInstance) {
|
|
$panelInstance = new Vtecrm_Panel();
|
|
$panelInstance->label = 'LBL_TAB_MAIN';
|
|
$moduleInstance->addPanel($panelInstance);
|
|
return $panelInstance;
|
|
}
|
|
|
|
/**
|
|
* Import Blocks of the module
|
|
* @access private
|
|
*/
|
|
function import_Blocks($panelnode, $panelInstance, $moduleInstance) {
|
|
if(empty($panelnode->blocks) || empty($panelnode->blocks->block)) return;
|
|
foreach($panelnode->blocks->block as $blocknode) {
|
|
$blockInstance = $this->import_Block($panelnode, $panelInstance, $moduleInstance, $blocknode);
|
|
$this->import_Fields($blocknode, $blockInstance, $moduleInstance);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Blocks without panel in the first panel (or create one if not present)
|
|
*/
|
|
function import_Orphaned_Blocks($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->blocks) || empty($modulenode->blocks->block)) return;
|
|
if (!$this->firstPanel) {
|
|
$this->firstPanel = $this->create_Main_Panel($moduleInstance);
|
|
}
|
|
foreach($modulenode->blocks->block as $blocknode) {
|
|
$blockInstance = $this->import_Block(null, $this->firstPanel, $moduleInstance, $blocknode);
|
|
$this->import_Fields($blocknode, $blockInstance, $moduleInstance);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Block of the module
|
|
* @access private
|
|
*/
|
|
function import_Block($panelnode, $panelInstance, $moduleInstance, $blocknode) {
|
|
$blocklabel = $blocknode->label;
|
|
$blocksequence = $blocknode->sequence;
|
|
|
|
$blockInstance = new Vtecrm_Block();
|
|
$blockInstance->label = $blocklabel;
|
|
$blockInstance->panel = $panelInstance;
|
|
$blockInstance->sequence = $blocksequence;
|
|
$moduleInstance->addBlock($blockInstance);
|
|
return $blockInstance;
|
|
}
|
|
|
|
/**
|
|
* Import Fields of the module
|
|
* @access private
|
|
*/
|
|
function import_Fields($blocknode, $blockInstance, $moduleInstance) {
|
|
if(empty($blocknode->fields) || empty($blocknode->fields->field)) return;
|
|
|
|
foreach($blocknode->fields->field as $fieldnode) {
|
|
$fieldInstance = $this->import_Field($blocknode, $blockInstance, $moduleInstance, $fieldnode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Field of the module
|
|
* @access private
|
|
*/
|
|
function import_Field($blocknode, $blockInstance, $moduleInstance, $fieldnode) {
|
|
$fieldInstance = new Vtecrm_Field();
|
|
$fieldInstance->name = $fieldnode->fieldname;
|
|
$fieldInstance->label = $fieldnode->fieldlabel;
|
|
$fieldInstance->table = $fieldnode->tablename;
|
|
$fieldInstance->column = $fieldnode->columnname;
|
|
$fieldInstance->uitype = $fieldnode->uitype;
|
|
$fieldInstance->generatedtype= $fieldnode->generatedtype;
|
|
$fieldInstance->readonly = $fieldnode->readonly;
|
|
$fieldInstance->presence = $fieldnode->presence;
|
|
$fieldInstance->selected = $fieldnode->selected;
|
|
$fieldInstance->maximumlength= $fieldnode->maximumlength;
|
|
$fieldInstance->sequence = $fieldnode->sequence;
|
|
$fieldInstance->quickcreate = $fieldnode->quickcreate;
|
|
$fieldInstance->quicksequence= $fieldnode->quickcreatesequence;
|
|
$fieldInstance->typeofdata = $fieldnode->typeofdata;
|
|
$fieldInstance->displaytype = $fieldnode->displaytype;
|
|
$fieldInstance->info_type = $fieldnode->info_type;
|
|
|
|
if(!empty($fieldnode->helpinfo))
|
|
$fieldInstance->helpinfo = $fieldnode->helpinfo;
|
|
|
|
if(isset($fieldnode->masseditable))
|
|
$fieldInstance->masseditable = $fieldnode->masseditable;
|
|
|
|
if(isset($fieldnode->columntype) && !empty($fieldnode->columntype))
|
|
$fieldInstance->columntype = $fieldnode->columntype;
|
|
|
|
$blockInstance->addField($fieldInstance);
|
|
|
|
// Set the field as entity identifier if marked.
|
|
if(!empty($fieldnode->entityidentifier)) {
|
|
$moduleInstance->entityidfield = $fieldnode->entityidentifier->entityidfield;
|
|
$moduleInstance->entityidcolumn= $fieldnode->entityidentifier->entityidcolumn;
|
|
$moduleInstance->setEntityIdentifier($fieldInstance);
|
|
}
|
|
|
|
// Check picklist values associated with field if any.
|
|
if(!empty($fieldnode->picklistvalues) && isset($fieldnode->picklistvalues->picklistvalue)) {
|
|
$picklistvalues = Array();
|
|
foreach($fieldnode->picklistvalues->picklistvalue as $picklistvaluenode) {
|
|
$picklistvalues[] = $picklistvaluenode;
|
|
}
|
|
$fieldInstance->setPicklistValues( $picklistvalues );
|
|
}
|
|
|
|
// Check related modules associated with this field
|
|
if(!empty($fieldnode->relatedmodules) && !empty($fieldnode->relatedmodules->relatedmodule)) {
|
|
$relatedmodules = Array();
|
|
foreach($fieldnode->relatedmodules->relatedmodule as $relatedmodulenode) {
|
|
$relatedmodules[] = $relatedmodulenode;
|
|
}
|
|
$fieldInstance->setRelatedModules($relatedmodules);
|
|
}
|
|
|
|
if(!empty($fieldnode->info)) {
|
|
$fieldinfo = array();
|
|
foreach($fieldnode->info as $info) {
|
|
foreach($info as $k => $v) {
|
|
$fieldinfo[$k] = Zend_Json::decode(strval($v));
|
|
if ($fieldInstance->uitype == '50' && !empty($fieldinfo[$k])) {
|
|
foreach($fieldinfo[$k] as &$user) if ($user != '') $user = getUserId_Ol($user);
|
|
}
|
|
}
|
|
}
|
|
if (!empty($fieldinfo)) $fieldInstance->setFieldInfo($fieldinfo);
|
|
}
|
|
|
|
$this->__AddModuleFieldToCache($moduleInstance, $fieldnode->fieldname, $fieldInstance);
|
|
return $fieldInstance;
|
|
}
|
|
|
|
/**
|
|
* Import Custom views of the module
|
|
* @access private
|
|
*/
|
|
function import_CustomViews($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->customviews) || empty($modulenode->customviews->customview)) return;
|
|
foreach($modulenode->customviews->customview as $customviewnode) {
|
|
$filterInstance = $this->import_CustomView($modulenode, $moduleInstance, $customviewnode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Custom View of the module
|
|
* @access private
|
|
*/
|
|
function import_CustomView($modulenode, $moduleInstance, $customviewnode) {
|
|
$viewname = $customviewnode->viewname;
|
|
$setdefault=$customviewnode->setdefault;
|
|
$setmetrics=$customviewnode->setmetrics;
|
|
$setmobile=$customviewnode->setmobile; // crmv@49398
|
|
|
|
$filterInstance = new Vtecrm_Filter();
|
|
$filterInstance->name = $viewname;
|
|
$filterInstance->isdefault = $setdefault;
|
|
$filterInstance->inmetrics = $setmetrics;
|
|
$filterInstance->inmobile = $setmobile; // crmv@49398
|
|
|
|
$moduleInstance->addFilter($filterInstance);
|
|
|
|
foreach($customviewnode->fields->field as $fieldnode) {
|
|
$fieldInstance = $this->__GetModuleFieldFromCache($moduleInstance, $fieldnode->fieldname);
|
|
$filterInstance->addField($fieldInstance, $fieldnode->columnindex);
|
|
|
|
if(!empty($fieldnode->rules->rule)) {
|
|
foreach($fieldnode->rules->rule as $rulenode) {
|
|
$filterInstance->addRule($fieldInstance, $rulenode->comparator, $rulenode->value, $rulenode->columnindex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Sharing Access of the module
|
|
* @access private
|
|
*/
|
|
function import_SharingAccess($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->sharingaccess)) return;
|
|
|
|
if(!empty($modulenode->sharingaccess->default)) {
|
|
foreach($modulenode->sharingaccess->default as $defaultnode) {
|
|
$moduleInstance->setDefaultSharing($defaultnode);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Events of the module
|
|
* @access private
|
|
*/
|
|
function import_Events($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->events) || empty($modulenode->events->event)) return;
|
|
|
|
if(Vtecrm_Event::hasSupport()) {
|
|
foreach($modulenode->events->event as $eventnode) {
|
|
$this->import_Event($modulenode, $moduleInstance, $eventnode);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import Event of the module
|
|
* @access private
|
|
*/
|
|
function import_Event($modulenode, $moduleInstance, $eventnode) {
|
|
$event_condition = '';
|
|
if(!empty($eventnode->condition)) $event_condition = "$eventnode->condition";
|
|
Vtecrm_Event::register($moduleInstance,
|
|
(string)$eventnode->eventname, (string)$eventnode->classname,
|
|
(string)$eventnode->filename, (string)$event_condition
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Import actions of the module
|
|
* @access private
|
|
*/
|
|
function import_Actions($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->actions) || empty($modulenode->actions->action)) return;
|
|
foreach($modulenode->actions->action as $actionnode) {
|
|
$this->import_Action($modulenode, $moduleInstance, $actionnode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import action of the module
|
|
* @access private
|
|
*/
|
|
function import_Action($modulenode, $moduleInstance, $actionnode) {
|
|
$actionstatus = $actionnode->status;
|
|
if($actionstatus == 'enabled')
|
|
$moduleInstance->enableTools($actionnode->name);
|
|
else
|
|
$moduleInstance->disableTools($actionnode->name);
|
|
}
|
|
|
|
/**
|
|
* Import related lists of the module
|
|
* @access private
|
|
*/
|
|
function import_RelatedLists($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->relatedlists) || empty($modulenode->relatedlists->relatedlist)) return;
|
|
foreach($modulenode->relatedlists->relatedlist as $relatedlistnode) {
|
|
$relModuleInstance = $this->import_Relatedlist($modulenode, $moduleInstance, $relatedlistnode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Import related list of the module.
|
|
* @access private
|
|
*/
|
|
function import_Relatedlist($modulenode, $moduleInstance, $relatedlistnode) {
|
|
$relModuleInstance = Vtecrm_Module::getInstance($relatedlistnode->relatedmodule);
|
|
$label = $relatedlistnode->label;
|
|
$actions = false;
|
|
if(!empty($relatedlistnode->actions) && !empty($relatedlistnode->actions->action)) {
|
|
$actions = Array();
|
|
foreach($relatedlistnode->actions->action as $actionnode) {
|
|
$actions[] = "$actionnode";
|
|
}
|
|
}
|
|
if($relModuleInstance) {
|
|
$moduleInstance->setRelatedList($relModuleInstance, "$label", $actions, "$relatedlistnode->function");
|
|
}
|
|
return $relModuleInstance;
|
|
}
|
|
|
|
/**
|
|
* Import custom links of the module.
|
|
* @access private
|
|
*/
|
|
function import_CustomLinks($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->customlinks) || empty($modulenode->customlinks->customlink)) return;
|
|
|
|
foreach($modulenode->customlinks->customlink as $customlinknode) {
|
|
$moduleInstance->addLink(
|
|
"$customlinknode->linktype",
|
|
"$customlinknode->linklabel",
|
|
"$customlinknode->linkurl",
|
|
"$customlinknode->linkicon",
|
|
"$customlinknode->sequence",
|
|
"$customlinknode->condition",
|
|
"$customlinknode->size"
|
|
);
|
|
}
|
|
}
|
|
|
|
// crmv@197127
|
|
function import_Modlights($modulenode, $moduleInstance) {
|
|
if(empty($modulenode->modlights) || empty($modulenode->modlights->module)) return;
|
|
|
|
foreach($modulenode->modlights->module as $modlightnode) {
|
|
if (!isModuleInstalled("$modlightnode->name")) {
|
|
$this->import_Modlight($modlightnode);
|
|
}
|
|
}
|
|
}
|
|
function import_Modlight($modlightnode) {
|
|
global $adb, $table_prefix;
|
|
|
|
$package = new Vtecrm_Package();
|
|
$package->_modulexml = $modlightnode;
|
|
$package->import_Module();
|
|
|
|
// update modlight seq
|
|
$ml_no = str_replace('ModLight','',$modlightnode->name);
|
|
// crmv@198024
|
|
if (is_numeric($ml_no)) {
|
|
if ($adb->table_exist("{$table_prefix}_modlight_seq") == 0) $adb->getUniqueID($table_prefix.'_modlight');
|
|
$res = $adb->query("select id from {$table_prefix}_modlight_seq");
|
|
if ($res && $adb->num_rows($res) > 0) $ml_seq = intval($adb->query_result($res,0,'id'));
|
|
if ($ml_seq < $ml_no) $adb->pquery("update {$table_prefix}_modlight_seq set id = ?", array($ml_no));
|
|
}
|
|
// crmv@198024e
|
|
}
|
|
// crmv@197127e
|
|
}
|