function getTitle() { if ($this->lexem === null) { $this->lexem = Lexem::get_by_id($this->lexemeId); } return $this->lexem ? $this->lexem->formNoAccent : ''; }
function getLexem() { if ($this->lexem === null) { $this->lexem = Lexem::get_by_id($this->lexemId); } return $this->lexem; }
function associateLongInfinitivesAndParticiples() { $lexems = Lexem::loadUnassociated(); $numMatched = 0; foreach ($lexems as $l) { $matched = false; $wordlist = WordList::loadByUnaccented($l->unaccented); foreach ($wordlist as $wl) { if ($wl->inflectionId == 50 || $wl->inflectionId == 52) { $verb = Lexem::load($wl->lexemId); print "{$l->unaccented} :: {$verb->unaccented}\n"; $matched = true; $ldms = LexemDefinitionMap::loadByLexemId($verb->id); foreach ($ldms as $ldm) { $existingLdm = LexemDefinitionMap::load($l->id, $ldm->definitionId); if (!$existingLdm) { $newLdm = LexemDefinitionMap::create($l->id, $ldm->definitionId); $newLdm->save(); } } } } if ($matched) { $numMatched++; } } print "Matched {$numMatched} of " . count($lexems) . " total lexems.\n"; }
function importLexems($srcId, $srcName) { $dbResult = db_execute("select l.*, d.internalRep from Lexem l, LexemDefinitionMap ldm, Definition d where l.id = ldm.lexemId and ldm.definitionId = d.id " . "and d.status = 0 and d.sourceId = {$srcId} and not l.isLoc order by l.formNoAccent"); $rowCount = $dbResult->RowCount(); print "************** Import {$rowCount} lexeme din {$srcName}\n"; while (!$dbResult->EOF) { $internalRep = $dbResult->fields['internalRep']; unset($dbResult->fields['internalRep']); unset($dbResult->fields['16']); $l = new Lexem(); $l->set($dbResult->fields); $dbResult->MoveNext(); print sprintf("%d\t%-20s\t%-60s\t%-50s\n", $l->id, $l->formNoAccent, mb_substr($internalRep, 0, 58), "http://dexonline.ro/lexem/{$l->formNoAccent}/{$l->id}"); $l->isLoc = 1; $l->save(); } }
static function loadRelatedLexems($map) { $results = array(); foreach ($map as $type => $lexemIds) { if ($type) { $results[$type] = Lexem::loadByIds(StringUtil::explode(',', $lexemIds)); } } return $results; }
/** * Returns a LexemModel for a given word and model. Creates one if one doesn't exist. **/ function getLexemModel($form, $modelType, $modelNumber) { // Load by canonical model, so if $modelType is V, look for a lexem with type V or VT. $lm = Model::factory('LexemModel')->table_alias('lm')->select('lm.*')->join('Lexem', 'l.id = lm.lexemId', 'l')->join('ModelType', 'modelType = code', 'mt')->where('mt.canonical', $modelType)->where('lm.modelNumber', $modelNumber)->where('l.form', $form)->limit(1)->find_one(); if ($lm) { $lm->loadInflectedFormMap(); } else { $l = Lexem::deepCreate($form, $modelType, $modelNumber); $lm = $l->getFirstLexemModel(); $lm->generateInflectedFormMap(); } return $lm; }
public static function associate($lexemId, $definitionId) { // The definition and the lexem should exist $definition = Definition::get_by_id($definitionId); $lexem = Lexem::get_by_id($lexemId); if (!$definition || !$lexem) { return; } // The association itself should not exist. $ldm = Model::factory('LexemDefinitionMap')->where('lexemId', $lexemId)->where('definitionId', $definitionId)->find_one(); if (!$ldm) { $ldm = LexemDefinitionMap::create($lexemId, $definitionId); $ldm->save(); } }
function getNouns($word) { $lexems = Lexem::searchWordlists($word, true); $result = array(); foreach ($lexems as $l) { if ($l->modelType == 'M' || $l->modelType == 'F' || $l->modelType == 'N' || $l->modelType == 'A' || $l->modelType == 'MF') { $result[] = $l; } } return $result; }
if ($fileName) { $v = Visual::get_by_path($fileName); if (!$v) { $v = Visual::createFromFile($fileName); } util_redirect("?id={$v->id}"); } $v = Visual::get_by_id($id); if ($saveButton) { $v->lexemeId = $lexemId; $v->revised = $revised; $v->save(); util_redirect("?id={$v->id}"); } if ($addTagButton) { $vt = Model::factory('VisualTag')->create(); $vt->imageId = $v->id; $vt->lexemeId = $tagLexemId; $vt->label = $tagLabel; $vt->textXCoord = $textXCoord; $vt->textYCoord = $textYCoord; $vt->imgXCoord = $imgXCoord; $vt->imgYCoord = $imgYCoord; $vt->save(); util_redirect("?id={$v->id}"); } SmartyWrap::assign('visual', $v); SmartyWrap::assign('lexem', Lexem::get_by_id($v->lexemeId)); SmartyWrap::addCss('jqueryui-smoothness', 'jcrop', 'select2', 'jqgrid', 'jqueryui', 'gallery'); SmartyWrap::addJs('jquery', 'jqueryui', 'jcrop', 'visualTag', 'select2', 'select2Dev', 'jqgrid', 'gallery'); SmartyWrap::displayAdminPage('admin/visualTag.tpl');
} } if ($lexemId) { SmartyWrap::assign('paradigmLink', util_getWwwRoot() . "lexem/{$cuv}/{$lexemId}/paradigma"); } else { SmartyWrap::assign('paradigmLink', util_getWwwRoot() . "definitie/{$cuv}/paradigma"); } if ($cuv) { $cuv = StringUtil::cleanupQuery($cuv); } // Normal search if ($searchType == SEARCH_INFLECTED) { $lexems = Lexem::searchInflectedForms($cuv, $hasDiacritics); if (count($lexems) == 0) { $cuv_old = StringUtil::tryOldOrthography($cuv); $lexems = Lexem::searchInflectedForms($cuv_old, $hasDiacritics); } } // Maps lexems to arrays of inflected forms (some lexems may lack inflections) // Also compute the text of the link to the paradigm div, // which can be 'conjugări', 'declinări' or both if (!empty($lexems)) { $conjugations = false; $declensions = false; $filtered_lexems = array(); foreach ($lexems as $l) { $lm = $l->getFirstLexemModel(); // One LexemModel suffices -- they all better have the same modelType. $isVerb = $lm->modelType == 'V' || $lm->modelType == 'VT'; if (TYPE_SHOW_ONLY_VERBS == $type && $isVerb || TYPE_SHOW_NO_VERBS == $type && !$isVerb || !$type) { $filtered_lexems[] = $l;
<?php require_once "../../phplib/util.php"; util_assertModerator(PRIV_EDIT); util_assertNotMirror(); $suffix = util_getRequestParameter('suffix'); $submitButton = util_getRequestParameter('submitButton'); if ($submitButton) { foreach ($_REQUEST as $name => $modelId) { if (StringUtil::startsWith($name, 'lexem_')) { $parts = preg_split('/_/', $name); assert(count($parts) == 2); assert($parts[0] == 'lexem'); $lexem = Lexem::get_by_id($parts[1]); if ($modelId) { $parts = preg_split('/_/', $modelId); assert(count($parts) == 2); $lm = $lexem->getFirstLexemModel(); $lm->modelType = $parts[0]; $lm->modelNumber = $parts[1]; $lm->restriction = util_getRequestParameter('restr_' . $lexem->id); $lm->save(); $lm->regenerateParadigm(); } else { $lexem->comment = util_getRequestParameter('comment_' . $lexem->id); $lexem->save(); } } } util_redirect("bulkLabel.php?suffix={$suffix}"); }
<?php require_once "../../phplib/util.php"; header("Content-Type: application/json"); $acEnable = Config::get("search.acEnable"); $acMinChars = Config::get("search.acMinChars"); $acLimit = Config::get("search.acLimit"); $search = util_getRequestParameter('term'); if (!$acEnable || strlen($search) < $acMinChars) { return print json_encode(array()); } $hasDiacritics = session_user_prefers(Preferences::FORCE_DIACRITICS) || StringUtil::hasDiacritics($search); $search_results = Lexem::searchLike("{$search}%", $hasDiacritics, true, $acLimit); $clean_results = array_map(function ($rec) { return $rec['formNoAccent']; }, $search_results); return print json_encode($clean_results); ?>
$dbResult = mysql_query('select * from lexems where (lexem_model_type = "T") or (lexem_model_type in ("MQ", "FQ", "NQ") and lexem_restriction like "%P%")' . 'order by lexem_neaccentuat'); $found = 0; while ($row = mysql_fetch_assoc($dbResult)) { $lexem = Lexem::createFromDbRow($row); $wordLists = WordList::loadByUnaccented($lexem->unaccented); $matchingWordLists = array(); foreach ($wordLists as $wl) { if (in_array($wl->inflectionId, $PLURAL_INFLECTIONS) && $wl->lexemId != $lexem->id) { $matchingWordLists[] = $wl; } } if (count($matchingWordLists)) { $sources = getSourcesForLexem($lexem); print "{$lexem->unaccented} {$lexem->modelType}{$lexem->modelNumber}{$lexem->restriction} {$sources} " . "http://dexonline.ro/admin/lexemEdit.php?lexemId={$lexem->id}\n"; foreach ($matchingWordLists as $wl) { $match = Lexem::load($wl->lexemId); $sources = getSourcesForLexem($match); print " * {$match->unaccented} {$match->modelType}{$match->modelNumber}{$match->restriction} {$sources}" . "http://dexonline.ro/admin/lexemEdit.php?lexemId={$match->id}\n"; } $found++; } } print "{$found} lexeme semnalate.\n"; /**************************************************************/ function loadSources() { $sources = Source::loadAllSources(); $result = array(); foreach ($sources as $source) { $result[$source->id] = $source; }
$dbResult = mysql_query($query); $fixed = 0; $prevUnaccented = ''; while (($dbRow = mysql_fetch_assoc($dbResult)) != null) { $l = Lexem::createFromDbRow($dbRow); if ($prevUnaccented != $l->unaccented) { $defs = loadDefinitions($l->id); if (count($defs)) { $isPart = isParticiple($l); $isAdj = isAdjective($defs) || $isPart; $isMf = isMfNoun($defs); $isN = isNNoun($defs); $isM = isMNoun($defs) && !$isMf; $femForm = loadFeminineForm($l->id); $isF = countDefinitionsByLexicon($femForm); $homonyms = Lexem::loadByUnaccented($l->unaccented); // Very often, the participle also acts os homonym. This is normal. // Report other cases of N because we don't have mapping tables for N. if (count($homonyms) == 1 && $isN && $isPart) { $isN = false; } // Report cases which (1) contain a N lexem outside of the above case, OR // (2) Do not seem to generate all the M and F forms. if (!$isAdj && !$isMf && !($isM && $isF) || $isN) { //printLexem($homonyms, $isAdj, $isMf, $isM, $isN, $isF); } else { $fixed += replaceLexems($homonyms, $isAdj, $isMf, $isM, $isN, $isF, $femForm); } } } $prevUnaccented = $l->unaccented;
<?php require_once '../phplib/util.php'; $INFL_LONG_INF = 50; $INFL_PART = 52; $LEXEM_EDIT_URL = 'http://dexonline.ro/admin/lexemEdit.php?lexemId='; $dbResult = db_execute("select * from Lexem where modelType in ('V', 'VT') and isLoc order by formNoAccent"); while (!$dbResult->EOF) { $verb = new Lexem(); $verb->set($dbResult->fields); $dbResult->MoveNext(); $ifs = db_find(new InflectedForm(), "lexemId = {$verb->id} and inflectionId = {$INFL_LONG_INF}"); assert(count($ifs) <= 1); if (count($ifs) == 1) { $longInfForm = $ifs[0]->formNoAccent; $longInfModelNumber = text_endsWith($longInfForm, 'are') ? '113' : '107'; $lexems = db_find(new Lexem(), "formNoAccent = '{$longInfForm}' and modelType = 'F' and modelNumber = '{$longInfModelNumber}'"); if (count($lexems) != 1) { print "I {$longInfForm} are " . count($lexems) . " lexeme corespunzătoare\n"; } foreach ($lexems as $longInf) { if (!$longInf->isLoc) { print "I {$longInf->formNoAccent} nu este în LOC {$LEXEM_EDIT_URL}{$longInf->id}\n"; $longInf->isLoc = 1; $longInf->save(); } } } if ($verb->modelType == 'VT') { $ifs = db_find(new InflectedForm(), "lexemId = {$verb->id} and inflectionId = {$INFL_PART}"); $pm = ParticipleModel::loadByVerbModel($verb->modelNumber);
<?php require_once "../../phplib/util.php"; util_assertModerator(PRIV_EDIT); util_assertNotMirror(); $reportId = util_getRequestParameter('report'); switch ($reportId) { case 'unassociatedLexems': echo count(Lexem::loadUnassociated()); break; case 'unassociatedDefinitions': echo Definition::countUnassociated(); break; case 'definitionsWithTypos': echo Model::factory('Typo')->select('definitionId')->distinct()->count(); break; case 'temporaryDefinitions': echo Definition::countByStatus(ST_PENDING); break; case 'temporaryLexems': echo Model::factory('Lexem')->where('modelType', 'T')->count(); break; case 'lexemsWithComments': echo Model::factory('Lexem')->where_not_equal('comment', '')->count(); break; case 'lexemsWithoutAccents': echo Model::factory('Lexem')->where_raw("form not rlike '\\''")->where('noAccent', false)->count(); break; case 'wotd': echo Model::factory('WordOfTheDay')->count(); break;
public static function searchMultipleWords($words, $hasDiacritics, $sourceId, $exclude_unofficial) { $defCounts = array(); foreach ($words as $word) { $lexems = Lexem::searchInflectedForms($word, $hasDiacritics); if (count($lexems)) { $definitions = self::loadForLexems($lexems, $sourceId, $word, $exclude_unofficial); foreach ($definitions as $def) { $defCounts[$def->id] = array_key_exists($def->id, $defCounts) ? $defCounts[$def->id] + 1 : 1; } } } arsort($defCounts); $result = array(); foreach ($defCounts as $defId => $cnt) { if ($cnt >= 2) { $d = Definition::get_by_id($defId); if ($d) { // Hidden definitions might return null $result[] = $d; } } } return $result; }
<?php require_once "../../phplib/util.php"; $id = util_getRequestParameter('id'); $m = Meaning::get_by_id($id); $l = Lexem::get_by_id($m->lexemId); $results = array('lexem' => $l->formNoAccent, 'breadcrumb' => $m->breadcrumb, 'htmlRep' => $m->htmlRep); print json_encode($results);
smarty_assign('selectedModelNumber', $modelNumber); LocVersion::changeDatabase($locVersion); if ($modelNumber == -1) { $modelsToDisplay = FlexModel::loadByType($modelType); } else { $modelsToDisplay = array(Model::factory('FlexModel')->where('modelType', $modelType)->where('number', $modelNumber)->find_one()); } $lexems = array(); $paradigms = array(); foreach ($modelsToDisplay as $m) { // Load by canonical model, so if $modelType is V, look for a lexem with type V or VT. $l = Model::factory('Lexem')->select('Lexem.*')->join('ModelType', 'modelType = code')->where('canonical', $modelType)->where('modelNumber', $m->number)->where('form', $m->exponent)->limit(1)->find_one(); if ($l) { $paradigm = getExistingForms($l->id, $locVersion); } else { $l = Lexem::create($m->exponent, $modelType, $m->number, ''); $l->isLoc = true; $paradigm = getNewForms($l, $locVersion); } $lexems[] = $l; $paradigms[] = $paradigm; } smarty_assign('modelsToDisplay', $modelsToDisplay); smarty_assign('lexems', $lexems); smarty_assign('paradigms', $paradigms); } else { smarty_assign('selectedLocVersion', $locVersions[0]->name); // LocVersion::changeDatabase($locVersion); } $modelTypes = ModelType::loadCanonical(); $models = FlexModel::loadByType($modelType ? $modelType : $modelTypes[0]->code);
$cuv_old = StringUtil::tryOldOrthography($cuv); $lexems = Lexem::searchInflectedForms($cuv_old, $hasDiacritics, true); } if (count($lexems) == 0) { $searchType = SEARCH_MULTIWORD; $words = preg_split('/[ .-]+/', $cuv); if (count($words) > 1) { $ignoredWords = array_slice($words, 5); $words = array_slice($words, 0, 5); $definitions = Definition::searchMultipleWords($words, $hasDiacritics, $sourceId, $exclude_unofficial); smarty_assign('ignoredWords', $ignoredWords); } } if (count($lexems) == 0 && empty($definitions)) { $searchType = SEARCH_APPROXIMATE; $lexems = Lexem::searchApproximate($cuv, $hasDiacritics, true); if (count($lexems) == 1) { FlashMessage::add("Ați fost redirecționat automat la forma „{$lexems[0]->formNoAccent}”."); } else { if (!count($lexems)) { FlashMessage::add("Niciun rezultat relevant pentru „{$cuv}”."); } } } if (count($lexems) == 1 && $cuv != $lexems[0]->formNoAccent) { // Convenience redirect when there is only one correct form. We want all pages to be canonical $sourcePart = $source ? "-{$source->urlName}" : ''; session_setVariable('redirect', true); session_setVariable('init_word', $cuv); util_redirect(util_getWwwRoot() . "definitie{$sourcePart}/{$lexems[0]->formNoAccent}" . ($xml ? '/xml' : '')); }
foreach ($mms as $mm) { print "Creating {$mm->modelType}{$mm->slaveNumber} from " . "{$mm->modelType}{$mm->masterNumber}\n"; $master = Model::loadByTypeNumber($mm->modelType, $mm->masterNumber); // Create the model $slave = Model::create($mm->modelType, $mm->slaveNumber, "Derivat din {$mm->modelType}{$mm->masterNumber}"); $slave->save(); $slave->id = db_getLastInsertedId(); // Clone the model descriptions $mds = ModelDescription::loadByModelId($master->id); foreach ($mds as $md) { $md->id = 0; $md->modelId = $slave->id; $md->save(); } // Clone the participle model if ($mm->modelType == 'V') { $pm = ParticipleModel::loadByVerbModel($mm->masterNumber); $clonePm = ParticipleModel::create($mm->slaveNumber, $pm->participleModel); $clonePm->save(); } // Delete the mapping mysql_query("delete from model_mappings where model_type = " . " '{$mm->modelType}' and slave_no = '{$mm->slaveNumber}'"); // Regenerate the lexems. In theory the paradigm won't change, but we want // to actually see it. $lexems = Lexem::loadByCanonicalModel($mm->modelType, $mm->slaveNumber); foreach ($lexems as $l) { print "\tRegenerating paradigm for {$l->form} ({$l->modelType}" . "{$l->modelNumber})\n"; $l->regenerateParadigm(); } } mysql_query('drop table model_mappings');
} } // procedura de refolosire a lexemului sau de regenerare if (count($lexems)) { // Reuse existing lexem. $lexem = $lexems[0]; if ($verbose) { echo "\t\tReusing lexem {$lexem->id} ({$lexem->form})\n"; } } else { if ($verbose) { echo "\t\tCreating a new lexem for name {$name}\n"; } if (!$dryrun) { // Create a new lexem. $lexem = Lexem::deepCreate($name, 'T', '1'); $lexem->deepSave(); if ($verbose) { echo "\t\tCreated lexem {$lexem->id} ({$lexem->form})\n"; } } } // procedura de asociere a definiției cu lexemul de mai sus if ($verbose) { echo "\t\tAssociate lexem {$name} ({$lexem->id}) to definition ({$definition->id})\n"; } if (!$dryrun) { LexemDefinitionMap::associate($lexem->id, $definition->id); } } }
<?php require_once '../../phplib/util.php'; assert_options(ASSERT_BAIL, 1); debug_off(); // First remove all restrictions from 'T' lesems mysql_query('update lexems set lexem_restriction = "" ' . 'where lexem_model_type = "T"'); $query = "select * from lexems where lexem_id not in " . "(select wl_lexem from wordlist)"; $dbResult = mysql_query($query); while (($dbRow = mysql_fetch_assoc($dbResult)) != null) { $l = Lexem::createFromDbRow($dbRow); print "{$l->id} {$l->form}\n"; $l->regenerateParadigm(); }
public function delete() { if ($this->id) { if ($this->hasModelType('VT')) { $this->deleteParticiple(); } if ($this->hasModelType('VT') || $this->hasModelType('V')) { $this->deleteLongInfinitive(); } LexemDefinitionMap::deleteByLexemId($this->id); Meaning::delete_all_by_lexemId($this->id); Relation::delete_all_by_lexemId($this->id); LexemModel::delete_all_by_lexemId($this->id); } // Clear the variantOfId field for lexems having $this as main. $lexemsToClear = Lexem::get_all_by_variantOfId($this->id); foreach ($lexemsToClear as $l) { $l->variantOfId = null; $l->save(); } parent::delete(); }
<?php require_once "../phplib/util.php"; $form = util_getRequestParameter('form'); $locVersion = util_getRequestParameter('locVersion'); $locVersions = pref_getLocVersions(); if ($locVersion && $form) { LocVersion::changeDatabase($locVersion); $form = StringUtil::cleanupQuery($form); smarty_assign('page_title', 'Verificare LOC: ' . $form); $ifs = loadLoc($form); $lexems = array(); $inflections = array(); foreach ($ifs as $if) { $lexems[] = Lexem::get_by_id($if->lexemId); $inflections[] = Inflection::get_by_id($if->inflectionId); } smarty_assign('form', $form); smarty_assign('selectedLocVersion', $locVersion); smarty_assign('ifs', $ifs); smarty_assign('lexems', $lexems); smarty_assign('inflections', $inflections); } else { smarty_assign('selectedLocVersion', $locVersions[1]->name); smarty_assign('page_title', 'Căutare formă flexionară în LOC ' . $form); } setlocale(LC_ALL, "ro_RO.utf8"); smarty_assign('locVersions', $locVersions); smarty_displayCommonPageWithSkin('scrabble-flexiune.ihtml'); function loadLoc($cuv) {
<?php require_once "../../phplib/util.php"; ini_set('max_execution_time', '3600'); util_assertModerator(PRIV_LOC); util_assertNotMirror(); DebugInfo::disable(); $modelType = util_getRequestParameter('modelType'); $modelNumber = util_getRequestParameter('modelNumber'); $deleteButton = util_getRequestParameter('deleteButton'); $model = Model::factory('FlexModel')->where('modelType', $modelType)->where('number', $modelNumber)->find_one(); $lexems = Lexem::loadByCanonicalModel($modelType, $modelNumber); if ($deleteButton) { foreach ($lexems as $lexem) { $lexem->modelType = 'T'; $lexem->modelNumber = '1'; $lexem->restriction = ''; $lexem->save(); $lexem->regenerateParadigm(); } $model->delete(); util_redirect('../admin/index.php'); exit; } RecentLink::createOrUpdate("Ștergere model: {$model}"); smarty_assign('modelType', $modelType); smarty_assign('modelNumber', $modelNumber); smarty_assign('lexems', $lexems); smarty_assign('recentLinks', RecentLink::loadForUser()); smarty_displayWithoutSkin('flex/deleteModel.ihtml');
$definition->abbrevReview = count($ambiguousMatches) ? ABBREV_AMBIGUOUS : ABBREV_REVIEW_COMPLETE; $definition->save(); log_userLog("Added definition {$definition->id} ({$definition->lexicon})"); $ldms = array(); foreach ($lexemNames as $lexemName) { $lexemName = addslashes(AdminStringUtil::formatLexem($lexemName)); if ($lexemName) { $matches = Lexem::loadByExtendedName($lexemName); if (count($matches) >= 1) { foreach ($matches as $match) { LexemDefinitionMap::associate($match->id, $definition->id); log_userLog("Associating with lexem {$match->id} ({$match->form})"); } } else { // Create a new lexem. $lexem = Lexem::create($lexemName, 'T', '1', ''); $lexem->save(); $lexem->regenerateParadigm(); LexemDefinitionMap::associate($lexem->id, $definition->id); log_userLog("Created lexem {$lexem->id} ({$lexem->form})"); } } } FlashMessage::add('Definiția a fost trimisă. Un moderator o va examina în scurt timp. Vă mulțumim!', 'info'); util_redirect('contribuie'); } } else { smarty_assign('sourceId', session_getDefaultContribSourceId()); } smarty_assign('contribSources', Model::factory('Source')->where('canContribute', true)->order_by_asc('displayOrder')->find_many()); smarty_assign('page_title', 'Contribuie cu definiții');
if ($l->comment) { $l->comment = $value; } break; case 'delete': case 'deleteConfirm': $deleteMap[$l->id] = array_key_exists($l->id, $deleteMap) ? $deleteMap[$l->id] + 1 : 1; break; } } } // Delete lexems foreach ($deleteMap as $lId => $value) { if ($value == 2) { // Checked and confirmed $l = Lexem::get_by_id($lId); $l->delete(); } } // Now save the ones that can be saved and present errors for the others foreach ($lexemMap as $id => $l) { if (!array_key_exists($id, $errorMap) && !array_key_exists($id, $deleteMap)) { $l->save(); $lm = $l->getFirstLexemModel(); $lm->save(); $lm->regenerateParadigm(); } } } $deSource = Source::get_by_shortName('DE'); $lexems = Model::factory('Lexem')->table_alias('l')->select('l.*')->distinct()->join('LexemModel', 'l.id = lm.lexemId', 'lm')->join('LexemDefinitionMap', 'l.id = ldm.lexemId', 'ldm')->join('Definition', 'ldm.definitionId = d.id', 'd')->where('d.status', Definition::ST_ACTIVE)->where('d.sourceId', $deSource->id)->where('lm.isLoc', 0)->where_like('l.formNoAccent', "{$prefix}%")->where('l.verifSp', 0)->where_not_equal('lm.modelType', 'SP')->order_by_asc('l.formNoAccent')->limit(100)->find_many();
// This is nowhere near perfect, but it's a decent approximation for starters. // Gives each lexem a frequency between 0.00 and 1.00 // Stop words defined in stringUtil.php get 1.00 // Other lexems get frequencies distributed uniformly between 0.01 and 1.00 based on their percentile rankings in the full text index. require_once '../phplib/util.php'; ini_set('max_execution_time', '3600'); ini_set('memory_limit', '256M'); assert_options(ASSERT_BAIL, 1); log_scriptLog('Running rebuildLexemFrequencies.php.'); log_scriptLog('Setting frequency to 1.00 for manual stop words'); foreach (StringUtil::$STOPWORDS as $sw) { $lexems = Lexem::get_all_by_formNoAccent($sw); foreach ($lexems as $l) { $l->frequency = 1.0; $l->save(); } } log_scriptLog("Scanning full text index"); $dbResult = db_execute("select lexemId from FullTextIndex group by lexemId order by count(*)"); $numLexems = $dbResult->rowCount(); $i = 0; foreach ($dbResult as $row) { $lexem = Lexem::get_by_id($row[0]); $lexem->frequency = round($i / $numLexems + 0.005, 2); $lexem->save(); $i++; if ($i % 10000 == 0) { log_scriptLog("{$i} of {$numLexems} labeled"); } } log_scriptLog('rebuildLexemFrequencies.php completed successfully');
<?php require_once "../../phplib/util.php"; util_assertModerator(PRIV_EDIT); util_assertNotMirror(); RecentLink::createOrUpdate('Lexeme neasociate'); $lexems = Lexem::loadUnassociated(); SmartyWrap::assign('lexems', $lexems); SmartyWrap::assign('sectionTitle', 'Lexeme neasociate'); SmartyWrap::assign('sectionCount', count($lexems)); SmartyWrap::assign('recentLinks', RecentLink::loadForUser()); SmartyWrap::displayAdminPage('admin/lexemList.ihtml');