/**
* @static
* @return SugarRelationshipFactory
*/
public static function getInstance()
{
if (is_null(self::$rfInstance)) {
self::$rfInstance = new SugarRelationshipFactory();
}
return self::$rfInstance;
}
function action_DeleteRelationship()
{
if (isset($_REQUEST['relationship_name'])) {
if (empty($_REQUEST['view_package'])) {
require_once 'modules/ModuleBuilder/parsers/relationships/DeployedRelationships.php';
if (!empty($_REQUEST['remove_tables'])) {
$GLOBALS['mi_remove_tables'] = $_REQUEST['remove_tables'];
}
$relationships = new DeployedRelationships($_REQUEST['view_module']);
} else {
$mb = new ModuleBuilder();
$module =& $mb->getPackageModule($_REQUEST['view_package'], $_REQUEST['view_module']);
require_once 'modules/ModuleBuilder/parsers/relationships/UndeployedRelationships.php';
$relationships = new UndeployedRelationships($module->getModuleDir());
}
$relationships->delete($_REQUEST['relationship_name']);
$relationships->save();
require_once "data/Relationships/RelationshipFactory.php";
SugarRelationshipFactory::deleteCache();
}
$this->view = 'relationships';
}
/**
* Updates relationships based on changes to fields of type 'parent' which
* may or may not have links associated with them
*
* @param array $exclude
*/
protected function update_parent_relationships($exclude = array())
{
foreach ($this->field_defs as $def) {
if (!empty($def['type']) && $def['type'] == "parent") {
if (empty($def['type_name']) || empty($def['id_name'])) {
continue;
}
$typeField = $def['type_name'];
$idField = $def['id_name'];
if (in_array($idField, $exclude)) {
continue;
}
//Determine if the parent field has changed.
if (!empty($this->fetched_row[$typeField]) && !empty($this->fetched_row[$idField]) && (empty($this->{$typeField}) || empty($this->{$idField})) || !empty($this->{$typeField}) && !empty($this->{$idField}) && (empty($this->fetched_row[$typeField]) || empty($this->fetched_row[$idField]) || $this->fetched_row[$idField] != $this->{$idField}) || $this->deleted == 1) {
$parentLinks = array();
//Correlate links to parent field module types
foreach ($this->field_defs as $ldef) {
if (!empty($ldef['type']) && $ldef['type'] == "link" && !empty($ldef['relationship'])) {
$relDef = SugarRelationshipFactory::getInstance()->getRelationshipDef($ldef['relationship']);
if (!empty($relDef['relationship_role_column']) && $relDef['relationship_role_column'] == $typeField) {
$parentLinks[$relDef['lhs_module']] = $ldef;
}
}
}
// Save $this->$idField, because it can be resetted in case of link->delete() call
$idFieldVal = $this->{$idField};
//If we used to have a parent, call remove on that relationship
if (!empty($this->fetched_row[$typeField]) && !empty($this->fetched_row[$idField]) && !empty($parentLinks[$this->fetched_row[$typeField]]) && $this->fetched_row[$idField] != $this->{$idField}) {
$oldParentLink = $parentLinks[$this->fetched_row[$typeField]]['name'];
//Load the relationship
if ($this->load_relationship($oldParentLink)) {
$this->{$oldParentLink}->delete($this->fetched_row[$idField]);
// Should resave the old parent
SugarRelationship::addToResaveList(BeanFactory::getBean($this->fetched_row[$typeField], $this->fetched_row[$idField]));
}
}
// If both parent type and parent id are set, save it unless the bean is being deleted
if (!empty($this->{$typeField}) && !empty($idFieldVal) && !empty($parentLinks[$this->{$typeField}]['name']) && $this->deleted != 1) {
//Now add the new parent
$parentLink = $parentLinks[$this->{$typeField}]['name'];
if ($this->load_relationship($parentLink)) {
$this->{$parentLink}->add($idFieldVal);
}
}
}
}
}
}
/**
* The collector method for relationships.
*
* @return array An array of relationships, indexed by the relationship name
*/
public function getRelationshipData()
{
$relFactory = SugarRelationshipFactory::getInstance();
// Request fresh relationship metadata always
$data = $relFactory->getRelationshipDefs(true);
// Sanity check the rel defs, just in case they came back empty
if (is_array($data)) {
// Certain elements of the relationship defs need to be pruned
$unsets = array('table', 'fields', 'indices', 'relationships');
foreach ($data as $relKey => $relData) {
// Prune the relationship defs as needed
foreach ($unsets as $unset) {
unset($relData[$unset]);
}
// Sort each def array for consistency to ensure sameness between
// metadata cache refreshes
ksort($relData);
// Reset the defs for this key
$data[$relKey] = $relData;
}
}
// To maintain hashes between requests, make sure this array is always
// in the same order. Otherwise, the serialized value of this data will
// potentially be different from one request to another.
ksort($data);
$data["_hash"] = $this->hashChunk($data);
return $data;
}
private function deleteRelationship($lhs_module, $rhs_module = null, $rel_name = null)
{
$rhs_module = $rhs_module == null ? $lhs_module : $rhs_module;
$this->relationships = new DeployedRelationships($lhs_module);
$this->relationships->delete($rel_name !== null ? $rel_name : $this->relationship->getName());
$this->relationships->save();
SugarRelationshipFactory::deleteCache();
LanguageManager::clearLanguageCache($lhs_module);
if ($lhs_module != $rhs_module) {
LanguageManager::clearLanguageCache($rhs_module);
}
}
/**
* @param $linkName String name of a link field in the module's vardefs
* @param $bean SugarBean focus bean for this link (one half of a relationship)
* @param $linkDef Array Optional vardef for the link in case it can't be found in the passed in bean for the global dictionary
* @return void
*
*/
function __construct($linkName, $bean, $linkDef = false)
{
$this->focus = $bean;
//Try to load the link vardef from the beans field defs. Otherwise start searching
if (empty($bean->field_defs) || empty($bean->field_defs[$linkName]) || empty($bean->field_defs[$linkName]['relationship'])) {
if (empty($linkDef)) {
//Assume $linkName is really relationship_name, and find the link name with the vardef manager
$this->def = VardefManager::getLinkFieldForRelationship($bean->module_dir, $bean->object_name, $linkName);
} else {
$this->def = $linkDef;
}
//Check if multiple links were found for a given relationship
if (is_array($this->def) && !isset($this->def['name'])) {
//More than one link found, we need to figure out if we are currently on the LHS or RHS
//default to lhs for now
if (isset($this->def[0]['side']) && $this->def[0]['side'] == 'left') {
$this->def = $this->def[0];
} else {
if (isset($this->def[1]['side']) && $this->def[1]['side'] == 'left') {
$this->def = $this->def[1];
} else {
$this->def = $this->def[0];
}
}
}
if (empty($this->def['name'])) {
$GLOBALS['log']->fatal("failed to find link for {$linkName}");
return false;
}
$this->name = $this->def['name'];
} else {
//Linkdef was found in the bean (this is the normal expectation)
$this->def = $bean->field_defs[$linkName];
$this->name = $linkName;
}
//Instantiate the relationship for this link.
$this->relationship = SugarRelationshipFactory::getInstance()->getRelationship($this->def['relationship']);
// Fix to restore functionality from Link.php that needs to be rewritten but for now this will do.
$this->relationship_fields = !empty($this->def['rel_fields']) ? $this->def['rel_fields'] : array();
if (!$this->loadedSuccesfully()) {
global $app_strings;
$GLOBALS['log']->error(string_format($app_strings['ERR_DATABSE_RELATIONSHIP_QUERY'], array($this->name, $this->def['relationship'])));
}
//Following behavior is tied to a property(ignore_role) value in the vardef. It alters the values of 2 properties, ignore_role_filter and add_distinct.
//the property values can be altered again before any requests are made.
if (!empty($this->def) && is_array($this->def)) {
if (isset($this->def['ignore_role'])) {
if ($this->def['ignore_role']) {
$this->ignore_role_filter = true;
$this->add_distinct = true;
}
}
if (!empty($this->def['primary_only'])) {
$this->relationship->primaryOnly = true;
}
}
}
/**
* Remove all created relationships
*
* @static
*/
public static function removeAllCreatedRelationships()
{
foreach (self::$_relsAdded as $rel) {
$relationships = new DeployedRelationships($rel['lhs_module']);
$relationships->delete($rel['relationship_name']);
$relationships->save();
$relationships->build();
LanguageManager::clearLanguageCache($rel['lhs_module']);
require_once "data/Relationships/RelationshipFactory.php";
SugarRelationshipFactory::deleteCache();
SugarRelationshipFactory::rebuildCache();
}
// since we are creating a relationship we need to unset this global var
if (isset($GLOBALS['reload_vardefs'])) {
unset($GLOBALS['reload_vardefs']);
}
}
//// START RELATIONSHIP CREATION
ksort($rel_dictionary);
foreach ($rel_dictionary as $rel_name => $rel_data) {
$table = $rel_data['table'];
if ($setup_db_drop_tables) {
if ($db->tableExists($table)) {
$db->dropTableName($table);
}
}
if (!$db->tableExists($table)) {
$db->createTableParams($table, $rel_data['fields'], isset($rel_data['indices']) ? $rel_data['indices'] : array());
}
SugarBean::createRelationshipMeta($rel_name, $db, $table, $rel_dictionary, '');
}
// Setup the relationship cache and build out the initial vardef cache
SugarRelationshipFactory::rebuildCache();
///////////////////////////////////////////////////////////////////////////////
//// START CREATE DEFAULTS
echo "<br>";
echo "<b>{$mod_strings['LBL_PERFORM_CREATE_DEFAULT']}</b><br>";
echo "<br>";
installLog("Begin creating Defaults");
installerHook('pre_createDefaultSettings');
if ($new_config) {
installLog("insert defaults into config table");
insert_default_settings();
}
installerHook('post_createDefaultSettings');
echo $line_entry_format . $mod_strings['LBL_PERFORM_LICENSE_SETTINGS'] . $line_exit_format;
installLog($mod_strings['LBL_PERFORM_LICENSE_SETTINGS']);
update_license_settings($_SESSION['setup_license_key_users'], $_SESSION['setup_license_key_expire_date'], $_SESSION['setup_license_key'], $_SESSION['setup_num_lic_oc']);
/**
* Updates relationships based on changes to fields of type 'parent' which
* may or may not have links associated with them
*
* @param array $exclude
*/
protected function update_parent_relationships($exclude = array())
{
foreach ($this->field_defs as $def) {
if (!empty($def['type']) && $def['type'] == "parent") {
if (empty($def['type_name']) || empty($def['id_name'])) {
continue;
}
$typeField = $def['type_name'];
$idField = $def['id_name'];
// save the new id
$newIdValue = $this->{$idField};
if (in_array($idField, $exclude)) {
continue;
}
//Determine if the parent field has changed.
if (!empty($this->fetched_row[$typeField]) && !empty($this->fetched_row[$idField]) && (empty($this->{$typeField}) || empty($this->{$idField})) || !empty($this->{$typeField}) && !empty($this->{$idField}) && (empty($this->fetched_row[$typeField]) || empty($this->fetched_row[$idField]) || $this->fetched_row[$idField] != $this->{$idField}) || $this->deleted == 1) {
$parentLinks = array();
//Correlate links to parent field module types
foreach ($this->field_defs as $ldef) {
if (!empty($ldef['type']) && $ldef['type'] == "link" && !empty($ldef['relationship'])) {
$rel = SugarRelationshipFactory::getInstance()->getRelationship($ldef['relationship']);
$relColumns = $rel->getRelationshipRoleColumns();
if (isset($relColumns[$typeField])) {
$parentLinks[$rel->getLHSModule()] = $ldef;
}
}
}
//If we used to have a parent, call remove on that relationship
if (!empty($this->fetched_row[$typeField]) && !empty($this->fetched_row[$idField]) && !empty($parentLinks[$this->fetched_row[$typeField]]) && $this->fetched_row[$idField] != $this->{$idField}) {
$oldParentLink = $parentLinks[$this->fetched_row[$typeField]]['name'];
//Load the relationship
if ($this->load_relationship($oldParentLink)) {
$this->{$oldParentLink}->delete($this->id, $this->fetched_row[$idField]);
// Should resave the old parent, if the current user has access to it and can save it
$beanToSave = BeanFactory::getBean($this->fetched_row[$typeField], $this->fetched_row[$idField]);
if (!empty($beanToSave->id)) {
SugarRelationship::addToResaveList($beanToSave);
}
}
}
// If both parent type and parent id are set, save it unless the bean is being deleted
if (!empty($this->{$typeField}) && !empty($newIdValue) && !empty($parentLinks[$this->{$typeField}]['name']) && $this->deleted != 1) {
//Now add the new parent
$parentLink = $parentLinks[$this->{$typeField}]['name'];
if ($this->load_relationship($parentLink)) {
$this->{$parentLink}->add($newIdValue);
}
}
}
}
}
}
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");
}
/**
* @param $linkName String name of a link field in the module's vardefs
* @param $bean SugarBean focus bean for this link (one half of a relationship)
* @param $linkDef Array Optional vardef for the link in case it can't be found in the passed in bean for the global dictionary
* @return void
*
*/
function __construct($linkName, $bean, $linkDef = false)
{
$this->focus = $bean;
//Try to load the link vardef from the beans field defs. Otherwise start searching
if (empty($bean->field_defs) || empty($bean->field_defs[$linkName]) || empty($bean->field_defs[$linkName]['relationship'])) {
if (empty($linkDef)) {
//Assume $linkName is really relationship_name, and find the link name with the vardef manager
$this->def = VardefManager::getLinkFieldForRelationship($bean->module_dir, $bean->object_name, $linkName);
} else {
$this->def = $linkDef;
}
//Check if multiple links were found for a given relationship
if (is_array($this->def) && !isset($this->def['name'])) {
//More than one link found, we need to figure out if we are currently on the LHS or RHS
//default to lhs for now
if (isset($this->def[0]['side']) && $this->def[0]['side'] == 'left') {
$this->def = $this->def[0];
} else {
if (isset($this->def[1]['side']) && $this->def[1]['side'] == 'left') {
$this->def = $this->def[1];
} else {
$this->def = $this->def[0];
}
}
}
if (empty($this->def['name'])) {
$GLOBALS['log']->fatal("failed to find link for {$linkName}");
return false;
}
$this->name = $this->def['name'];
} else {
//Linkdef was found in the bean (this is the normal expectation)
$this->def = $bean->field_defs[$linkName];
$this->name = $linkName;
}
//Instantiate the relationship for this link.
$this->relationship = SugarRelationshipFactory::getInstance()->getRelationship($this->def['relationship']);
if (!$this->loadedSuccesfully()) {
$GLOBALS['log']->fatal("{$this->name} for {$this->def['relationship']} failed to load\n");
}
//Following behavior is tied to a property(ignore_role) value in the vardef. It alters the values of 2 properties, ignore_role_filter and add_distinct.
//the property values can be altered again before any requests are made.
if (!empty($this->def) && is_array($this->def)) {
if (array_key_exists('ignore_role', $this->def)) {
if ($this->def['ignore_role']) {
$this->ignore_role_filter = true;
$this->add_distinct = true;
}
}
}
}
/**
* Used internally to determine if a field def is a valid link for use in formulas
* @static
* @param $def array, Link field definition.
* @return bool true if field is valid.
*/
protected static function validLinkField($def)
{
global $dictionary;
$invalidModules = array("Emails" => true, "Teams" => true);
if (empty($def['relationship'])) {
return false;
//Not a good link field
}
$rel = SugarRelationshipFactory::getInstance()->getRelationship($def['relationship']);
if ($rel === false) {
return false;
//Unable to find a relationship definition
}
if (!empty($invalidModules[$rel->lhs_module]) || !empty($invalidModules[$rel->rhs_module])) {
return false;
//Invalid module
}
//Otherwise this link looks ok
return true;
}
public static function delete_cache()
{
$filename = Relationship::cache_file_dir() . '/' . Relationship::cache_file_name_only();
if (file_exists($filename)) {
unlink($filename);
}
SugarRelationshipFactory::deleteCache();
// Delete the internal cache as well
self::$relCacheInternal = array();
}
/**
* Find links with wrong relationship.
* @param DefinitionObject $fieldDefs
* @param SugarBean $seed
* @return array Wrong relationships.
*/
protected function checkFieldsRelationships($fieldDefs, $seed)
{
$wrongRelations = array();
foreach ($fieldDefs as $fieldnm => $field) {
// Check for bad links
if ($field['type'] == 'link') {
$seed->load_relationship($field['name']);
$wRel = false;
if (empty($seed->{$field}['name'])) {
$wRel = true;
} else {
if ($this->checkRelationshipDef($field['name'], $seed)) {
// Need to delete cache of TableDictionary to avoid inclusion of deleted files.
if (file_exists('custom/application/Ext/TableDictionary/tabledictionary.ext.php')) {
SugarAutoLoader::unlink('custom/application/Ext/TableDictionary/tabledictionary.ext.php');
}
SugarRelationshipFactory::deleteCache();
SugarRelationshipFactory::rebuildCache();
unset($seed->{$field}['name']);
$seed->load_relationship($field['name']);
}
$relModule = $seed->{$field}['name']->getRelatedModuleName();
$relBean = $this->getBean($relModule);
if (empty($relBean)) {
$wRel = true;
}
}
if ($wRel) {
if (!empty($field['relationship'])) {
$wrongRelations[] = $field['relationship'];
}
$fieldDefs->setWrongDef($fieldnm);
}
}
}
return $wrongRelations;
}
public static function delete_cache()
{
$filename = Relationship::cache_file_dir() . '/' . Relationship::cache_file_name_only();
if (file_exists($filename)) {
unlink($filename);
}
require_once "data/Relationships/RelationshipFactory.php";
SugarRelationshipFactory::deleteCache();
}
public function action_DeleteRelationship()
{
if (isset($_REQUEST['relationship_name'])) {
if (empty($_REQUEST['view_package'])) {
if (!empty($_REQUEST['remove_tables'])) {
$GLOBALS['mi_remove_tables'] = $_REQUEST['remove_tables'];
}
$relationships = new DeployedRelationships($_REQUEST['view_module']);
} else {
$mb = new ModuleBuilder();
$module =& $mb->getPackageModule($_REQUEST['view_package'], $_REQUEST['view_module']);
$relationships = new UndeployedRelationships($module->getModuleDir());
}
$relationships->delete($_REQUEST['relationship_name']);
$relationships->save();
SugarRelationshipFactory::deleteCache();
}
$this->view = 'relationships';
}
function install_relationships()
{
if (isset($this->installdefs['relationships'])) {
$this->log(translate('LBL_MI_IN_RELATIONSHIPS'));
$str = "<?php \n //WARNING: The contents of this file are auto-generated\n";
$save_table_dictionary = false;
if (!file_exists("custom/Extension/application/Ext/TableDictionary")) {
mkdir_recursive("custom/Extension/application/Ext/TableDictionary", true);
}
foreach ($this->installdefs['relationships'] as $key => $relationship) {
$filename = basename($relationship['meta_data']);
$this->copy_path($relationship['meta_data'], 'custom/metadata/' . $filename);
$this->install_relationship('custom/metadata/' . $filename);
$save_table_dictionary = true;
if (!empty($relationship['module_vardefs'])) {
$relationship['module_vardefs'] = str_replace('<basepath>', $this->base_dir, $relationship['module_vardefs']);
$this->install_vardef($relationship['module_vardefs'], $relationship['module']);
}
if (!empty($relationship['module_layoutdefs'])) {
$relationship['module_layoutdefs'] = str_replace('<basepath>', $this->base_dir, $relationship['module_layoutdefs']);
$this->install_layoutdef($relationship['module_layoutdefs'], $relationship['module']);
}
$relName = strpos($filename, "MetaData") !== false ? substr($filename, 0, strlen($filename) - 12) : $filename;
$out = sugar_fopen("custom/Extension/application/Ext/TableDictionary/{$relName}.php", 'w');
fwrite($out, $str . "include('custom/metadata/{$filename}');\n\n?>");
fclose($out);
}
Relationship::delete_cache();
$this->rebuild_vardefs();
$this->rebuild_layoutdefs();
if ($save_table_dictionary) {
$this->rebuild_tabledictionary();
}
require_once "data/Relationships/RelationshipFactory.php";
SugarRelationshipFactory::deleteCache();
}
}
/**
* Doing the same things like setUp but for initialized list of modules
*
* @static
* @return bool are caches refreshed or not
*/
protected static function tearDown_relation()
{
SugarRelationshipFactory::deleteCache();
$modules = array_unique(self::$cleanModules);
foreach ($modules as $module) {
LanguageManager::clearLanguageCache($module);
}
self::tearDown('dictionary');
VardefManager::$linkFields = array();
VardefManager::clearVardef();
foreach ($modules as $module) {
VardefManager::refreshVardefs($module, BeanFactory::getBeanName($module));
}
SugarRelationshipFactory::rebuildCache();
self::$cleanModules = array();
return true;
}
/**
* @group 45339
*/
public function testGetExtensionsList()
{
// Create new relationship between Leads and Accounts
$_REQUEST['view_module'] = "Leads";
$_REQUEST['lhs_module'] = "Leads";
$_REQUEST['rhs_module'] = "Accounts";
$_REQUEST['lhs_label'] = "Leads";
$_REQUEST['rhs_label'] = "Accounts";
$deployedRelation = new DeployedRelationships($_REQUEST['view_module']);
$relationLeadAccount = $deployedRelation->addFromPost();
$deployedRelation->save();
$deployedRelation->build();
//create expected file paths from custom extensions
$accountContactRelInAccountVardefExtensions = sprintf('custom%1$sExtension%1$smodules%1$sAccounts%1$sExt%1$sVardefs%1$s' . $this->relationAccountContact->getName() . '_Accounts.php', DIRECTORY_SEPARATOR);
$contactAccountRelInAccountVardefExtensions = sprintf('custom%1$sExtension%1$smodules%1$sAccounts%1$sExt%1$sVardefs%1$s' . $this->relationContactAccount->getName() . '_Accounts.php', DIRECTORY_SEPARATOR);
$leadAccountRelInAccountVardefExtensions = sprintf('custom%1$sExtension%1$smodules%1$sAccounts%1$sExt%1$sVardefs%1$s' . $relationLeadAccount->getName() . '_Accounts.php', DIRECTORY_SEPARATOR);
$sugarfieldAccountVardefExtensions = sprintf('custom%1$sExtension%1$smodules%1$sAccounts%1$sExt%1$sVardefs%1$s' . 'sugarfield_' . $this->field->name . '.php', DIRECTORY_SEPARATOR);
//call mbPackage to retrieve arrays of Files to be exported using different test parameters
$accountAllExtensions = $this->mbPackage->getExtensionsListTest('Accounts', array('Accounts', 'Contacts', 'Leads'));
$accountExtContacts = $this->mbPackage->getExtensionsListTest('Accounts', array('Accounts', 'Contacts'));
$accountExtOnly = $this->mbPackage->getExtensionsListTest('Accounts', array('Accounts'));
$contactExtWithWrongRelationship = $this->mbPackage->getExtensionsListTest('Contacts', array(''));
$wrongModuleName = $this->mbPackage->getExtensionsListTest('Wrong_module_name');
// Remove relationship
$deployedRelation->delete($relationLeadAccount->getName());
$deployedRelation->save();
SugarRelationshipFactory::deleteCache();
//assert that contact rels are exported when all rels were defined
$this->assertContains($accountContactRelInAccountVardefExtensions, $accountAllExtensions, 'Contact Relationship should have been exported when accounts and contacts modules are exported');
//assert that contact rels are not exported when contact is not defined
$this->assertNotContains($accountContactRelInAccountVardefExtensions, $accountExtOnly, 'Contact Relationship should NOT have been exported when exporting accounts only');
//assert that non relationship change is exported when no related module is defined
$this->assertContains($sugarfieldAccountVardefExtensions, $accountExtOnly, 'Sugarfield change should have been exported when exporting Accounts only');
//assert only contact and Account modules are present when both contact and Accounts are defined
$this->assertContains($accountContactRelInAccountVardefExtensions, $accountExtContacts, 'Accounts rels should be present when exporting Contacts and Accounts');
$this->assertContains($contactAccountRelInAccountVardefExtensions, $accountExtContacts, 'Contacts rels should be present when exporting Contacts and Accounts');
$this->assertNotContains($leadAccountRelInAccountVardefExtensions, $accountExtContacts, 'Leads rels should NOT be present when exporting Contacts and Accounts');
//assert that requesting a wrong relationship returns an empty array
$this->assertInternalType('array', $contactExtWithWrongRelationship, 'array type should be returned when no relationships are exported, and no other changes exist');
$this->assertEmpty($contactExtWithWrongRelationship, 'An empty array should be returned when no relationships are exported, and no other changes exist');
//assert that requesting a wrong module name returns an empty array
$this->assertInternalType('array', $wrongModuleName, 'An array type should be returned when a bad module is requested for export');
$this->assertEmpty($wrongModuleName, 'An empty array should be returned when a bad module is requested for export');
}
/**
* @static
* @param $module String name of module.
* @param $object String name of module Bean.
* Updates a list of link fields which have relationships to modules with calculated fields
* that use this module. Needed to cause an update to those modules when this module is updated.
* @return bool
*/
protected static function updateRelCFModules($module, $object)
{
global $dictionary, $beanList;
if (empty($dictionary[$object]) || empty($dictionary[$object]['fields'])) {
return false;
}
$linkFields = self::getLinkFieldsForModule($module, $object);
if (empty($linkFields)) {
$dictionary[$object]['related_calc_fields'] = array();
return false;
}
$linksWithCFs = array();
foreach ($linkFields as $name => $def) {
$relName = $def['relationship'];
//Start by getting the relation
$relDef = false;
if (!empty($def['module'])) {
$relMod = $def['module'];
} else {
if (!empty($dictionary[$relName]['relationships'][$relName])) {
$relDef = $dictionary[$relName]['relationships'][$relName];
} else {
if (!empty($dictionary[$object][$relName])) {
$relDef = $dictionary[$object][$relName];
} else {
$relDef = SugarRelationshipFactory::getInstance()->getRelationshipDef($relName);
if (!$relDef) {
continue;
}
}
}
if (empty($relDef['lhs_module'])) {
continue;
}
$relMod = $relDef['lhs_module'] == $module ? $relDef['rhs_module'] : $relDef['lhs_module'];
}
if (empty($beanList[$relMod])) {
continue;
}
$relObject = BeanFactory::getObjectName($relMod);
$relLinkFields = self::getLinkFieldsForModule($relMod, $relObject);
if (!empty($relLinkFields)) {
foreach ($relLinkFields as $rfName => $rfDef) {
if ($rfDef['relationship'] == $relName && self::modHasCalcFieldsWithLink($relMod, $relObject, $rfName)) {
$linksWithCFs[$name] = true;
}
}
}
}
$dictionary[$object]['related_calc_fields'] = array_keys($linksWithCFs);
}