Inherited by APIUpgradeManager, ActivityTrackerUpgradeManager, ArticleUpgradeManager, AttachmentUpgradeManager, AutoLoginUpgradeManager, BlogUpgradeManager, BookmarkUpgradeManager, CalendarUpgradeManager, ClassificationUpgradeManager, CommentUpgradeManager, ComponentUpgradeManager, ConnectableUpgradeManager, ContextHelpUpgradeManager, DataSyncUpgradeManager, DocumentUpgradeManager, EmailUpgradeManager, ErrorLogUpgradeManager, FileshareUpgradeManager, ForumUpgradeManager, GlossaryUpgradeManager, HtmlEditorUpgradeManager, ImageUpgradeManager, LinkLibraryUpgradeManager, LoginUpgradeManager, MenuUpgradeManager, ModuleUpgradeManager, OnlineHelpUpgradeManager, OpenDataUpgradeManager, PageUpgradeManager, ProcessUpgradeManager, QuestionnaireUpgradeManager, RatingUpgradeManager, RedirectUpgradeManager, ReportManagerUpgradeManager, RoleUpgradeManager, RssFeedUpgradeManager, ScheduledTaskUpgradeManager, ScrollUpgradeManager, SectionUpgradeManager, SessionPersistenceUpgradeManager, SettingsUpgradeManager, SharingUpgradeManager, SiteMapUpgradeManager, SiteUpgradeManager, SurveyUpgradeManager, SvgChartsUpgradeManager, TaxonomyUpgradeManager, TextLookupUpgradeManager, ToolHintsUpgradeManager, UserUpgradeManager, VersionedContentUpgradeManager, and VideoUpgradeManager.

Public Member Functions
	UpgradeManager ()

	upgrade ($upgrade_to="")

	upgradeOneVersion ($version_number, $function)

	executeVersionSql ($version_number)

	parseSQLStatements ($lines)

	executeSQLStatements ($sqlStatements)

	log ($text)

	executeVersionXML ($version)

	recordUpdate ($version, $description)

	saveLogFile ($version)

	addSectionContent ($items, $section_name="/", $role="", $template="", $permissions="")
	Utility function for use by calling classes to add an array of items of class Page, ComponentPage, Blog, ImageGallery, DocumentLibrary, Calendar to a section. More...

	addModuleToPages ($items, $module_name, $position='right', $sort_order=1)
	Given an array of either identifiers that must be either CMS Page or ComponentPage identifiers or items that are of obj CMSPage, Blog, Calendar, etc., link each to the specified module. More...

	searchByIdentifier ($identifier)

	addMenuItem ($item, $menu_identifier, $parent_identifier="", $title="", $section_name="", $sort_order=0)

	reformatPhone (&$item, $field)

	executeSQLFile ($sqlFile, $version_number)

	dependsOn ($component, $version)

Static Public Member Functions
static	upgradeComponentToVersion ($component, $version)

Public Attributes
	$sqlFile

	$xmlDir

	$component_name

	$log

Detailed Description

Definition at line 191 of file upgrade_manager.inc.

Member Function Documentation

◆ addMenuItem()

UpgradeManager::addMenuItem	(	$item,
		$menu_identifier,
		$parent_identifier = `""`,
		$title = `""`,
		$section_name = `""`,
		$sort_order = `0`
	)

