function fetchNextRow($row) { global $lexemDbResult; global $sourceMap; global $currentLexem; $def = Model::factory('Definition')->create($row); $def->internalRep = AdminStringUtil::xmlizeRequired($def->internalRep); if (hasFlag('d')) { $def->internalRep = AdminStringUtil::xmlizeOptional($def->internalRep); } $lexemNames = array(); $lexemLatinNames = array(); while (merge_compare($def, $currentLexem) < 0) { $currentLexem = $lexemDbResult->fetch(); } while (merge_compare($def, $currentLexem) == 0) { $lexemNames[] = $currentLexem[1]; $lexemLatinNames[] = StringUtil::unicodeToLatin($currentLexem[1]); $currentLexem = $lexemDbResult->fetch(); } SmartyWrap::assign('def', $def); SmartyWrap::assign('lexemNames', $lexemNames); SmartyWrap::assign('lexemLatinNames', $lexemLatinNames); SmartyWrap::assign('source', $sourceMap[$def->sourceId]); SmartyWrap::assign('user', userCache_get($def->userId)); }
function writeLexems($locVersion, $fileName) { LocVersion::changeDatabase($locVersion); $dbResult = db_execute(DB_QUERY, PDO::FETCH_ASSOC); $handle = fopen($fileName, 'w'); foreach ($dbResult as $row) { $l = Model::factory('Lexem')->create($row); fprintf($handle, AdminStringUtil::padRight(mb_strtoupper($l->form), 20)); fprintf($handle, AdminStringUtil::padRight($l->modelType, 4)); fprintf($handle, AdminStringUtil::padRight($l->modelNumber, 8)); fprintf($handle, $l->restriction . "\n"); } fclose($handle); }
function extractWords($text) { $alphabet = 'abcdefghijklmnopqrstuvwxyzăâîșț'; $text = mb_strtolower($text); $text = AdminStringUtil::removeAccents($text); $result = array(); $currentWord = ''; $chars = AdminStringUtil::unicodeExplode($text); foreach ($chars as $c) { if (strpos($alphabet, $c) !== false) { $currentWord .= $c; } else { if ($currentWord) { $result[] = $currentWord; } $currentWord = ''; } } if ($currentWord) { $result[] = $currentWord; } return $result; }
function dumpDefinitions($query, $remoteFile, $message) { global $FTP, $USERS; log_scriptLog($message); $results = db_execute($query); $tmpFile = tempnam(Config::get('global.tempDir'), 'xmldump_'); $file = gzopen($tmpFile, 'wb9'); gzwrite($file, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); gzwrite($file, "<Definitions>\n"); foreach ($results as $row) { $def = Model::factory('Definition')->create($row); $def->internalRep = AdminStringUtil::xmlizeRequired($def->internalRep); SmartyWrap::assign('def', $def); SmartyWrap::assign('nick', $USERS[$def->userId]); gzwrite($file, SmartyWrap::fetch('xml/xmldump/definition.tpl')); } gzwrite($file, "</Definitions>\n"); gzclose($file); $FTP->staticServerPut($tmpFile, $remoteFile); unlink($tmpFile); }
} else { $number = 0; } $query = Model::factory('Definition')->where('sourceId', $scribanSrc->id)->where('status', 0); if (ctype_digit($line)) { $query = $query->where('id', $line); } else { if ($number) { $query = $query->where_raw("lexicon = '{$line}' and (internalRep rlike '^@{$number}) ' or internalRep rlike '^@\\*{$number}) ')"); } else { $query = $query->where('lexicon', $line); } } $defs = $query->find_many(); if (count($defs) != 1) { printf("Am găsit %d definiții pentru [%s]\n", count($defs), $line); } else { if (strpos(substr($defs[0]->internalRep, 0, 10), $symbol) !== false) { printf("Definiția pentru [%s] conține deja simbolul [%s]\n", $line, $symbol); } else { if ($defs[0]->internalRep[0] != '@') { printf("Definiția pentru [%s] nu începe cu [@]\n", $line); } else { $defs[0]->internalRep = '@' . $symbol . substr($defs[0]->internalRep, 1); $defs[0]->htmlRep = AdminStringUtil::htmlize($defs[0]->internalRep, $scribanSrc->id, $errors); $defs[0]->save(); } } } } }
/** * Creates a map($sourceId => map($from, pair($to, $ambiguous))). * That is, for each sourceId and abbreviated text, we store the expanded text and whether the abbreviation is ambiguous. * An ambigious abbreviation such as "top" or "gen" also has a meaning as an inflected form. * Ambiguous abbreviations should be expanded carefully, or with human approval. */ private static function loadAbbreviations() { if (!self::$ABBREVS) { $raw = self::loadRawAbbreviations(); $result = array(); foreach ($raw['sources'] as $sourceId => $sectionList) { $sections = preg_split('/, */', $sectionList); $list = array(); foreach ($sections as $section) { // If an abbreviation is defined in several sections, use the one that's defined later $list = array_merge($list, $raw[$section]); } $result[$sourceId] = array(); foreach ($list as $from => $to) { $ambiguous = $from[0] == '*'; if ($ambiguous) { $from = substr($from, 1); } $numWords = 1 + substr_count($from, ' '); $regexp = str_replace(array('.', ' '), array("\\.", ' *'), $from); $pattern = "[^-a-zăâîșțáéíóúA-ZĂÂÎȘȚÁÉÍÓÚ.]({$regexp})([^-a-zăâîșțáéíóúA-ZĂÂÎȘȚÁÉÍÓÚ.]|\$)"; $hasCaps = $from !== mb_strtolower($from); $result[$sourceId][$from] = array('to' => $to, 'ambiguous' => $ambiguous, 'regexp' => $pattern, 'numWords' => $numWords, 'hasCaps' => $hasCaps); } // Sort the list by number of words, then by ambiguous uasort($result[$sourceId], 'self::abbrevCmp'); } self::$ABBREVS = $result; } return self::$ABBREVS; }
smarty_assign('previewDivContent', AdminStringUtil::htmlize($def, $sourceId)); } else { $definition = Model::factory('Definition')->create(); $definition->displayed = 0; $definition->status = ST_PENDING; $definition->userId = session_getUserId(); $definition->sourceId = $sourceId; $definition->internalRep = $def; $definition->htmlRep = AdminStringUtil::htmlize($def, $sourceId); $definition->lexicon = AdminStringUtil::extractLexicon($definition); $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})"); }
foreach ($_REQUEST as $name => $value) { if ((StringUtil::startsWith($name, 'caps_') || StringUtil::startsWith($name, 'model_') || StringUtil::startsWith($name, 'comment_') || StringUtil::startsWith($name, 'singular_') || StringUtil::startsWith($name, 'plural_') || StringUtil::startsWith($name, 'verifSp_') || StringUtil::startsWith($name, 'delete_') || StringUtil::startsWith($name, 'deleteConfirm_')) && $value) { $parts = preg_split('/_/', $name); assert(count($parts) == 2); $lexemId = $parts[1]; if (!array_key_exists($lexemId, $lexemMap)) { $lexemMap[$lexemId] = Lexem::get_by_id($lexemId); } $l = $lexemMap[$lexemId]; $lm = $l->getFirstLexemModel(); switch ($parts[0]) { case 'caps': if (StringUtil::startsWith($l->form, "'")) { $l->form = "'" . AdminStringUtil::capitalize(mb_substr($l->form, 1)); } else { $l->form = AdminStringUtil::capitalize($l->form); } $l->formNoAccent = str_replace("'", '', $l->form); break; case 'singular': $lm->restriction = 'S'; break; case 'plural': $lm->restriction = 'P'; break; case 'model': if ($value) { $m = Model::factory('FlexModel')->where_raw("concat(modelType, number) = '{$value}'")->find_one(); if ($m) { $oldModelType = $lm->modelType; $oldModelNumber = $lm->modelNumber;
function assertAbbreviations($typed, $internal, $html, $sourceId) { assertEquals($internal, AdminStringUtil::markAbbreviations($typed, $sourceId)); assertEquals($html, AdminStringUtil::htmlize($internal, $sourceId)); }
if ($oldModelType == 'VT' && $lexem->modelType != 'VT') { $lexem->deleteParticiple($oldModelNumber); } if (($oldModelType == 'VT' || $oldModelType == 'V') && ($lexem->modelType != 'VT' && $lexem->modelType != 'V')) { $lexem->deleteLongInfinitive(); } $lexem->save(); // There are two reasons to regenerate the paradigm: the model has changed // or the form has changed. It's easier to do it every time. $lexem->regenerateParadigm(); log_userLog("Edited lexem {$lexem->id} ({$lexem->form})"); util_redirect("lexemEdit.php?lexemId={$lexem->id}"); } $definitions = Definition::loadByLexemId($lexem->id); $searchResults = SearchResult::mapDefinitionArray($definitions); $definitionLexem = mb_strtoupper(AdminStringUtil::internalize($lexem->form, false)); // Generate new inflected forms, but do not overwrite the old ones. $ifs = $lexem->generateParadigm(); if (!is_array($ifs)) { $infl = Inflection::get_by_id($ifs); if (!$errorMessage) { $errorMessage = "Nu pot genera flexiunea '" . htmlentities($infl->description) . "' " . "conform modelului {$lexem->modelType}{$lexem->modelNumber}."; } } else { $ifMap = InflectedForm::mapByInflectionRank($ifs); smarty_assign('ifMap', $ifMap); smarty_assign('searchResults', $searchResults); } $models = FlexModel::loadByType($lexem->modelType); $sources = LexemSources::getSourceArrayChecked($lexem->source); $sourceNames = LexemSources::getNamesOfSources($lexem->source);
<?php define('FILE_NAME', __DIR__ . '/../../corectii DEXOnline.txt'); require_once __DIR__ . '/../../phplib/util.php'; util_assertModerator(PRIV_EDIT); util_assertNotMirror(); $id = util_getRequestParameter('id'); $def = Definition::get_by_id($id); assert($def); $lines = file(FILE_NAME); $lines = array_slice($lines, 1); // First line contains the column descriptions foreach ($lines as $line) { $parts = explode("\t", trim($line)); assert(count($parts) == 4); list($id, $wrong, $right, $code) = $parts; if ($id == $def->id) { $def->internalRep = $right; $def->htmlRep = AdminStringUtil::htmlize($right, $def->sourceId); $def->lexicon = AdminStringUtil::extractLexicon($def); $def->save(); break; // I know. Shut up. } }
} } } } else { $lexems = Model::factory('Lexem')->select('Lexem.*')->join('LexemDefinitionMap', 'Lexem.id = lexemId')->where('definitionId', $definitionId)->find_many(); } if ($commentContents) { if (!$comment) { $comment = Model::factory('comment')->create(); $commend->status = ST_ACTIVE; $comment->definitionId = $definitionId; } $newContents = AdminStringUtil::internalizeDefinition($commentContents, $sourceId); if ($newContents != $comment->contents) { $comment->contents = $newContents; $comment->htmlContents = AdminStringUtil::htmlize($comment->contents, $sourceId); if (!$preserveCommentUser) { $comment->userId = session_getUserId(); } } } else { if ($comment) { // User wiped out the existing comment, set status to DELETED. $comment->status = ST_DELETED; $comment->userId = session_getUserId(); } } if (($acceptButton || $moveButton) && !$hasErrors) { // The only difference between these two is that but_move also changes the // status to Active if ($moveButton) {
<?php require_once "../../phplib/util.php"; $internalRep = util_getRequestParameter('internalRep'); $sourceId = util_getRequestParameter('sourceId'); $reallyInternalRep = AdminStringUtil::internalizeDefinition($internalRep, $sourceId); $htmlRep = AdminStringUtil::htmlize($reallyInternalRep, $sourceId); echo $htmlRep;
function dumpDefinitions($query, $fileName, $message) { global $USERS; log_scriptLog($message); $results = db_execute($query); $file = gzopen($fileName, 'wb9'); gzwrite($file, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); gzwrite($file, "<Definitions>\n"); foreach ($results as $row) { $def = Model::factory('Definition')->create($row); $def->internalRep = AdminStringUtil::xmlizeRequired($def->internalRep); smarty_assign('def', $def); smarty_assign('nick', $USERS[$def->userId]); gzwrite($file, smarty_fetch('xmldump/definition.ihtml')); } gzwrite($file, "</Definitions>\n"); gzclose($file); }
function format($row) { return AdminStringUtil::padRight($row['form'], 20) . AdminStringUtil::padRight($row['modelType'], 4) . AdminStringUtil::padRight($row['modelNumber'], 8) . $row['restriction']; }
<?php require_once "../../phplib/util.php"; $query = util_getRequestParameter('term'); $parts = preg_split('/\\(/', $query, 2); $name = AdminStringUtil::internalizeWordName(trim($parts[0])); $field = StringUtil::hasDiacritics($name) ? 'formNoAccent' : 'formUtf8General'; if (count($parts) == 2) { $description = trim($parts[1]); $description = str_replace(')', '', $description); $lexems = Model::factory('Lexem')->where($field, $name)->where_like('description', "{$description}%")->order_by_asc('formNoAccent')->order_by_asc('description')->limit(10)->find_many(); } else { $lexems = Model::factory('Lexem')->where_like($field, "{$name}%")->order_by_asc('formNoAccent')->limit(10)->find_many(); } $resp = array('results' => array()); foreach ($lexems as $l) { $resp['results'][] = array('id' => $l->id, 'text' => (string) $l); } print json_encode($resp);
function handleLexemActions() { $lexemId = util_getRequestParameter('lexemId'); $lexem = Lexem::get_by_id($lexemId); $associateDefinitionId = util_getRequestParameter('associateDefinitionId'); if ($associateDefinitionId) { LexemDefinitionMap::associate($lexem->id, $associateDefinitionId); util_redirect("lexemEdit.php?lexemId={$lexem->id}"); } $dissociateDefinitionId = util_getRequestParameter('dissociateDefinitionId'); if ($dissociateDefinitionId) { LexemDefinitionMap::dissociate($lexem->id, $dissociateDefinitionId); util_redirect("lexemEdit.php?lexemId={$lexem->id}"); } $createDefinition = util_getRequestParameter('createDefinition'); $miniDefTarget = util_getRequestParameter('miniDefTarget'); if ($createDefinition) { $def = Model::factory('Definition')->create(); $def->userId = session_getUserId(); $def->sourceId = Source::get_by_shortName('Neoficial')->id; $def->lexicon = $lexem->formNoAccent; $def->internalRep = '@' . mb_strtoupper(AdminStringUtil::internalize($lexem->form, false)) . '@ v. @' . $miniDefTarget . '.@'; $def->htmlRep = AdminStringUtil::htmlize($def->internalRep, $def->sourceId); $def->status = Definition::ST_ACTIVE; $def->save(); LexemDefinitionMap::associate($lexem->id, $def->id); util_redirect("lexemEdit.php?lexemId={$lexem->id}"); } $deleteLexem = util_getRequestParameter('deleteLexem'); if ($deleteLexem) { $homonyms = Model::factory('Lexem')->where('formNoAccent', $lexem->formNoAccent)->where_not_equal('id', $lexem->id)->find_many(); $lexem->delete(); SmartyWrap::assign('lexem', $lexem); SmartyWrap::assign('homonyms', $homonyms); SmartyWrap::displayAdminPage('admin/lexemDeleted.tpl'); exit; } $cloneLexem = util_getRequestParameter('cloneLexem'); if ($cloneLexem) { $newLexem = $lexem->cloneLexem(); log_userLog("Cloned lexem {$lexem->id} ({$lexem->form}), new id is {$newLexem->id}"); util_redirect("lexemEdit.php?lexemId={$newLexem->id}"); } $mergeLexem = util_getRequestParameter('mergeLexem'); $mergeLexemId = util_getRequestParameter('mergeLexemId'); if ($mergeLexem) { $other = Lexem::get_by_id($mergeLexemId); if ($lexem->form != $other->form) { FlashMessage::add('Nu pot unifica lexemele deoarece accentele diferă. Rezolvați diferența și încercați din nou.'); util_redirect("lexemEdit.php?lexemId={$lexem->id}"); } $defs = Definition::loadByLexemId($lexem->id); foreach ($defs as $def) { LexemDefinitionMap::associate($other->id, $def->id); } // Add lexem models from $lexem to $other if the form is the same. Exclude T-type models. $displayOrder = count($other->getLexemModels()); foreach ($lexem->getLexemModels() as $lm) { if ($lm->modelType != 'T' && !$other->hasModel($lm->modelType, $lm->modelNumber)) { $lm->lexemId = $other->id; $lm->displayOrder = ++$displayOrder; $lm->save(); } } // Add meanings from $lexem to $other and renumber their displayOrder and breadcrumb // displayOrders are generated sequentially regardless of level. // Breadcrumbs follow levels so only their first part changes. $counter = Model::factory('Meaning')->where('lexemId', $other->id)->count(); $numRoots = Model::factory('Meaning')->where('lexemId', $other->id)->where('parentId', 0)->count(); $meanings = Model::factory('Meaning')->where('lexemId', $lexem->id)->order_by_asc('displayOrder')->find_many(); foreach ($meanings as $m) { $m->lexemId = $other->id; $m->displayOrder = ++$counter; $parts = explode('.', $m->breadcrumb, 2); $parts[0] += $numRoots; $m->breadcrumb = implode('.', $parts); $m->save(); } // Add images and image tags from $lexem to $other $visuals = Visual::get_all_by_lexemeId($lexem->id); foreach ($visuals as $v) { $v->lexemeId = $other->id; $v->save(); } $visualTags = VisualTag::get_all_by_lexemeId($lexem->id); foreach ($visualTags as $vt) { $vt->lexemeId = $other->id; $vt->save(); } $lexem->delete(); util_redirect("lexemEdit.php?lexemId={$other->id}"); } }
SmartyWrap::assign('abbrev', AdminStringUtil::loadRawAbbreviations()); SmartyWrap::displayWithoutSkin('xml/update3Abbrev.tpl'); } else { if ($export == 'definitions') { userCache_init(); $statusClause = $timestamp ? '' : ' and status = 0'; $defDbResult = db_execute("select * from Definition where modDate >= '{$timestamp}' and sourceId in (select id from Source where canDistribute) " . "{$statusClause} order by modDate, id", PDO::FETCH_ASSOC); // $lexemDbResult = db_execute("select Definition.id, lexemId from Definition force index(modDate), LexemDefinitionMap " . "where Definition.id = definitionId and Definition.modDate >= {$timestamp} " . "and sourceId in (select id from Source where canDistribute) " . "{$statusClause} order by Definition.modDate, Definition.id", PDO::FETCH_NUM); $currentLexem = $lexemDbResult->fetch(); print "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; print "<Definitions>\n"; print " <NumResults>" . $defDbResult->rowCount() . "</NumResults>\n"; foreach ($defDbResult as $dbRow) { $def = Model::factory('Definition')->create($dbRow); $def->internalRep = AdminStringUtil::xmlizeRequired($def->internalRep); $lexemIds = array(); while ($currentLexem && $currentLexem[0] == $def->id) { $lexemIds[] = $currentLexem[1]; $currentLexem = $lexemDbResult->fetch(); } prepareDefForVersion($def); SmartyWrap::assign('def', $def); SmartyWrap::assign('lexemIds', $lexemIds); SmartyWrap::assign('user', userCache_get($def->userId)); SmartyWrap::displayWithoutSkin('xml/update3Definitions.tpl'); } print "</Definitions>\n"; } else { if ($export == 'lexems') { $lexemDbResult = db_execute("select * from Lexem where modDate >= '{$timestamp}' order by modDate, id");
static function saveTree($meanings, $lexem) { $seenMeaningIds = array(); // Keep track of the previous meaning ID at each level. This allows us to populate the parentId field $meaningStack = array(); $displayOrder = 1; foreach ($meanings as $tuple) { $m = $tuple->id ? self::get_by_id($tuple->id) : Model::factory('Meaning')->create(); $m->parentId = $tuple->level ? $meaningStack[$tuple->level - 1] : 0; $m->displayOrder = $displayOrder++; $m->breadcrumb = $tuple->breadcrumb; $m->userId = session_getUserId(); $m->lexemId = $lexem->id; $m->internalRep = $tuple->internalRep; $m->htmlRep = AdminStringUtil::htmlize($m->internalRep, 0); $m->internalEtymology = $tuple->internalEtymology; $m->htmlEtymology = AdminStringUtil::htmlize($m->internalEtymology, 0); $m->internalComment = $tuple->internalComment; $m->htmlComment = AdminStringUtil::htmlize($m->internalComment, 0); $m->save(); $meaningStack[$tuple->level] = $m->id; $sourceIds = StringUtil::explode(',', $tuple->sourceIds); MeaningSource::updateList(array('meaningId' => $m->id), 'sourceId', $sourceIds); $meaningTagIds = StringUtil::explode(',', $tuple->meaningTagIds); MeaningTagMap::updateList(array('meaningId' => $m->id), 'meaningTagId', $meaningTagIds); foreach ($tuple->relationIds as $type => $lexemIdString) { if ($type) { $lexemIds = StringUtil::explode(',', $lexemIdString); Relation::updateList(array('meaningId' => $m->id, 'type' => $type), 'lexemId', $lexemIds); } } $seenMeaningIds[] = $m->id; } self::deleteNotInSet($seenMeaningIds, $lexem->id); }
// any string that won't occur naturally in a definition $def = null; $ids = db_getArray(sprintf('select id from Definition where status != %d and abbrevReview = %d', ST_DELETED, ABBREV_AMBIGUOUS)); if (count($ids)) { $defId = $ids[array_rand($ids, 1)]; $def = Definition::get_by_id($defId); // Collect the positions of ambiguous abbreviations $matches = array(); AdminStringUtil::markAbbreviations($def->internalRep, $def->sourceId, $matches); usort($matches, 'positionCmp'); // Inject our marker around each ambiguity and htmlize the definition $s = $def->internalRep; foreach ($matches as $m) { $s = substr($s, 0, $m['position']) . " {$MARKER} " . substr($s, $m['position'], $m['length']) . " {$MARKER} " . substr($s, $m['position'] + $m['length']); } $s = AdminStringUtil::htmlize($s, $def->sourceId); // Split the definition into n ambiguities and n+1 bits of text between the ambiguities $text = array(); $ambiguities = array(); while (($p = strpos($s, $MARKER)) !== false) { $chunk = trim(substr($s, 0, $p)); $s = trim(substr($s, $p + strlen($MARKER))); if (count($text) == count($ambiguities)) { $text[] = $chunk; } else { $ambiguities[] = $chunk; } } $text[] = trim($s); SmartyWrap::assign('text', $text); SmartyWrap::assign('ambiguities', $ambiguities);
<?php /* Htmlizes the definition and comment, then builds the SimilarRecord */ require_once "../../phplib/util.php"; util_assertModerator(PRIV_EDIT); util_assertNotMirror(); $definitionId = util_getRequestParameter('definitionId'); $definitionInternalRep = util_getRequestParameter('definitionInternalRep'); $commentInternalRep = util_getRequestParameter('commentInternalRep'); $sourceId = util_getRequestParameter('sourceId'); $lexemIds = util_getRequestCsv('lexemIds'); $d = Definition::get_by_id($definitionId); $d->internalRep = AdminStringUtil::internalizeDefinition($definitionInternalRep, $sourceId); $d->htmlRep = AdminStringUtil::htmlize($d->internalRep, $sourceId); $d->sourceId = $sourceId; $commentInternalRep = AdminStringUtil::internalizeDefinition($commentInternalRep, $sourceId); $commentHtmlRep = AdminStringUtil::htmlize($commentInternalRep, $sourceId); $sim = SimilarRecord::create($d, $lexemIds); $data = $sim->getJsonFriendly(); $data['htmlRep'] = $d->htmlRep; $data['commentHtmlRep'] = $commentHtmlRep; print json_encode($data);
$modified = 0; $ambiguousDefinitions = 0; $ambiguities = 0; foreach ($dbResult as $row) { $def = Definition::get_by_id($row['id']); $ambiguousMatches = array(); // Remove existing hash signs $newRep = str_replace('#', '', $def->internalRep); $newRep = AdminStringUtil::internalizeDefinition($newRep, $def->sourceId, $ambiguousMatches); if (count($ambiguousMatches) || $newRep !== $def->internalRep) { print "{$def->id} {$newRep}\n"; } if ($newRep !== $def->internalRep) { $modified++; $def->internalRep = $newRep; $def->htmlRep = AdminStringUtil::htmlize($newRep, $def->sourceId); } if (count($ambiguousMatches)) { $def->abbrevReview = ABBREV_AMBIGUOUS; $ambiguousDefinitions++; $ambiguities += count($ambiguousMatches); print " AMBIGUOUS:"; foreach ($ambiguousMatches as $match) { print " [{$match['abbrev']}]@{$match['position']}"; } print "\n"; } else { $def->abbrevReview = ABBREV_REVIEW_COMPLETE; } $def->save(); $i++;
SmartyWrap::assign('def', $def); FlashMessage::add($errorMessage); SmartyWrap::assign('previewDivContent', AdminStringUtil::htmlize($def, $sourceId)); } else { $definition = Model::factory('Definition')->create(); $definition->status = ST_PENDING; $definition->userId = session_getUserId(); $definition->sourceId = $sourceId; $definition->internalRep = $def; $definition->htmlRep = AdminStringUtil::htmlize($def, $sourceId); $definition->lexicon = AdminStringUtil::extractLexicon($definition); $definition->abbrevReview = count($ambiguousMatches) ? ABBREV_AMBIGUOUS : ABBREV_REVIEW_COMPLETE; $definition->save(); log_userLog("Added definition {$definition->id} ({$definition->lexicon})"); foreach ($lexemIds as $lexemId) { $lexemId = addslashes(AdminStringUtil::formatLexem($lexemId)); if (StringUtil::startsWith($lexemId, '@')) { // create a new lexem $lexem = Lexem::deepCreate(substr($lexemId, 1), 'T', '1'); $lexem->deepSave(); LexemDefinitionMap::associate($lexem->id, $definition->id); log_userLog("Created lexem {$lexem->id} ({$lexem->form})"); } else { $lexem = Lexem::get_by_id($lexemId); LexemDefinitionMap::associate($lexem->id, $definition->id); log_userLog("Associating with 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'); }
$sourceClause = $sourceId ? "and sourceId = {$sourceId}" : ''; $count = Model::factory('Definition')->where_raw("status = 0 {$sourceClause} and binary internalRep like '%{$search}%'")->count(); if ($count > $MAX_AFFECTED) { if ($realRun) { FlashMessage::add("{$count} definiții se potrivesc, numai {$MAX_AFFECTED} au fost modificate.", 'info'); } else { FlashMessage::add("{$count} definiții se potrivesc, maxim {$MAX_AFFECTED} vor fi modificate."); } } $defs = Model::factory('Definition')->where_raw("status = 0 {$sourceClause} and binary internalRep like '%{$search}%'")->order_by_asc('id')->limit($MAX_AFFECTED)->find_many(); $searchResults = SearchResult::mapDefinitionArray($defs); foreach ($defs as $def) { $def->internalRep = str_replace($search, $replace, $def->internalRep); $ambiguousMatches = array(); $def->internalRep = AdminStringUtil::internalizeDefinition($def->internalRep, $def->sourceId, $ambiguousMatches); $def->htmlRep = AdminStringUtil::htmlize($def->internalRep, $def->sourceId); // Complete or un-complete the abbreviation review if (!count($ambiguousMatches) && $def->abbrevReview == ABBREV_AMBIGUOUS) { $def->abbrevReview = ABBREV_REVIEW_COMPLETE; } else { if (count($ambiguousMatches) && $def->abbrevReview == ABBREV_REVIEW_COMPLETE) { $def->abbrevReview = ABBREV_AMBIGUOUS; } } if ($realRun) { $def->save(); } } if ($realRun) { util_redirect("index.php"); }
/** * Creates a map of $sourceId => array of sections to use. * Each section resides in a file named docs/abbrev/<section>.conf (these are loaded lazily). */ static function loadAbbreviationsIndex() { if (!self::$ABBREV_INDEX) { self::$ABBREV_INDEX = array(); $raw = parse_ini_file(util_getRootPath() . "docs/abbrev/abbrev.conf", true); foreach ($raw['sources'] as $sourceId => $sectionList) { self::$ABBREV_INDEX[$sourceId] = preg_split('/, */', $sectionList); } } return self::$ABBREV_INDEX; }