$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");
}
$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++;
}
}
if ($errorMessage) {
smarty_assign('lexemNames', $lexemNames);
smarty_assign('sourceId', $sourceId);
smarty_assign('def', $def);
FlashMessage::add($errorMessage);
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 {
function assertAbbreviations($typed, $internal, $html, $sourceId)
{
assertEquals($internal, AdminStringUtil::markAbbreviations($typed, $sourceId));
assertEquals($html, AdminStringUtil::htmlize($internal, $sourceId));
}
// 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);
} 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();
}
}
}
}
}
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);
}
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}");
}
}
<?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;