Definition at line 693 of file upgrade_manager.inc.

      {                   
           // Find the menu
           $menus = Query::create(Menu, "WHERE identifier=:identifier")
                ->bind(":identifier", $menu_identifier)
                ->execute();
                
           if(count($menus) == 0)
                return false;
           else
                $menu = $menus[0];
                
           if(!is_object($item))
           {
                $page = $this->searchByIdentifier($item);
                if(!$page) return false;
           }
           else
                $page = $item;
                               
           $found = Query::create(MenuItem, "WHERE (identifier=:identifier OR url like '%{$page->identifier}') AND menu_id=:menu_id")
                ->bind(":identifier", $page->identifier, ":menu_id", $menu->menu_id)
                ->executeValue("COUNT(1)");
  
           if($found)
           {
                $this->log .= "Page identifier {$page->identifier} already linked to menu {$menu_identifier}\r\n";
                return true;
           }
           
           $parent_id = 0;
           
           if($parent_identifier)
           {
                $parents = Query::create(MenuItem, "WHERE identifier=:identifier")
                     ->bind(":identifier", $parent_identifier)
                     ->execute();
  
                if(count($parents) > 0)
                     $parent_id = $parents[0]->menu_item_id;
           }
           
           if(!$sort_order)
           {
                $sort_order = (Query::create(MenuItem, "WHERE menu_id=:menu_id AND parent_id=:parent_id")
                     ->bind(":menu_id", $menu->menu_id, ":parent_id", $parent_id)
                     ->executeValue("MAX(sort_order)") + 1);
           }
           
           if(!$section_name)
           {
                $sections = Query::create(SectionContent, "WHERE identifier=:identifier")
                     ->bind(":identifier", $page->identifier)
                     ->execute();
  
                if(count($sections) == 0)
                {
                     trace("UpgradeManager error: page {$page->identifier} is not in section content", 3);
                     return false;  
                }
  
                $section_name = $sections[0]->Section()->section;
           }
           
           $menuItem = new MenuItem();
           $menuItem->title = ($title) ? $title : prettify($page->identifier);
           $menuItem->menu_id = $menu->menu_id;
           $menuItem->parent_id = $parent_id;
           $menuItem->published = 1;
           $menuItem->url =  "/" . $section_name . "/" . $page->identifier;
           $menuItem->role = $page->role;
           $menuItem->identifier = $page->identifier;
           $menuItem->sort_order = $sort_order;
           $menuItem->page_id = 0;
           $menuItem->save();
           
           $this->log .= $page->format("Adding menu item {identifier} to menu {$menu->name}\r\n");   
      
           return true;
      }

◆ addModuleToPages()

UpgradeManager::addModuleToPages	(	$items,
		$module_name,
		$position = `'right'`,
		$sort_order = `1`
	)

Given an array of either identifiers that must be either CMS Page or ComponentPage identifiers or items that are of obj CMSPage, Blog, Calendar, etc., link each to the specified module.

Definition at line 588 of file upgrade_manager.inc.

      {
           if($items && !is_array($items))
                $items = array($items);
                
           if(count($items) == 0)
                return true;
                
           $modules = Query::create(Module, "WHERE title=:title")
           ->bind(":title", $module_name)
           ->execute();
                
           if(count($modules) == 0)
                return false;
           else
                $module = $modules[0];
  
           foreach($items as $item)
           {
                if(!is_object($item))
                {
                     $page = $this->searchByIdentifier($item);
                     if(!$page) return false;
                }
                else
                     $page = $item;
  
                $xref_class = (preg_match("/component/i", (get_class($page)))) ? ComponentPageModuleXref : PageModuleXref; 
                $xref = new $xref_class();
                $pk = $page->getPrimaryKey();
  
                $found = Query::create($xref_class, "WHERE $pk=:$pk AND module_id=:module_id")
                     ->bind(":$pk", $page->$pk, ":module_id", $module->module_id)
                     ->executeValue("COUNT(1)");
           
                if(!$found)
                {
                     $xref->$pk = $page->$pk;
                     $xref->module_id = $module->module_id;
                     $xref->position = $position;
                     $xref->sort_order = $sort_order;
                     $xref->save();
                     $this->log .= $page->format("Adding $xref_class record for page {identifier} to module {$module->title}\r\n");     
                }
                else
                {
                     $this->log .= "Page identifier $identifier already linked to module {$module->title}\r\n";
                }    
           }
                
           return true;
      }

◆ addSectionContent()

UpgradeManager::addSectionContent	(	$items,
		$section_name = `"/"`,
		$role = `""`,
		$template = `""`,
		$permissions = `""`
	)

Utility function for use by calling classes to add an array of items of class Page, ComponentPage, Blog, ImageGallery, DocumentLibrary, Calendar to a section.

@items can be any of the following: 1) array of CMS Page, Component Page, Blog, ImageGallery, DocumentLibrary, or Calendar DataItem objects 2) a single DataItem obj of any of the above types 3) array of CMS Page or Component page identifiers 4) a single CMS Page or Component Page identifier

Alternatively, $items can be an array of identifiers or a single identifier as long as the identifiers are a CMS Page or Component Page.

We find the section based on the section name, and query the existing content to avoid adding the identifier twice.

If the page is found, its role and template, are updated, if an update is provided.

