TranslationBackend.php

Go to the documentation of this file.

<?php

/***************************************************************************
 *   Copyright (C) 2005-2020 by Ferenc Veres                                                       *
 *   lion@netngine.hu                                                                                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 ***************************************************************************/
include_once('config.inc.php');
include_once('lib/Common.php');

$DB = NewADOConnection(GetConfigVar('db_software'));
$DB->Connect(GetConfigVar('db_host'), GetConfigVar('db_username') , GetConfigVar('db_password'), GetConfigVar('db_database'));
$DB->Execute("SET NAMES utf8");
CacheIndexes();

define('LOCATE_CURR', 0);
define('LOCATE_NEXT', 1);
define('LOCATE_NEXTMISSING', 2);
define('LOCATE_PREV', 3);
define('LOCATE_PREVMISSING', 4);

class TranslationBackend
{
        public $Event;  
        // CONTROLS
        
        public $txtFindText;    
        public $ddlSearchType;  
        public $ddlFindPercent; 
        public $ddlLocaleID;    
        public $xOldLocaleID;   
        public $xStringID;      
        public $xProjectID; 
        public $xActiveRootID; 
        public $xDelStringID;   
        public $txtEditString;  
        // OUTPUT

        public $Translations;   
        public $LocatedString;  
        public $LocatedProjects;
        public $SiblingProjects;        
        public $ChildProjects;  
        public $CurrentStrings; 
        public $RootProjects;   
        // PRIVATE 

        private $String;        
        function __construct()
        {
                // Get and use default locale
                $localeName = GetConfigVar('default_locale');
                $localeID = TranslationProject::$LocaleIDCache[$localeName];
                if(empty($localeID))
                {
                        throw new Exception("Invalid default locale in the configuration: $localeName");
                }
                
                // Create a new translation string handler class
                $this->String = new TranslationString();
                $this->DB = GetDbConn();
                $this->Tables = GetTables();

                $this->txtFindText = "";
                $this->ddlSearchType = 0;
                $this->ddlFindPercent = 60;
                $this->ddlLocaleID = $localeID;
                $this->xOldLocaleID = $localeID;
                $this->xStringID = 0;
                $this->xProjectID = 0;

                $this->RootProjects = TranslationProject::GetRoots($this->ddlLocaleID);
                if(count($this->RootProjects) == 0) 
                {
                        throw new Exception("Cannot initialze backend for $this->ddlLocaleID locale. No roots.");
                }
        
                $this->InitLanguage();
        }

        public function InitLanguage()
        {
                // Find a legal root project
                $proj = new TranslationProject();

                // Reset to first project's root if no root selected yet
                if(!$this->xActiveRootID) 
                {
                        $this->xActiveRootID = array_keys($this->RootProjects)[0];
                }

                // Reset system to select the root project
                $this->xProjectID = $this->RootProjects[$this->xActiveRootID]->GetID();
                $this->FindProjectPath();
        }
        
        function FindStrings()
        {
                switch($this->ddlSearchType)
                {

                        case 1:
                                // Find in Original as part of the string
                                $this->Translations = $this->String->FindText($this->txtFindText, $this->ddlLocaleID, true);
                                break;
                        
                        case 2:
                                // Find in Translation as part of the string
                                $this->Translations = $this->String->FindText($this->txtFindText, $this->ddlLocaleID, false);
                                break;

                        default:
                                // Similarity matching
                                $this->Translations = $this->String->FindSimilar($this->txtFindText, $this->ddlLocaleID, $this->ddlFindPercent);
                                break;
                }
        }

        function LocateString($locate = LOCATE_CURR)
        {
                // Load string details
                switch($locate)
                {
                        case LOCATE_CURR:
                                $this->LocatedString = new TranslationString($this->xStringID);
                                break;

                        case LOCATE_NEXT:
                        case LOCATE_NEXTMISSING:
                                $this->LocateStringNext( ($locate == LOCATE_NEXTMISSING) );
                                break;
                }
        }

