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;
}