Definition at line 514 of file upgrade_manager.inc.

      {
           if($items && !is_array($items))
                $items = array($items);
                
           if(count($items) == 0)
           {
                trace("No items found to add to section", 2);
                return true;
           }
           
           $sections = Query::create(Section, "WHERE section=:section")
           ->bind(":section", $section_name)
           ->execute();
                
           if(count($sections) == 0)
           {
                trace("UpgradeManager::addSectionContent - section $section_name not found", 3);
                return false;
           }
           else
                $section = $sections[0];
                
           foreach($items as $item)
           {
                if (is_object($item))
                {
                     $ident = $item->identifier;
                }
                else
                {
                     $ident = $item;
                }
                
                // should be only one or none
                $contents = Query::create(SectionContent, "WHERE identifier=:identifier AND section_id=:section_id")
                     ->bind(":identifier", $ident, ":section_id", $section->section_id)
                     ->execute();
                     
                $content = (count($contents) > 0) ? $contents[0] : null;
  
                if(!$content)
                {
                     $content = new SectionContent();
                     $content->section_id = $section->section_id;
                     $content->identifier = $ident;
                }
                else
                {
                     $content->filter = new InclusionFilter("template", "role");
                }
  
                if($section->default_template != $template)
                     $content->template = $template;
                if($section->default_role != $role)
                     $content->role = $role;
                if ($section->default_permissions != $permissions)
                     $content->permissions = $permissions;
                                    
                $content->save();
                
                trace("Added $item to $section_name", 3);
           }
           
           return true;
      }

◆ dependsOn()

UpgradeManager::dependsOn	(	$component,
		$version
	)

Definition at line 860 of file upgrade_manager.inc.

      {
           UpgradeManager::upgradeComponentToVersion($component, $version); 
      }

◆ executeSQLFile()

UpgradeManager::executeSQLFile	(	$sqlFile,
		$version_number
	)

Definition at line 816 of file upgrade_manager.inc.

      {
           trace("** Upgrade {$this->component_name} to version $version_number by executing file {$sqlFile}", 3);
           
           if(!file_exists($sqlFile))
           {
                trace("UpgradeManager:: sql file does not exists {$sqlFile}", 2);
                return;
           }
           
           $fp = fopen($sqlFile, 'r');
           
           if(!$fp)
           {
                trace("Error: executeVersionSql failed to open file", 3);
                return;
           }
                               
           $lines = array();
           while(($buffer = fgets($fp)) !== false)
           {
                // Omit blank lines and comments
                if(trim($buffer) == "" || preg_match("/^--(.*?)\s/", $buffer))
                     continue;
                $lines[] = $buffer;
           }
           
           if(count($lines) == 0)
           {
                trace("UpgradeManager:: no lines parsed in file {$sqlFile}", 3);
                return true;        
           }
                
           $sqlStatements = $this->parseSQLStatements($lines);
  
           if(count($sqlStatements) == 0)
           {
                trace("UpgradeManager:: no query statements found in sql file {$sqlFile} for version $version_number", 3);
                return true;
           }
  
           return $this->executeSQLStatements($sqlStatements);
      }

◆ executeSQLStatements()

UpgradeManager::executeSQLStatements ( $sqlStatements )

Definition at line 404 of file upgrade_manager.inc.

      {
           try
           {
                trace("Executing SQL Statements", 2);
                
                $db = ConnectionManager::getConnection();
                $db->beginTransaction();
      
                foreach($sqlStatements as $sqlStatement)
                {
                     trace($sqlStatement, 2);
                     $db->exec($sqlStatement);     
                }
  
                $db->commit();
                fclose($fp);   
           }
           catch(PDOException $e)
           {
                $db->rollBack();
                fclose($fp);
                throw $e; 
           }
  
           return true;
      }

◆ executeVersionSql()

UpgradeManager::executeVersionSql ( $version_number )

