public function configSave(ServiceBase $api, $args) { $module = 'dm_Duplicates'; unset($args['__sugar_url']); //acl check, only allow if they are module admin if (!$api->user->isAdmin() && !$api->user->isDeveloperForModule($module)) { // No create access so we construct an error message and throw the exception $failed_module_strings = return_module_language($GLOBALS['current_language'], $module); $moduleName = $failed_module_strings['LBL_MODULE_NAME']; $args = null; if (!empty($moduleName)) { $args = array('moduleName' => $moduleName); } throw new SugarApiExceptionNotAuthorized($GLOBALS['app_strings']['EXCEPTION_CHANGE_MODULE_CONFIG_NOT_AUTHORIZED'], $args); } $admin = BeanFactory::getBean('Administration'); $platform = 'base'; foreach ($args as $name => $value) { if (is_array($value)) { $admin->saveSetting($module, $name, json_encode($value), $platform); } else { $admin->saveSetting($module, $name, $value, $platform); } } if ($this->skipMetadataRefresh === false) { MetaDataManager::refreshModulesCache(array($module)); } return $admin->getConfigForModule($module, $platform, true); }
public function run() { // somehow we missed quick create configuration on upgrade. here we update it too. if (version_compare($this->from_version, '7.6', '<') && is_file('custom/include/DashletContainer/Containers/DCActions.php')) { require_once 'modules/Administration/views/view.configureshortcutbar.php'; $quickCreate = new ViewConfigureshortcutbar(); $modules = $quickCreate->getQuickCreateModules(); $needToUpdate = true; foreach (array_merge($modules['enabled'], $modules['disabled']) as $module => $definition) { // it means that someone already configured that so we don't need to do anything. if (is_file("custom/modules/{$module}/clients/base/menus/quickcreate/quickcreate.php")) { $needToUpdate = false; break; } } if ($needToUpdate) { $DCActions = array(); require 'custom/include/DashletContainer/Containers/DCActions.php'; $DCActions = array_flip($DCActions); $successful = $quickCreate->saveChangesToQuickCreateMetadata($modules['enabled'], $modules['disabled'], $DCActions); if ($successful) { MetaDataManager::refreshSectionCache(array(MetaDataManager::MM_MODULES)); } } } // Only run when coming from a version lower than 7.2. if (version_compare($this->from_version, '7.2', '<')) { $this->fixQuickCreateOrder(); } // Only run when coming from a version lower than 7.6. if (version_compare($this->from_version, '7.6', '<')) { $this->addStickyResizableColumnsFlag('recordlist'); $this->addStickyResizableColumnsFlag('history-summary'); } }
/** * Get the filterable field types and their operators. * * @param string $client The client that you are working on. * @return array The list of filterable field types and their operators. */ public static function getOperators($client = 'base') { $filtersMetadata = MetaDataManager::getManager($client)->getSugarFilters(); if (empty($filtersMetadata['operators']['meta'])) { return array(); } return $filtersMetadata['operators']['meta']; }
public function clearCaches() { //Need to invalidate the caches for rolesets when roles change (availible modules may change) if ($this->load_relationship('acl_role_sets')) { $rolesets = $this->acl_role_sets->getBeans(); $mm = MetaDataManager::getManager(); foreach ($rolesets as $roleset) { $context = new MetaDataContextRoleSet($roleset); $mm->invalidateCache($mm->getPlatformsWithCaches(), $context); } } sugar_cache_clear('ACL'); }
/** * This function allows a user with Forecasts admin rights to reset the Forecasts settings so that the Forecasts wizard * dialog will appear once again. * */ public function action_resetSettings() { global $current_user; if ($current_user->isAdminForModule('Forecasts')) { $db = DBManagerFactory::getInstance(); $db->query("UPDATE config SET value = '0' WHERE category = 'Forecasts' and name in ('is_setup', 'has_commits')"); MetaDataManager::refreshModulesCache(array('Forecasts')); MetaDataManager::refreshSectionCache(array(MetaDataManager::MM_CONFIG)); echo '<script>' . navigateToSidecar(buildSidecarRoute("Forecasts")) . ';</script>'; exit; } $this->view = 'noaccess'; }
function __construct() { parent::SugarView(); global $current_user; if (!$current_user->isDeveloperForModule("Leads")) { die("Unauthorized Access to Administration"); } $this->jsonHelper = getJSONobj(); $this->parser = new ConvertLayoutMetadataParser("Contacts"); if (isset($_REQUEST['updateConvertDef']) && $_REQUEST['updateConvertDef'] && !empty($_REQUEST['data'])) { $this->parser->updateConvertDef(object_to_array_recursive($this->jsonHelper->decode(html_entity_decode_utf8($_REQUEST['data'])))); // clear the cache for this module only MetaDataManager::refreshModulesCache(array('Leads')); } }
/** * Saves $data to the $name dropdown for the $role name * * @param $fieldName * @param $role * @param $data * @return boolean */ public function handleSave($fieldName, $role, $data) { $path = $this->getFilePath($fieldName, $role); $dir = dirname($path); if (!SugarAutoLoader::ensureDir($dir)) { $GLOBALS['log']->error("ParserRoleDropDownFilter :: Cannot create directory {$dir}"); return false; } $result = write_array_to_file("role_dropdown_filters['{$fieldName}']", $this->convertFormData($data), $path); if ($result) { $this->rebuildExtension($role); MetaDataManager::refreshSectionCache(MetaDataManager::MM_EDITDDFILTERS, array(), array('role' => $role)); } return $result; }
function save($df) { // Bug 58560 - Set the group name since addresses are part of a group $this->group = $df->getDBName($this->name); require_once 'modules/ModuleBuilder/parsers/parser.label.php'; $parser = new ParserLabel($df->getModuleName(), $df->getPackageName()); // Clean up the labels so they more accurately reflect the actual field if (!empty($this->label_value)) { $labelValue = $this->label_value; } else { $labelValue = empty($_REQUEST['labelValue']) ? '' : $_REQUEST['labelValue']; } // If there is a label to use, space it here for use below if (!empty($labelValue)) { $labelValue .= ' '; } // To prevent mutilple calls to the metadata api cache rebuilder, queue MetaDataManager::enableCacheRefreshQueue(); // To keep consistency with OOTB address groups, add Street to the fields foreach (array('Street', 'City', 'State', 'PostalCode', 'Country') as $addressFieldName) { $systemLabel = strtoupper("LBL_" . $this->name . '_' . $addressFieldName); // Use the entered label value as a prefix instead of the field name $parser->handleSave(array("label_" . $systemLabel => $labelValue . $addressFieldName), $GLOBALS['current_language']); if ($addressFieldName === 'Street') { $addressField = new TemplateAddressStreet(); $addressField->len = 150; } else { $addressField = new TemplateField(); $addressField->len = $addressFieldName === 'PostalCode' ? 20 : 100; } $addressField->name = $this->name . '_' . strtolower($addressFieldName); $addressField->label = $addressField->vname = $systemLabel; // Bug 58560 - Add the group to this field so it gets written to the custom vardefs $addressField->group = $this->group; // Maintain unified search setting for 'Street' $addressField->supports_unified_search = $addressField == 'Street'; $addressField->save($df); } // Handle the metadata api update now MetaDataManager::runCacheRefreshQueue(); }
/** * @see SugarView::display() */ public function display() { require_once "include/JSON.php"; $json = new JSON(); global $mod_strings; $title = getClassicModuleTitle("Administration", array("<a href='index.php?module=Administration&action=index'>{$mod_strings['LBL_MODULE_NAME']}</a>", translate('LBL_CONFIGURE_SHORTCUT_BAR')), false); $msg = ""; $GLOBALS['log']->info("Administration ConfigureShortcutBar view"); $quickCreateModules = $this->getQuickCreateModules(); //If save is set, save then let the user know if the save worked. if (!empty($_REQUEST['enabled_modules'])) { $toDecode = html_entity_decode($_REQUEST['enabled_modules'], ENT_QUOTES); // get the enabled $enabledModules = array_flip(json_decode($toDecode)); $successful = $this->saveChangesToQuickCreateMetadata($quickCreateModules['enabled'], $quickCreateModules['disabled'], $enabledModules); if ($successful) { MetaDataManager::refreshSectionCache(array(MetaDataManager::MM_MODULES)); echo "true"; } else { echo translate("LBL_SAVE_FAILED"); } } else { $enabled = $this->sortEnabledModules($quickCreateModules['enabled']); $enabled = $this->filterAndFormatModuleList($enabled); ksort($quickCreateModules['disabled']); $disabled = $this->filterAndFormatModuleList($quickCreateModules['disabled']); $this->ss->assign('APP', $GLOBALS['app_strings']); $this->ss->assign('MOD', $GLOBALS['mod_strings']); $this->ss->assign('title', $title); $this->ss->assign('enabled_modules', $json->encode($enabled)); $this->ss->assign('disabled_modules', $json->encode($disabled)); $this->ss->assign('description', translate("LBL_CONFIGURE_SHORTCUT_BAR")); $this->ss->assign('msg', $msg); $returnModule = !empty($_REQUEST['return_module']) ? $_REQUEST['return_module'] : 'Administration'; $returnAction = !empty($_REQUEST['return_action']) ? $_REQUEST['return_action'] : 'index'; $this->ss->assign('RETURN_MODULE', $returnModule); $this->ss->assign('RETURN_ACTION', $returnAction); echo $this->ss->fetch('modules/Administration/templates/ShortcutBar.tpl'); } }
/** * Save the Individual Worksheet * * @return ForecastWorksheet * @throws SugarApiException */ public function save() { require_once 'include/SugarFields/SugarFieldHandler.php'; /* @var $seed ForecastWorksheet */ $seed = BeanFactory::getBean("ForecastWorksheets"); $seed->loadFromRow($this->args); $sfh = new SugarFieldHandler(); foreach ($seed->field_defs as $properties) { $fieldName = $properties['name']; if (!isset($this->args[$fieldName])) { continue; } if (!$seed->ACLFieldAccess($fieldName, 'save')) { // No write access to this field, but they tried to edit it global $app_strings; throw new SugarApiException(string_format($app_strings['SUGAR_API_EXCEPTION_NOT_AUTHORIZED'], array($fieldName, $this->args['module']))); } $type = !empty($properties['custom_type']) ? $properties['custom_type'] : $properties['type']; $field = $sfh->getSugarField($type); if (!is_null($field)) { $field->save($seed, $this->args, $fieldName, $properties); } } // Check if this is the first commit, then save has_commits true to the config table $admin = BeanFactory::getBean('Administration'); $settings = $admin->getConfigForModule('Forecasts'); if (!isset($settings['has_commits']) || !$settings['has_commits']) { $admin->saveSetting('Forecasts', 'has_commits', true, 'base'); MetaDataManager::refreshModulesCache(array('Forecasts')); } $seed->setWorksheetArgs($this->args); // we need to set the parent_type and parent_id so it finds it when we try and retrieve the old records $seed->parent_type = $this->getArg('parent_type'); $seed->parent_id = $this->getArg('parent_id'); $seed->saveWorksheet(); // we have the id, just retrieve the record again $seed = BeanFactory::getBean("ForecastWorksheets", $this->getArg('record')); return $seed; }
function build() { $modulesToBuild = array(); if (!isset($this->relationships[$this->newRelationshipName])) { $GLOBALS['log']->fatal("Could not find a relationship by the name of {$this->newRelationshipName}, you will have to quick repair and rebuild to get the new relationship added."); } else { $newRel = $this->relationships[$this->newRelationshipName]; $newRelDef = $newRel->getDefinition(); $modulesToBuild[$newRelDef['rhs_module']] = true; $modulesToBuild[$newRelDef['lhs_module']] = true; } $basepath = "custom/Extension/modules"; $this->activitiesToAdd = false; // and mark all as built so that the next time we come through we'll know and won't build again foreach ($this->relationships as $name => $relationship) { if ($relationship->readonly()) { continue; } $definition = $relationship->getDefinition(); // activities will always appear on the rhs only - lhs will be always be this module in MB if (strtolower($definition['rhs_module']) == 'activities') { $this->activitiesToAdd = true; $relationshipName = $definition['relationship_name']; foreach (self::$activities as $activitiesSubModuleLower => $activitiesSubModuleName) { $definition['rhs_module'] = $activitiesSubModuleName; $definition['for_activities'] = true; $definition['relationship_name'] = $relationshipName . '_' . $activitiesSubModuleLower; $this->relationships[$definition['relationship_name']] = RelationshipFactory::newRelationship($definition); } unset($this->relationships[$name]); } } $GLOBALS['log']->info(get_class($this) . "->build(): installing relationships"); $MBModStrings = $GLOBALS['mod_strings']; $adminModStrings = return_module_language('', 'Administration'); // required by ModuleInstaller foreach ($this->relationships as $name => $relationship) { if ($relationship->readonly()) { continue; } $relationship->setFromStudio(); $GLOBALS['mod_strings'] = $MBModStrings; $installDefs = parent::build($basepath, "<basepath>", array($name => $relationship)); // and mark as built so that the next time we come through we'll know and won't build again $relationship->setReadonly(); $this->relationships[$name] = $relationship; // now install the relationship - ModuleInstaller normally only does this as part of a package load where it installs the relationships defined in the manifest. However, we don't have a manifest or a package, so... // If we were to chose to just use the Extension mechanism, without using the ModuleInstaller install_...() methods, we must : // 1) place the information for each side of the relationship in the appropriate Ext directory for the module, which means specific $this->save...() methods for DeployedRelationships, and // 2) we must also manually add the relationship into the custom/application/Ext/TableDictionary/tabledictionary.ext.php file as install_relationship doesn't handle that (install_relationships which requires the manifest however does) // Relationships must be in tabledictionary.ext.php for the Admin command Rebuild Relationships to reliably work: // Rebuild Relationships looks for relationships in the modules vardefs.php, in custom/modules/<modulename>/Ext/vardefs/vardefs.ext.php, and in modules/TableDictionary.php and custom/application/Ext/TableDictionary/tabledictionary.ext.php // if the relationship is not defined in one of those four places it could be deleted during a rebuilt, or during a module installation (when RebuildRelationships.php deletes all entries in the Relationships table) // So instead of doing this, we use common save...() methods between DeployedRelationships and UndeployedRelationships that will produce installDefs, // and rather than building a full manifest file to carry them, we manually add these installDefs to the ModuleInstaller, and then // individually call the appropriate ModuleInstaller->install_...() methods to take our relationship out of our staging area and expand it out to the individual module Ext areas $GLOBALS['mod_strings'] = $adminModStrings; require_once 'ModuleInstall/ModuleInstaller.php'; $mi = new ModuleInstaller(); $mi->id_name = 'custom' . $name; // provide the moduleinstaller with a unique name for this relationship - normally this value is set to the package key... $mi->installdefs = $installDefs; $mi->base_dir = $basepath; $mi->silent = true; VardefManager::clearVardef(); $mi->install_relationships(); $mi->install_languages(); $mi->install_vardefs(); $mi->install_layoutdefs(); $mi->install_extensions(); $mi->install_client_files(); } $GLOBALS['mod_strings'] = $MBModStrings; // finally, restore the ModuleBuilder mod_strings // Anything that runs in-process needs to reload their vardefs $GLOBALS['reload_vardefs'] = true; // save out the updated definitions so that we keep track of the change in built status // sending false so we don't rebuild relationshsips for a third time. $this->save(false); $mi = new ModuleInstaller(); $mi->silent = true; $mi->rebuild_relationships($modulesToBuild); // now clear all caches so that our changes are visible require_once 'modules/Administration/QuickRepairAndRebuild.php'; $rac = new RepairAndClear(); $rac->module_list = $modulesToBuild; $rac->clearJsFiles(); $rac->clearVardefs(); $rac->clearJsLangFiles(); $rac->clearLanguageCache(); $rac->rebuildExtensions(array_keys($modulesToBuild)); $rac->clearVardefs(); foreach ($rac->module_list as $moduleName => $ignore) { // Now rebuild the vardefs in memory $bean = BeanFactory::newBean($moduleName); VardefManager::loadVardef($bean->module_dir, $bean->object_name, true, array('bean' => $bean)); } foreach (array_keys($modulesToBuild) as $module) { unset($GLOBALS['dictionary'][BeanFactory::getObjectName($module)]); } SugarRelationshipFactory::rebuildCache(); MetaDataManager::refreshLanguagesCache(array($GLOBALS['current_language'])); MetaDataManager::refreshSectionCache(array(MetaDataManager::MM_RELATIONSHIPS)); MetaDataManager::refreshModulesCache(array_keys($modulesToBuild)); $GLOBALS['log']->info(get_class($this) . "->build(): finished relationship installation"); }
function uninstall($base_dir) { global $app_strings; $total_steps = 5; //min steps with no tasks $current_step = 0; $this->base_dir = $base_dir; $tasks = array('pre_uninstall', 'uninstall_relationships', 'uninstall_copy', 'uninstall_dcactions', 'uninstall_dashlets', 'uninstall_connectors', 'uninstall_layoutfields', 'uninstall_extensions', 'uninstall_global_search', 'uninstall_filters', 'disable_manifest_logichooks', 'post_uninstall'); $total_steps += count($tasks); //now the real number of steps if (file_exists($this->base_dir . '/manifest.php')) { if (!$this->silent) { $current_step++; display_progress_bar('install', $current_step, $total_steps); echo '<div id ="displayLoglink" ><a href="#" onclick="toggleDisplay(\'displayLog\')">' . $app_strings['LBL_DISPLAY_LOG'] . '</a> </div><div id="displayLog" style="display:none">'; } global $moduleList; $data = $this->readManifest(); extract($data); $this->installdefs = $installdefs; $this->id_name = $this->installdefs['id']; $installed_modules = array(); if (isset($this->installdefs['beans'])) { foreach ($this->installdefs['beans'] as $bean) { $installed_modules[] = $bean['module']; $this->uninstall_user_prefs($bean['module']); } $this->modulesInPackage = $installed_modules; $this->uninstall_beans($installed_modules); $this->uninstall_customizations($installed_modules); if (!$this->silent) { $current_step++; update_progress_bar('install', $total_steps, $total_steps); } } if (!$this->silent) { $current_step++; update_progress_bar('install', $current_step, $total_steps); } foreach ($tasks as $task) { $this->{$task}(); $this->reset_file_cache(); if (!$this->silent) { $current_step++; update_progress_bar('install', $current_step, $total_steps); } } if (isset($installdefs['custom_fields']) && (isset($GLOBALS['mi_remove_tables']) && $GLOBALS['mi_remove_tables'])) { $this->log(translate('LBL_MI_UN_CUSTOMFIELD')); $this->uninstall_custom_fields($installdefs['custom_fields']); } if (!$this->silent) { $current_step++; update_progress_bar('install', $current_step, $total_steps); echo '</div>'; } //since we are passing $silent = true to rebuildAll() in that method it will set $this->silent = true, so //we need to save the setting to set it back after rebuildAll() completes. $silentBak = $this->silent; $this->rebuild_all(true); $this->silent = $silentBak; //#27877, If the request from MB redeploy a custom module , we will not remove the ACL actions for this package. if (!isset($_REQUEST['action']) || $_REQUEST['action'] != 'DeployPackage') { $this->remove_acl_actions(); } //end if (!$this->silent) { $current_step++; update_progress_bar('install', $current_step, $total_steps); echo '</div>'; } $this->updateSystemTabs('Restore', $installed_modules); //clear the unified_search_module.php file require_once 'modules/Home/UnifiedSearchAdvanced.php'; UnifiedSearchAdvanced::unlinkUnifiedSearchModulesFile(); // Destroy all metadata caches and rebuild the base metadata. This // will cause a small amount of lag on subsequent requests for other // clients. MetaDataManager::clearAPICache(true, true); MetaDataManager::setupMetadata(); require_once 'include/api/ServiceDictionaryRest.php'; $dict = new ServiceDictionaryRest(); $dict->buildAllDictionaries(); $this->log('<br><b>' . translate('LBL_MI_COMPLETE') . '</b>'); if (!$this->silent) { update_progress_bar('install', $total_steps, $total_steps); } } else { die("No manifest.php Defined In {$this->base_dir}/manifest.php"); } }
/** * Clears mobile and portal metadata caches that have been created by the API * to allow immediate rendering of changes at the client */ protected function _clearCaches() { if ($this->implementation->isDeployed()) { MetaDataFiles::clearModuleClientCache($this->_moduleName, 'view'); // Clear out the cache just for the platform we are on $client = empty($this->client) ? 'base' : $this->client; MetaDataManager::refreshModulesCache(array($this->_moduleName), array($client), $this->implementation->getParams()); parent::_clearCaches(); } }
/** * This function prebuilds the metadata cache * * The cache is prebuilt only for en_us and base platform for now. */ public function prewarmCache() { //Now that installation is complete, we need to set this to false to have the caches build correctly $GLOBALS['installing'] = false; $this->log("Populating metadata cache"); $GLOBALS['app_list_strings'] = return_app_list_strings_language('en_us'); require_once 'include/MetaDataManager/MetaDataManager.php'; MetaDataManager::setupMetadata(array('base'), array('en_us')); $this->log("Metadata cache populated"); }
/** * Same as SugarBean::mark_deleted except clears api cache. * @param $id */ public function mark_deleted($id) { sugar_cache_clear('currency_list'); $return = parent::mark_deleted($id); // The per-module cache doesn't need to be cleared here MetaDataManager::refreshSectionCache(array(MetaDataManager::MM_CURRENCIES)); }
/** * Processes layout field by collecting its display parameters and processing nested fields * * @param MetaDataManager $metaDataManager Metadata manager * @param array $field The field being processed * @param array $fieldDefs Field definitions of the module the layout belongs to * @param array $fields Resulting set of fields * @param array $displayParams Resulting display parameters */ public function processLayoutField(MetaDataManager $metaDataManager, array $field, array $fieldDefs, array &$fields, array &$displayParams) { $isNamedField = isset($field['name']); if ($isNamedField) { $displayParams[$field['name']] = $field; unset($displayParams[$field['name']]['name']); } $fieldAttributes = array('fields', 'related_fields'); foreach ($fieldAttributes as $attribute) { if (isset($field[$attribute]) && is_array($field[$attribute])) { $fields = array_merge($fields, $metaDataManager->getFieldNames($field[$attribute], $fieldDefs, $displayParams)); if ($isNamedField) { unset($displayParams[$field['name']][$attribute]); } } } }
/** * Clears mobile and portal metadata caches that have been created by the API * to allow immediate rendering of changes at the client */ protected function _clearCaches() { if ($this->implementation->isDeployed()) { // Installing and trying to refresh the modules cache is bad juju if (!empty($GLOBALS['installing'])) { // Use the clear NOW method so that if there is a cache it is wiped MetaDataManager::clearAPICache(true, true); } else { MetaDataManager::refreshModulesCache(array($this->_moduleName)); } parent::_clearCaches(); } }
public function deploy($defs) { // We are saving to the custom file $savefile = $this->getMetadataFilename(MB_CUSTOMMETADATALOCATION); // Simple validation and sanity checking if (!is_dir(dirname($savefile))) { if (!sugar_mkdir(dirname($savefile), null, true)) { throw new Exception("Cannot create directory for {$savefile}"); } } // Handle history if ($this->loadedMetadataFile === MB_HISTORYMETADATALOCATION) { $types = array(MB_WORKINGMETADATALOCATION, MB_CUSTOMMETADATALOCATION, MB_BASEMETADATALOCATION); foreach ($types as $type) { $file = $this->getMetadataFilename($type); if (file_exists($file)) { $this->_history->append($file); break; } } } else { $this->_history->append($this->loadedMetadataFile); } $this->_viewdefs = $defs; // Now save the actual data write_array_to_file("viewdefs['{$this->_moduleName}']['{$this->_viewClient}']['filter']['default']", $this->_viewdefs, $savefile); // Delete the working file if exists as we do in DeployedMetaDataImplementation $workingFilename = $this->getMetadataFilename(MB_WORKINGMETADATALOCATION); if (file_exists($workingFilename)) { SugarAutoLoader::unlink($workingFilename); } // clear the cache for this module MetaDataManager::refreshModulesCache(array($this->_moduleName)); }
/** * Save function responsible executing all sub-save functions required to rename a module. * * @return void */ public function save($redirect = TRUE) { global $locale; if (!empty($_REQUEST['dropdown_lang'])) { $this->selectedLanguage = $_REQUEST['dropdown_lang']; } else { $this->selectedLanguage = $locale->getAuthenticatedUserLanguage(); } //Clear all relevant language caches $this->clearLanguageCaches(); //Retrieve changes the user is requesting and store previous values for future use. $this->changedModules = $this->getChangedModules(); // Queue the metadata manager so that writes and rewrites only happen once MetaDataManager::enableCacheRefreshQueue(); //Change module, appStrings, subpanels, and related links. $this->changeAppStringEntries()->changeAllModuleModStrings()->renameAllRelatedLinks()->renameAllSubpanels()->renameAllDashlets()->changeStringsInRelatedModules()->changeGlobalAppStrings(); // Run the metadata cache refresh queue so changes take effect MetaDataManager::runCacheRefreshQueue(); //Refresh the page again so module tabs are changed as the save process happens after module tabs are already generated. if ($redirect) { echo "\n <script>\n var app = window.parent.SUGAR.App;\n app.api.call('read', app.api.buildURL('ping'));\n </script>"; } }
/** * Add a set of labels to the language pack for a module, deployed or undeployed * * @param string $language Language key, for example 'en_us' * @param array $labels The labels to add in the form of an array of System label => Display label pairs * @param string $moduleName Name of the module to which to add these labels * @param string $basepath Basepath to the file to be written to */ public static function addLabels($language, $labels, $moduleName, $basepath = null) { $GLOBALS['log']->debug("ParserLabel->addLabels({$language}, \$labels, {$moduleName}, {$basepath});"); $GLOBALS['log']->debug("\$labels:" . print_r($labels, true)); $deployedModule = false; if (is_null($basepath)) { $deployedModule = true; $basepath = "custom/Extension/modules/{$moduleName}/Ext/Language"; if (!SugarAutoLoader::fileExists($basepath)) { mkdir_recursive($basepath); } } $filename = "{$basepath}/{$language}.lang.php"; $mod_strings = array(); $changed = false; if (SugarAutoLoader::fileExists($basepath)) { if (SugarAutoLoader::fileExists($filename)) { // Get the current $mod_strings include $filename; } foreach ($labels as $key => $value) { if (!isset($mod_strings[$key]) || strcmp($value, $mod_strings[$key]) != 0) { // Must match encoding used in view.labels.php $mod_strings[$key] = to_html(strip_tags(from_html($value))); $changed = true; } } } else { $changed = true; } if (!empty($mod_strings) && $changed) { $GLOBALS['log']->debug("ParserLabel->addLabels: writing new mod_strings to {$filename}"); $GLOBALS['log']->debug("ParserLabel->addLabels: mod_strings=" . print_r($mod_strings, true)); $write = "<?php\n// WARNING: The contents of this file are auto-generated.\n"; // We can't use normal array writing here since multiple files can be // structured differently. This is dirty, yes, but necessary. foreach ($mod_strings as $k => $v) { $write .= "\$mod_strings['{$k}'] = " . var_export($v, 1) . ";\n"; } if (!SugarAutoLoader::put($filename, $write, true)) { $GLOBALS['log']->fatal("Could not write {$filename}"); } else { // if we have a cache to worry about, then clear it now if ($deployedModule) { SugarCache::cleanOpcodes(); $GLOBALS['log']->debug("PaserLabel->addLabels: clearing language cache"); self::rebuildLanguageExtensions($language, $moduleName); $cache_key = "module_language." . $language . $moduleName; sugar_cache_clear($cache_key); LanguageManager::clearLanguageCache($moduleName, $language); MetaDataManager::refreshLanguagesCache($language); } } } return true; }
/** * Removes the metadata files for all known studio layouts. * * @return html output record of the files deleted */ function removeCustomLayouts() { $module = StudioModuleFactory::getStudioModule($this->module); $sources = $module->getViewMetadataSources(); $out = ""; // list of existing platforms including BWC $platforms = MetaDataManager::getPlatformList(); array_unshift($platforms, ''); // Flag to tell the autoloader whether to save itself or not when done $saveMap = false; foreach ($sources as $view) { foreach ($platforms as $platform) { $file = MetaDataFiles::getDeployedFileName($view['type'], $this->module, MB_CUSTOMMETADATALOCATION, $platform); // Ensure we are working on files that the autoloader knows about if (SugarAutoLoader::fileExists($file)) { // Since we are in a loop inside of a loop do NOT send the // save flag as true to unlink() but be sure to save the file // map after the process is finished so that all changes to // the map are saved. SugarAutoLoader::unlink($file); $out .= "Removed layout {$view['type']}.php<br/>"; // Tell the autoloader to save itself $saveMap = true; } } } // now clear the cache include_once 'include/TemplateHandler/TemplateHandler.php'; TemplateHandler::clearCache($this->module); // If the file map needs saving, handle that now if ($saveMap) { SugarAutoLoader::saveMap(); } return $out; }
/** * Update the metadata depending on what we are forecasting on * * @param String $forecast_by The Module that we are currently forecasting by */ public function updateConfigWorksheetColumnsMetadata($forecast_by) { if ($forecast_by === 'RevenueLineItems') { $contents = "<?php\n\n"; $key = "viewdefs['Forecasts']['base']['view']['config-worksheet-columns']['panels'][0]['fields']"; foreach ($this->rli_worksheet_columns as $val) { $contents .= override_value_to_string_recursive2($key, $val['name'], $val, false); } sugar_file_put_contents($this->module_ext_path . DIRECTORY_SEPARATOR . $this->columns_ext_file, $contents); } else { if (SugarAutoLoader::fileExists($this->module_ext_path . DIRECTORY_SEPARATOR . $this->columns_ext_file)) { SugarAutoLoader::unlink($this->module_ext_path . DIRECTORY_SEPARATOR . $this->columns_ext_file); } } $this->runRebuildExtensions(array('Forecasts')); MetaDataManager::refreshModulesCache('Forecasts'); }
/** * action_saveglobalsearchsettings * * This method handles saving the selected modules to display in the Global Search Settings. * It instantiates an instance of UnifiedSearchAdvanced and then calls the saveGlobalSearchSettings * method. * */ public function action_saveglobalsearchsettings() { global $current_user, $app_strings; if (!is_admin($current_user)) { sugar_die($GLOBALS['app_strings']['ERR_NOT_ADMIN']); } try { require_once 'modules/Home/UnifiedSearchAdvanced.php'; $unifiedSearchAdvanced = new UnifiedSearchAdvanced(); $unifiedSearchAdvanced->saveGlobalSearchSettings(); //Save FTS Settings $type = !empty($_REQUEST['type']) ? $_REQUEST['type'] : ''; $host = !empty($_REQUEST['host']) ? $_REQUEST['host'] : ''; $port = !empty($_REQUEST['port']) ? $_REQUEST['port'] : ''; $ftsConfig = $this->mergeFtsConfig($type, array('port' => $port, 'host' => $host)); $this->cfg = new Configurator(); $this->cfg->config['full_text_engine'] = ''; $this->cfg->saveConfig(); $ftsConnectionValid = TRUE; if (!empty($type)) { //Check if the connection is valid on save: require_once 'include/SugarSearchEngine/SugarSearchEngineFactory.php'; $searchEngine = SugarSearchEngineFactory::getInstance($type, $ftsConfig); $result = $searchEngine->getServerStatus(); if (!$result['valid']) { $ftsConnectionValid = FALSE; } // bug 54274 -- only bother with an override if we have data to place there, empty string breaks Sugar On-Demand! $ftsConfig['valid'] = $ftsConnectionValid; $this->cfg->config['full_text_engine'] = array($type => $ftsConfig); $this->cfg->handleOverride(); } // Refresh the server info & module list sections of the metadata MetaDataManager::refreshSectionCache(array(MetaDataManager::MM_SERVERINFO, MetaDataManager::MM_MODULES)); if (!$ftsConnectionValid) { echo $GLOBALS['mod_strings']['LBL_FTS_CONNECTION_INVALID']; } else { echo "true"; } } catch (Exception $ex) { echo "false"; } }
} } else { $bottleMsg = $mod_strings['LBL_PERFORM_SUCCESS']; } installerHook('post_installModules'); installerHook('pre_handleMissingSmtpServerSettingsNotifications'); handleMissingSmtpServerSettingsNotifications(); installerHook('post_handleMissingSmtpServerSettingsNotifications'); // rebuild cache after all is said and done installLog("Populating file cache"); SugarAutoLoader::buildCache(); // Build the base platform metadata caches after everything else is done. installLog("Populating metadata cache"); MetaDataManager::enableCache(); $app_list_strings = return_app_list_strings_language('en_us'); MetaDataManager::setupMetadata(array('base'), array('en_us')); // TODO: Remove the following. (See MAR-1314) // Restore the activity stream behaviour. Activity::enable(); installerHook('post_performSetup'); $out = <<<EOQ <br><p><b>{$mod_strings['LBL_PERFORM_OUTRO_1']} {$setup_sugar_version} {$mod_strings['LBL_PERFORM_OUTRO_2']}</b></p> {$mod_strings['LBL_PERFORM_OUTRO_3']} {$deltaTime} {$mod_strings['LBL_PERFORM_OUTRO_4']}<br /> {$memoryUsed} {$errTcpip} </td> </tr> <tr> <td align="right" colspan="2"> <hr>
/** * Temporarily disables metadata caching */ public static function disableCache() { self::$isCacheEnabled = false; }
/** * Saves the company logo to the custom directory for the default theme, so all themes can use it * * @param string $path path to the image to set as the company logo image */ function saveCompanyLogo($path) { $path = $this->checkTempImage($path); $logo = create_custom_directory(SugarThemeRegistry::current()->getDefaultImagePath() . '/company_logo.png'); copy($path, $logo); SugarAutoLoader::addToMap($logo); sugar_cache_clear('company_logo_attributes'); SugarThemeRegistry::clearAllCaches(); SugarThemeRegistry::current()->clearImageCache('company_logo.png'); MetaDataManager::refreshSectionCache(array(MetaDataManager::MM_LOGOURL)); }
/** * Retrieve white listed properties which shall be copied from server side * configurations to client side configurations. * * @return array Configuration properties. */ protected function getConfigProperties() { $properties = parent::getConfigProperties(); $properties['offlineEnabled'] = true; return $properties; }
/** * Gets the metadata manager for this user and platform * * @return MetaDataManager */ protected function getMetadataManager() { return MetaDataManager::getManager(array($this->platform)); }
/** * Gets a MetaDataManager object * @param string $platform The platform to get the manager for * @param boolean $public Flag to describe visibility for metadata * @return MetaDataManager */ protected function getMetaDataManager($platform = '', $public = false) { return MetaDataManager::getManager($platform, $public); }
public function action_listViewSave() { $GLOBALS['log']->info("action_listViewSave"); if (isset($_REQUEST['PORTAL'])) { $this->view = 'portallistview'; $parser = ParserFactory::getParser($this->view, $_REQUEST['view_module'], null, null, MB_PORTAL); //$parser->init ( $_REQUEST [ 'view_module' ] ) ; // removed init because MetaDataParsers don't use it } else { $packageName = isset($_REQUEST['view_package']) && strtolower($_REQUEST['view_package']) != 'studio' ? $_REQUEST['view_package'] : null; $subpanelName = !empty($_REQUEST['subpanel']) ? $_REQUEST['subpanel'] : null; $parser = ParserFactory::getParser($_REQUEST['view'], $_REQUEST['view_module'], $packageName, $subpanelName); $this->view = 'listView'; // To make sure that dashlets can render customized list views on BWC // modules, we need to save list customizations for BWC modules in // the new style as well. if (isModuleBWC($_REQUEST['view_module']) && empty($packageName) && empty($subpanelName)) { $sidecarListParser = new SidecarListLayoutMetaDataParser(MB_SIDECARLISTVIEW, $_REQUEST['view_module'], null, 'base'); $sidecarListParser->handleSave(); } } // for backwards compatibility we need to parse the subpanel the old way as well // TODO: Remove this when all BWC Modules are converted if ($parser instanceof SidecarSubpanelLayoutMetaDataParser) { require_once 'modules/ModuleBuilder/parsers/views/SubpanelMetaDataParser.php'; $oldSubpanelParser = new SubpanelMetaDataParser($subpanelName, $_REQUEST['view_module'], $packageName); $oldSubpanelParser->handleSave(); unset($oldSubpanelParser); } $parser->handleSave(); if (empty($packageName) && !empty($subpanelName)) { $rr = new RepairAndClear(); $rr->show_output = false; $rr->rebuildExtensions(); } // clear the cache for the linked module and requested module MetaDataManager::refreshModulesCache($parser->getAffectedModules()); }