        private function LocateStringNext($missingOnly)
        {
                unset($this->LocatedString);

                // Skip string-in-project search if xStringID is empty:
                // which means there were no strings in this project

                if($this->xStringID != 0)
                {
                        // Take current string and an iterator for it's siblings
                        $currentString = new TranslationString($this->xStringID);
                        $stringIter = new StringIterator($currentString->GetProjectID());
        
                        // FLAT SEARCH - STRINGS OF THE CURRENT PROJECT
                        
                        // Find current and then take next. If we are last, this will end with false.
                        $takeString = false;
                        foreach($stringIter as $str)
                        {
                                if($takeString)
                                {
                                        $this->LocatedString = new TranslationString($str->GetStringID());
        
                                        // If we find Missing Strings, ignore non-empty results!
                                        if($missingOnly && $this->LocatedString->GetTranslation() != "")
                                        {
                                                // Need to search a missing one, drop that result
                                                unset($this->LocatedString);
                                        }
                                        else
                                        {
                                                // Found, break!
                                                $this->xStringID = $str->GetStringID();
                                                break;
                                        }
                                }
                                
                                // If reached the current string, note to take the next one
                                if($str->GetStringID() == $currentString->GetStringID())
                                {
                                        $takeString = true;
                                }
                        }
                }
                
                // RECURSIVE SEARCH - UPWARDS AND DOWNWARDS
                
                // If this was a "last string" in the project, we will search across projects!
                $currentProject = new TranslationProject($this->xProjectID);

                // Stop variable for reaching root
                $rootHit = false;

                // Search next string across projects!
                while(empty($this->LocatedString) && !$rootHit)
                {
                        $takeProject = false;

                        // Start an iterator on sibling and subprojects
                        $parentProjects = new RecursiveIteratorIterator(
                                new ProjectIterator($currentProject->GetParentID(), $this->ddlLocaleID, true),
                                RecursiveIteratorIterator::SELF_FIRST);

                        // Loop on the projects and find the current one (which hit last string above!)
                        foreach($parentProjects as $proj)
                        {
                                // This happens after the "last-string-hit" project, take next project:
                                if($takeProject)
                                {
                                        // Get strings of all next projects and see if there are any strings.
                                        $stringIter = new StringIterator($proj->GetID());

                                        // There are strings, take the first and we are done! (in not missing ok)
                                        if(!$missingOnly)
                                        {
                                                // Any strings? If yes, found, break!
                                                if($stringIter->valid())
                                                {
                                                        $this->xStringID = $stringIter->current()->GetStringID();
                                                        $this->LocatedString = new TranslationString($this->xStringID);
                                                        break;
                                                }
                                        }
                                        else
                                        {
                                                $foundEmpty = false;
                                                // Missing only, so loop on all strings
                                                // If we find Missing Strings, ignore non-empty results!
                                                foreach($stringIter as $str)
                                                {
                                                        if($str->GetTranslation() == "")
                                                        {
                                                                $this->xStringID = $str->GetStringID();
                                                                $this->LocatedString = new TranslationString($this->xStringID);
                                                                $foundEmpty = true;
                                                                break;
                                                        }
                                                }

                                                // If iterator not finished, we found the result
                                                if($foundEmpty)
                                                {
                                                        break;
                                                }
                                        }
                                }

                                // Found the "last-string-hit" project?
                                if($proj->GetID() == $this->xProjectID)
                                {
                                        $takeProject = true;
                                }
                        }

                        // Stop working if taking parent would result in looping on root!
                        $rootHit = ($currentProject->GetParentID() == 0);

                        // If not root and not found a string, recurse UPWARDS
                        if($currentProject->GetParentID() != 0 && empty($this->LocatedString))
                        {
                                $currentProject = new TranslationProject($currentProject->GetParentID());
                        }

                }
        }
        function FindProjectPath()
        {
                unset ($this->LocatedProjects);
                unset ($this->SiblingProjects);
                unset ($this->ChildProjects);

                $pid = $this->xProjectID;
                
                // Loop and collect projects until reaching the end
                while($pid != 0)
                {
                        $proj = new TranslationProject($pid);
                        $this->LocatedProjects[] = $proj;
                        $pid = $proj->GetParentID();
                }
                
                // Make a new project Iterators with current parent to see if there are children
                $this->ChildProjects = new ProjectIterator($this->xProjectID, $this->ddlLocaleID, true);
                $this->SiblingProjects = new ProjectIterator($this->GetProject()->GetParentID(), $this->ddlLocaleID, true);
        }

        function SaveString()
        {
                // Load our string from the DB, change it and save changes
                $string = new TranslationString($this->xStringID);
                $string->SetTranslation($this->txtEditString);
                $string->Save();
        }

        function DeleteString()
        {
                // Load our string
                $string = new TranslationString($this->xDelStringID);
                $string->DestroyData();
        }

        function DeleteProject($projectID)
        {
                $project = new TranslationProject($projectID);
                $parent = $project->GetParentID();
                $project->DestroyData();
                return $parent;
        }

        function LoadProjectStrings()
        {
                $this->CurrentStrings = new StringIterator($this->xProjectID);
        }

        function GetProject() 
        {
                if(count($this->LocatedProjects) > 0) 
                {
                        return $this->LocatedProjects[0];
                }
                return null;
        }
}

?>