Definition at line 300 of file upgrade_manager.inc.

      {
           ComponentManager::scanTrace("** Upgrade {$this->component_name} to Version $version_number", 2);
           
           $lines = array();
           if(!file_exists($this->sqlFile))
           {
                ComponentManager::scanTrace("UpgradeManager:: sql file does not exists {$this->sqlFile}", 2);
                return;
           }
           
           $fp = fopen($this->sqlFile, 'r');
           $version_id = str_ireplace(".", "\\.", "version " . $version_number); // case insensitive
           trace("UpgradeManager::version id: $version_id file $this->sqlFile", 3);
           
           if(!$fp)
           {
                ComponentManager::scanTrace("Error: executeVersionSql failed to open file", 2);
                return;
           }
           
           while (($buffer = fgets($fp)) !== false && !preg_match("/^--.*?\s+$version_id/i", $buffer)) 
                continue;
                     
           // Found start of this verson's update section in the sql file
           if(preg_match("/^--\s*START\s*$version_id/i", $buffer))
           {
                while(($buffer = fgets($fp)) !== false && !preg_match("/^--\s*END\s*$version_id/i", $buffer))
                {
                     $depends = array();
                     if (preg_match('/^--\s*Depends\s+On\s+([\w_]+)\s+(.*)/i', $buffer, $depends))
                     {
                          ComponentManager::scanTrace("{$this->component_name} $version_id is dependent on {$depends[1]} {$depends[2]}", 2);
                          
                          UpgradeManager::upgradeComponentToVersion($depends[1], trim($depends[2]));
                     }
                     
                     // Omit blank lines and comments
                     if(trim($buffer) == "" || preg_match("/^--(.*?)\s/", $buffer))
                          continue;
                     $lines[] = $buffer;
                }
                
                trace("** Upgrade has ".count($lines)." lines", 3);
           }
           
           $sqlStatements = $this->parseSQLStatements($lines);
  
           if(count($sqlStatements) == 0)
           {
                ComponentManager::scanTrace("UpgradeManager:: no query statements found for version $version_number", 3);
                return true;
           }
  
           try
           {
                $rtn = $this->executeSQLStatements($sqlStatements);
                return rtn;
           }
           catch(Exception $e)
           {
                ComponentManager::scanTrace("Failed to upgrade {$this->component_name} to version $version_number - ". $e->getMessage(), 2);
                throw new FakoliException("Failed to upgrade {$this->component_name} to version $version_number - ". $e->getMessage());
           }
      }

◆ executeVersionXML()

UpgradeManager::executeVersionXML ( $version )

Definition at line 440 of file upgrade_manager.inc.

      {
           global $config;
           
           ComponentManager::scanTrace("** Upgrade {$this->component_name} to Version $version_number", 3);
           
           if (preg_match("/\\b{$this->component_name}\\b/", $config["ignore_xml_updates"]))
           {
                ComponentManager::scanTrace("** Ignoring this upgrade as specified in config", 3);
                return true;
           }
           
           if (!is_dir($this->xmlDir))
           {
                throw new FakoliException("XML update directory does not exists for {$this->component_name}");
           }
           
           $file = $this->xmlDir . DIRECTORY_SEPARATOR . $this->component_name ."_" . $version . ".xml";
           
           if (!file_exists($file))
           {
                throw new FakoliException("No XML update for version $version of $this->component_name");
           }
           
           $xml = file_get_contents($file);
           $mgr = new SerializationManager();
           $mgr->importAll($xml);
           
           return true;
      }

◆ log()

UpgradeManager::log ( $text )

Definition at line 432 of file upgrade_manager.inc.

      {
           if(preg_match("/(<br>|<br\/>)$/i", $text))
                $this->log .= preg_replace(array("/<br>$/i", "/<br\/>$/i"), "\r\n", $text);
           else
                $this->log .= $text . "\r\n";
      }

◆ parseSQLStatements()

UpgradeManager::parseSQLStatements ( $lines )

Definition at line 370 of file upgrade_manager.inc.

      {
           if(count($lines) == 0)
                return;
                
           $delimiter = ";";
           foreach($lines as $line)
           {
                $d = array();
  
                ComponentManager::scanTrace("UpgradeManager:: processing update schema line $line", 4);
                if (preg_match("/^\s*DELIMITER\s+(.*?)$/i", $line, $d))
                {
                     $delimiter = preg_quote($d[1]);
                     //$sqlStatement .= $line."\n";
                }
                else
                {
                     if(preg_match("/{$delimiter}\s*$/", $line))
                     {
                          $sqlStatement .= preg_replace("/{$delimiter}\s*$/", "", $line);
                          $sqlStatements[] = $sqlStatement;
                          $sqlStatement = "";
                     }
                     else
                     {
                          $sqlStatement .= $line;                 
                     }
                }
           }
           trace(print_r($sqlStatements, true), 3);
           return $sqlStatements;        
      }

◆ recordUpdate()

UpgradeManager::recordUpdate	(	$version,
		$description
	)

Definition at line 471 of file upgrade_manager.inc.

      {
           if($this->log)
                $fileName = $this->saveLogFile($version);
           ComponentUpdateLog::recordUpdate($this->component_name, $version, $description, $fileName);
      }    

◆ reformatPhone()

UpgradeManager::reformatPhone	(	&	$item,
			$field
	)

Definition at line 782 of file upgrade_manager.inc.

      {
           $oldPhone = $item->$field;
           if(!$oldPhone)
                return;
  
           // remove the 1 before 800 or 888
           $phone = preg_replace("/^1-/","", $oldPhone);
           // remove all nondigits
           $phone = preg_replace("/\D/","", $phone);
  
           if($phone != $oldPhone)
           {
                $item->$field = $phone;
                $table = $item->table;
                $pk = $item->getPrimaryKey();
                $this->log($item->format("Setting {$item->table} {$pk} $field from {$oldPhone} to {$phone}"));
                $item->filter = new InclusionFilter($field);
                $item->save();
           }    
      }    

◆ saveLogFile()

UpgradeManager::saveLogFile ( $version )

Definition at line 478 of file upgrade_manager.inc.

      {
           $upgradePath = Settings::getValue("component", "upgrade_output_path");
      
           $fileName = $this->component_name . "_" . $version . ".txt";
           $fp = fopen($upgradePath . DIRECTORY_SEPARATOR . $fileName, 'w');
           fwrite($fp, $this->log);
          fclose($fp);
          return $fileName;
      }

◆ searchByIdentifier()

UpgradeManager::searchByIdentifier ( $identifier )

Definition at line 645 of file upgrade_manager.inc.

      {
           $pages = Query::create(Page, "WHERE identifier=:identifier")
                     ->bind(":identifier", $identifier)
                     ->execute();
                     
           if(count($pages) == 0)
           {
                $pages = Query::create(ComponentPage, "WHERE identifier=:identifier")
                ->bind(":identifier", $identifier)
                ->execute();
           }
                
           if(count($pages) == 0)
           {
                $this->log .= "Page identifier $identifier not found in Page or ComponentPage tables\r\n";
           }    
                
           return (count($pages) > 0) ? $pages[0] : null;              
      }

◆ upgrade()

UpgradeManager::upgrade ( $upgrade_to = "" )

Definition at line 226 of file upgrade_manager.inc.

      {                        
           if ($upgrade_to)
           {
                ComponentManager::scanTrace("Upgrading {$this->component_name} to version $upgrade_to", 2);
           }
           
           $latest_version = ComponentUpdateLog::getLatestVersion($this->component_name);
           ComponentManager::scanTrace("UpgradeManager:: upgrade: latest version in db for component {$this->component_name} is $latest_version", 3);
                          
           if(count($this->updateMap) > 0)
           {
                foreach($this->updateMap as $version_number => $handler)
                {
                     // remove any contents from a previous upgraded version
                     $this->log = "";
                     if($latest_version < $version_number)
                     {
                          list($function, $description) = explode(":", $handler);
                          if($this->upgradeOneVersion($version_number, $function))
                               $this->recordUpdate($version_number, $description);
                          else
                               break;
                     }
                     
                     if ($upgrade_to != "" && $upgrade_to == $version_number) break;
                }
           }
                     
           // Save the latest version number to the version
           // field of the component record
           ComponentManager::setComponentVersion($this->component_name);
      }

◆ upgradeComponentToVersion()

static UpgradeManager::upgradeComponentToVersion	(	$component,
		$version
	)

static

Definition at line 865 of file upgrade_manager.inc.

      {
           trace("Firing upgrade event to $component, target version $version", 3);
           ComponentManager::fireEventTo("upgradeComponent", $component, $version);
      }

◆ UpgradeManager()

UpgradeManager::UpgradeManager ( )

Definition at line 204 of file upgrade_manager.inc.

      {
           global $config;
      
           $path = ComponentManager::findComponentPath($this->component_name);        
           $this->sqlFile = $path . DIRECTORY_SEPARATOR . $this->component_name . "_schema.sql";
           $this->xmlDir = $path . DIRECTORY_SEPARATOR . "updates";
      }

◆ upgradeOneVersion()

UpgradeManager::upgradeOneVersion	(	$version_number,
		$function
	)

Definition at line 271 of file upgrade_manager.inc.

      {              
           if($function == "sql")
                return $this->executeVersionSql($version_number);
           else if ($function == "xml")
                return $this->executeVersionXML($version_number);
           elseif($function != "done")
           {         
                $updater = array($this, $function);
                return call_user_func($updater, $version_number);
           }
           else // sql update done in local copy
                return true;
      }

Member Data Documentation

◆ $component_name

UpgradeManager::$component_name

Definition at line 195 of file upgrade_manager.inc.

◆ $log

UpgradeManager::$log

Definition at line 196 of file upgrade_manager.inc.

◆ $sqlFile

UpgradeManager::$sqlFile

Definition at line 193 of file upgrade_manager.inc.

◆ $xmlDir

UpgradeManager::$xmlDir

Definition at line 194 of file upgrade_manager.inc.

The documentation for this class was generated from the following file:

C:/code/cms.sonjara.com/cms/components/component/upgrade_manager.inc

Public Member Functions

Static Public Member Functions

Public Attributes