/**
* Returns true on success, false on errors.
*/
function validate($src)
{
$success = true;
if (!$src->name) {
FlashMessage::add('Numele nu poate fi vid.');
$success = false;
}
if (!$src->shortName) {
FlashMessage::add('Numele scurt nu poate fi vid.');
$success = false;
}
if (!$src->urlName) {
FlashMessage::add('Numele URL nu poate fi vid.');
$success = false;
}
if (!$src->author) {
FlashMessage::add('Autorul nu poate fi vid.');
$success = false;
}
if ($src->defCount < 0 && $src->defCount != Source::$UNKNOWN_DEF_COUNT) {
FlashMessage::add("Numărul de definiții trebuie să fie pozitiv.");
$success = false;
}
return $success;
}
/**
* Returns null and sets a flash message on all errors.
**/
static function finishAuth()
{
$consumer = self::getConsumer();
$return_to = self::getReturnTo();
$response = $consumer->complete($return_to);
if ($response->status == Auth_OpenID_CANCEL) {
FlashMessage::add('Verificare anulată.');
return null;
} else {
if ($response->status == Auth_OpenID_FAILURE) {
FlashMessage::add('Verificarea a eșuat: ' . $response->message);
return null;
} else {
if ($response->status == Auth_OpenID_SUCCESS) {
$result = array();
$result['identity'] = htmlentities($response->getDisplayIdentifier());
if ($response->endpoint->canonicalID) {
$escaped_canonicalID = htmlentities($response->endpoint->canonicalID);
// Ignored for now
}
$sreg_resp = Auth_OpenID_SRegResponse::fromSuccessResponse($response);
if ($sreg_resp) {
$sreg = $sreg_resp->contents();
if (isset($sreg['email'])) {
$result['email'] = $sreg['email'];
}
if (isset($sreg['nickname'])) {
$result['nickname'] = $sreg['nickname'];
}
if (isset($sreg['fullname'])) {
$result['fullname'] = $sreg['fullname'];
}
}
$ax_resp = Auth_OpenID_AX_FetchResponse::fromSuccessResponse($response);
if ($ax_resp) {
$data = $ax_resp->data;
if (isset($data['http://axschema.org/contact/email']) && count($data['http://axschema.org/contact/email'])) {
$result['email'] = $data['http://axschema.org/contact/email'][0];
// Take this over sreg
}
if (isset($data['http://axschema.org/namePerson']) && count($data['http://axschema.org/namePerson'])) {
$result['fullname'] = $data['http://axschema.org/namePerson'][0];
}
$names = array();
if (isset($data['http://axschema.org/namePerson/first']) && count($data['http://axschema.org/namePerson/first'])) {
$names[] = $data['http://axschema.org/namePerson/first'][0];
}
if (isset($data['http://axschema.org/namePerson/last']) && count($data['http://axschema.org/namePerson/last'])) {
$names[] = $data['http://axschema.org/namePerson/last'][0];
}
if (count($names)) {
$result['fullname'] = implode(' ', $names);
}
}
return $result;
}
}
}
}
public function regenerateLongInfinitive()
{
$infl = Inflection::loadLongInfinitive();
$ifs = Model::factory('InflectedForm')->where('lexemId', $this->id)->where('inflectionId', $infl->id)->find_many();
$f107 = Model::factory('FlexModel')->where('modelType', 'F')->where('number', '107')->find_one();
$f113 = Model::factory('FlexModel')->where('modelType', 'F')->where('number', '113')->find_one();
foreach ($ifs as $if) {
$model = StringUtil::endsWith($if->formNoAccent, 'are') ? $f113 : $f107;
// Load an existing lexem only if it has one of the models F113, F107 or T1. Otherwise create a new lexem.
$lexems = Lexem::get_all_by_formNoAccent($if->formNoAccent);
$lexem = null;
foreach ($lexems as $l) {
if ($l->modelType == 'T' || $l->modelType == 'F' && $l->modelNumber == $model->number) {
$lexem = $l;
} else {
if ($this->isLoc && !$l->isLoc) {
FlashMessage::add("Lexemul {$l->formNoAccent} ({$l->modelType}{$l->modelNumber}), care nu este în LOC, nu a fost modificat.", 'info');
}
}
}
if ($lexem) {
$lexem->modelType = 'F';
$lexem->modelNumber = $model->number;
$lexem->restriction = '';
if ($this->isLoc && !$lexem->isLoc) {
$lexem->isLoc = $this->isLoc;
FlashMessage::add("Lexemul {$lexem->formNoAccent}, care nu era în LOC, a fost inclus automat în LOC.", 'info');
}
$lexem->noAccent = false;
$lexem->save();
} else {
$lexem = Lexem::create($if->form, 'F', $model->number, '');
$lexem->isLoc = $this->isLoc;
$lexem->save();
// Also associate the new lexem with the same definitions as $this.
$ldms = LexemDefinitionMap::get_all_by_lexemId($this->id);
foreach ($ldms as $ldm) {
LexemDefinitionMap::associate($lexem->id, $ldm->definitionId);
}
FlashMessage::add("Am creat automat lexemul {$lexem->formNoAccent} (F{$lexem->modelNumber}) și l-am asociat cu toate definițiile verbului.", 'info');
}
$lexem->regenerateParadigm();
}
}
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');
smarty_assign('suggestNoBanner', true);
smarty_displayCommonPageWithSkin('contribuie.ihtml');
/**************************************************************************/
function deleteEmptyElements(&$v)
{
$result = array();
foreach ($v as $elem) {
if (!empty($elem)) {
// Exercise the fields we'll need later in the view.
// TODO: this code replicates code from search.php
$hasUnrecommendedForms = false;
foreach ($filtered_lexems as $l) {
foreach ($l->getLexemModels() as $lm) {
$lm->getModelType();
$lm->getSourceNames();
$map = $lm->loadInflectedFormMap();
$lm->addLocInfo();
foreach ($map as $ifs) {
foreach ($ifs as $if) {
$hasUnrecommendedForms |= !$if->recommended;
}
}
}
}
SmartyWrap::assign('hasUnrecommendedForms', $hasUnrecommendedForms);
SmartyWrap::assign('lexems', $filtered_lexems);
SmartyWrap::assign('showParadigm', true);
SmartyWrap::assign('locParadigm', session_user_prefers(Preferences::LOC_PARADIGM));
SmartyWrap::assign('onlyParadigm', !$ajax);
} else {
FlashMessage::add("Niciun rezultat pentru {$cuv}.");
SmartyWrap::assign('page_title', "Eroare");
}
if ($ajax) {
SmartyWrap::displayWithoutSkin('bits/multiParadigm.ihtml');
} else {
SmartyWrap::addCss('paradigm');
SmartyWrap::display('search.ihtml');
}
if ($error) {
throw new OpenIDException($errorDescription);
}
if (!$code || !$state || $state != session_get('openid_connect_state')) {
throw new OpenIDException('Răspuns incorect de la server');
}
if (!$provider) {
throw new OpenIDException('Sesiune coruptă');
}
$token = $oidc->requestToken($code);
$data = $oidc->getUserInfo($token);
if (!isset($data['sub'])) {
throw new OpenIDException('Date incorecte de la furnizor');
}
} catch (OpenIDException $e) {
FlashMessage::add('Eroare la autentificare: ' . $e->getMessage());
util_redirect('login.php');
}
// With OpenID connect, the user is uniquely identified by (provider, sub).
// We store the provider in the User.identity field for backwards compatibility with OpenID.
// We also rename the name field to fullname, plain OpenID style
$data['identity'] = $provider;
if (isset($data['name'])) {
$data['fullname'] = $data['name'];
}
$user = User::get_by_identity_openidConnectSub($provider, $data['sub']);
if (!$user && $oidc->getPlainOpenid()) {
// This may be the first time the user logs in after the migration from
// OpenID 2.0 to OpenID Connect.
$user = User::get_by_identity($oidc->getPlainOpenid());
if ($user) {
/**
* Delete lexems that do not have their own definitions.
* Arguments for participles: 'A', ($adjectiveModel).
* Arguments for long infinitives: 'F', ('107', '113').
*/
private function _deleteDependentModels($inflId, $modelType, $modelNumbers)
{
// Load and hash all the definitionIds
$ldms = LexemDefinitionMap::get_all_by_lexemId($this->id);
$defHash = array();
foreach ($ldms as $ldm) {
$defHash[$ldm->definitionId] = true;
}
// Iterate through all the forms of the desired inflection (participle / long infinitive)
foreach ($this->getLexemModels() as $lm) {
$ifs = InflectedForm::get_all_by_lexemModelId_inflectionId($lm->id, $inflId);
foreach ($ifs as $if) {
// Examine all lexems having one of the above forms
$lexems = Lexem::get_all_by_formNoAccent($if->formNoAccent);
foreach ($lexems as $l) {
// Keep only the ones that have acceptable model types/numbers
$acceptable = false;
foreach ($l->getLexemModels() as $o) {
if ($o->modelType == 'T' || $o->modelType == $modelType && in_array($o->modelNumber, $modelNumbers)) {
$acceptable = true;
}
}
// If $l has the right model, delete it unless it has its own definitions
if ($acceptable) {
$ownDefinitions = false;
$ldms = LexemDefinitionMap::get_all_by_lexemId($l->id);
foreach ($ldms as $ldm) {
if (!array_key_exists($ldm->definitionId, $defHash)) {
$ownDefinitions = true;
}
}
if (!$ownDefinitions) {
FlashMessage::add("Am șters automat lexemul {$l->formNoAccent}.", 'info');
$l->delete();
}
}
}
}
}
}
$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' : ''));
}
smarty_assign('lexems', $lexems);
if ($searchType == SEARCH_INFLECTED) {
// For successful searches, load the definitions, inflections and linguistic articles
$definitions = Definition::loadForLexems($lexems, $sourceId, $cuv, $exclude_unofficial);
smarty_assign('wikiArticles', WikiArticle::loadForLexems($lexems));
}
}
} else {
$openidNick = $loginType == 1 ? $data['fullname'] : ($loginType == 2 ? $data['nickname'] : $nick);
$user = User::get_by_nick($openidNick);
if ($user) {
FlashMessage::add('Acest nume de utilizator este deja luat.');
} else {
if (mb_strlen($openidNick) < 3 || mb_strlen($openidNick) > 20) {
FlashMessage::add('Numele de utilizator trebuie să aibă între 3 și 20 de caractere.');
} else {
if (!preg_match("/^([-a-z0-9_. ]|ă|â|î|ș|ț|Ă|Â|Î|Ș|Ț)+\$/i", $openidNick)) {
FlashMessage::add('Numele de utilizator poate conține doar litere, cifre, spații și simbolurile . - _');
} else {
if (!preg_match("/[a-z]|ă|â|î|ș|ț|Ă|Â|Î|Ș|Ț/i", $openidNick)) {
FlashMessage::add('Numele de utilizator trebuie să conțină cel puțin o literă.');
} else {
$data['nickname'] = $openidNick;
session_login(null, $data);
}
}
}
}
}
}
smarty_assign('page_title', 'Autentificare cu OpenID');
smarty_assign('suggestHiddenSearchForm', true);
smarty_assign('data', $data);
smarty_assign('randString', $randString);
smarty_assign('loginType', $loginType);
smarty_displayCommonPageWithSkin('auth/chooseIdentity.ihtml');
<?php
require_once "../phplib/util.php";
util_assertModerator(PRIV_ADMIN);
$userIds = util_getRequestParameter('userIds');
$newNick = util_getRequestParameter('newNick');
$newCheckboxes = util_getRequestParameterWithDefault("newPriv", array());
$submitButton = util_getRequestParameter('submitButton');
if ($submitButton) {
foreach ($userIds as $userId) {
$checkboxes = util_getRequestParameterWithDefault("priv_{$userId}", array());
$user = User::get_by_id($userId);
$user->moderator = array_sum($checkboxes);
$user->save();
}
if ($newNick) {
$user = User::get_by_nick($newNick);
if ($user) {
$user->moderator = array_sum($newCheckboxes);
$user->save();
} else {
FlashMessage::add("Numele de utilizator „{$newNick}” nu există");
util_redirect("moderatori");
}
}
FlashMessage::add('Modificările au fost salvate', 'info');
util_redirect("moderatori");
}
smarty_assign('page_title', 'Moderatori');
smarty_assign('users', Model::factory('User')->where_not_equal('moderator', 0)->order_by_asc('nick')->find_many());
smarty_displayCommonPageWithSkin('moderatori.ihtml');
$error = 'A intervenit o eroare la încărcare.';
}
}
}
}
if ($error) {
FlashMessage::add($error);
util_redirect(util_getWwwRoot() . 'preferinte');
}
$user = session_getUser();
if (!$user) {
FlashMessage::add('Nu puteți alege o imagine de profil dacă nu sunteți autentificat.');
util_redirect(util_getWwwRoot());
}
// Remove any old files (with different extensions)
$oldFiles = glob(util_getRootPath() . "wwwbase/img/user/{$user->id}_raw.*");
foreach ($oldFiles as $oldFile) {
unlink($oldFile);
}
$ext = pathinfo($file['name'], PATHINFO_EXTENSION);
$destFileName = util_getRootPath() . "wwwbase/img/user/{$user->id}_raw.{$ext}";
if (!move_uploaded_file($file['tmp_name'], $destFileName)) {
FlashMessage::add('A intervenit o eroare la copierea fișierului.');
util_redirect(util_getWwwRoot() . 'preferinte');
}
chmod($destFileName, 0666);
SmartyWrap::addCss('jcrop');
SmartyWrap::addJs('jcrop');
SmartyWrap::assign('page_title', "Editarea pozei de profil");
SmartyWrap::assign('rawFileName', "{$user->id}_raw.{$ext}");
SmartyWrap::display('editare-avatar.ihtml');
// OpenID connect, but no dynamic registration and no explicit config.
// Log this and display an error message.
log_userlog("Need OpenID Connect registration for {$openid}");
FlashMessage::add('Momentan nu putem accepta OpenID de la acest furnizor. Problema nu ține de noi, dar vom încerca să o reparăm.');
}
} else {
// asume plain OpenID
$isOpenidConnect = false;
}
}
if (!FlashMessage::getMessage()) {
if ($isOpenidConnect) {
try {
$oidc->authenticate($oidcId, $oidcSecret);
} catch (OpenIDException $e) {
FlashMessage::add($e->getMessage());
}
} else {
$authResult = OpenID::beginAuth($openid, null);
if ($authResult != null) {
SmartyWrap::displayWithoutSkin('auth/beginAuth.ihtml');
exit;
}
}
}
}
if ($devel) {
SmartyWrap::assign('allowFakeUsers', true);
SmartyWrap::assign('privilegeNames', $PRIV_NAMES);
SmartyWrap::assign('fakeUserNick', 'test' . rand(10000, 99999));
}
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}");
}
}
static function addJs()
{
// Note the priorities. This allows files to be added in any order, regardless of dependencies
foreach (func_get_args() as $id) {
switch ($id) {
case 'jquery':
self::$jsFiles[1] = 'jquery-1.10.2.min.js';
break;
case 'jqueryui':
self::$jsFiles[2] = 'jquery-ui-1.10.3.custom.min.js';
break;
case 'jqgrid':
self::$jsFiles[3] = 'grid.locale-en.js?v=2';
self::$jsFiles[4] = 'jquery.jqGrid.min.js?v=3';
break;
case 'jqnotice':
self::$jsFiles[5] = 'jquery.notice.js';
break;
case 'jqTableDnd':
self::$jsFiles[6] = 'jquery.tablednd.0.8.min.js?v=1';
break;
case 'tablesorter':
self::$jsFiles[7] = 'jquery.tablesorter.min.js?v=5';
self::$jsFiles[8] = 'tablesorter.dev.js?v=3';
break;
case 'pager':
self::$jsFiles[9] = 'jquery.tablesorter.pager.min.js';
break;
case 'elfinder':
self::$jsFiles[10] = 'elfinder.min.js?v=1';
break;
case 'windowEngine':
self::$jsFiles[11] = 'jquery-wm.js';
break;
case 'cookie':
self::$jsFiles[12] = 'jquery.cookie.js?v=1';
break;
case 'dex':
self::$jsFiles[13] = 'dex.js?v=29';
break;
case 'flex':
self::$jsFiles[14] = 'flex.js?v=2';
break;
case 'hangman':
self::$jsFiles[15] = 'hangman.js?v=5';
break;
case 'mill':
self::$jsFiles[16] = 'mill.js?v=3';
break;
case 'wotd':
self::$jsFiles[17] = 'wotd.js?v=2';
break;
case 'lexemEdit':
self::$jsFiles[18] = 'lexemEdit.js?v=15';
break;
case 'jcrop':
self::$jsFiles[19] = 'jquery.Jcrop.min.js?v=2';
break;
case 'select2':
self::$jsFiles[20] = 'select2.min.js?v=3';
break;
case 'select2Dev':
self::$jsFiles[21] = 'select2Dev.js?v=7';
break;
case 'visual':
self::$jsFiles[22] = 'visual.js?v=2';
break;
case 'visualTag':
self::$jsFiles[23] = 'visualTag.js?v=2';
break;
case 'gallery':
self::$jsFiles[24] = 'colorbox/jquery.colorbox-min.js';
self::$jsFiles[25] = 'colorbox/jquery.colorbox-ro.js';
self::$jsFiles[26] = 'dexGallery.js?v=2';
self::$jsFiles[27] = 'jcanvas.min.js';
break;
case 'modelDropdown':
self::$jsFiles[28] = 'modelDropdown.js';
break;
case 'textComplete':
self::$jsFiles[29] = 'jquery.textcomplete.min.js';
break;
case 'definitionEdit':
self::$jsFiles[30] = 'definitionEdit.js';
break;
default:
FlashMessage::add("Cannot load JS script {$id}");
util_redirect(util_getWwwRoot());
}
}
}
$ldms = array();
foreach ($lexemNames as $lexemName) {
$lexemName = trim($lexemName);
if ($lexemName) {
$matches = Lexem::loadByExtendedName($lexemName);
if (count($matches) >= 1) {
foreach ($matches as $match) {
if (!in_array($match->id, $lexemIds)) {
$lexemIds[] = $match->id;
$lexems[] = $match;
$ldms[] = LexemDefinitionMap::create($match->id, $definitionId);
}
}
} else {
$hasErrors = true;
FlashMessage::add("Lexemul <i>" . htmlentities($lexemName) . "</i> nu există. Folosiți lista de sugestii pentru a-l corecta.");
$lexems[] = Lexem::create($lexemName, 0, '', '');
// We won't be needing $ldms since there is an error.
}
}
}
} 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);
util_redirect(util_getWwwRoot());
}
$rawFileName = $rawFileList[0];
$canvas = imagecreatetruecolor(AVATAR_RESOLUTION, AVATAR_RESOLUTION);
$image = loadImage($rawFileName);
imagecopyresampled($canvas, $image, 0, 0, $x0, $y0, AVATAR_RESOLUTION, AVATAR_RESOLUTION, $side, $side);
sharpenImage($canvas);
$tmpFileName = tempnam(Config::get('global.tempDir'), 'dex_avatar_');
imagejpeg($canvas, $tmpFileName, AVATAR_QUALITY);
$f = new FtpUtil();
$f->staticServerPut($tmpFileName, $AVATAR_REMOTE_FILE);
unlink($rawFileName);
unlink($tmpFileName);
$user->hasAvatar = 1;
$user->save();
FlashMessage::add('Imaginea a fost salvată.', 'info');
util_redirect('preferinte');
/****************************************************************************/
/* Load an image by its (supported) type */
function loadImage($file)
{
$size = getimagesize($file);
switch ($size['mime']) {
case 'image/jpeg':
return imagecreatefromjpeg($file);
case 'image/gif':
return imagecreatefromgif($file);
case 'image/png':
return imagecreatefrompng($file);
default:
return null;
util_assertNotLoggedIn();
$token = util_getRequestParameter('token');
$identity = util_getRequestParameter('identity');
$pt = PasswordToken::get_by_token($token);
$data = FileCache::get($identity);
if (!$pt) {
FlashMessage::add('Ați introdus un cod de recuperare incorect.');
} else {
if ($pt->createDate < time() - 24 * 3600) {
FlashMessage::add('Codul de recuperare introdus a expirat.');
} else {
if (!$data) {
FlashMessage::add('Ați introdus o identitate incorectă.');
} else {
$user = User::get_by_id($pt->userId);
if (!$user) {
FlashMessage::add('Ați introdus un cod de recuperare incorect.');
} else {
if ($user->identity) {
FlashMessage::add('Acest cont a fost deja revendicat de o identitate OpenID.');
} else {
FlashMessage::add('Contul dumneavoastră a fost recuperat și unificat cu identitatea OpenID.', 'info');
session_login($user, $data);
}
}
}
}
}
SmartyWrap::assign('page_title', 'Recuperarea parolei');
SmartyWrap::assign('suggestHiddenSearchForm', true);
SmartyWrap::display('auth/passwordRecoveryWrongData.ihtml');
function validateDelete($mt)
{
$numLexems = Model::factory('LexemModel')->where('modelType', $mt->code)->count();
if ($numLexems) {
FlashMessage::add("Nu pot șterge tipul '{$mt->code}', deoarece este folosit de {$numLexems} lexeme.");
}
$numDependants = Model::factory('ModelType')->where('canonical', $mt->code)->count();
if ($numDependants > 1) {
FlashMessage::add("Nu pot șterge tipul '{$mt->code}', deoarece este canonic pentru alte tipuri.");
}
return FlashMessage::getMessage() == null;
}
<?php
require_once "../phplib/util.php";
ini_set('max_execution_time', '3600');
define('DB_QUERY', 'select * from Lexem where isLoc order by formNoAccent');
$locVersion = util_getRequestParameter('locVersion');
$newLocVersion = util_getRequestParameter('newLocVersion');
if ($newLocVersion) {
if ($locVersion == $newLocVersion) {
FlashMessage::add('Ați selectat aceeași versiune LOC de două ori');
util_redirect('scrabble-loc');
}
$file1 = tempnam('/tmp', 'loc_diff_');
$file2 = tempnam('/tmp', 'loc_diff_');
writeLexems($locVersion, $file1);
writeLexems($newLocVersion, $file2);
$diff = OS::executeAndReturnOutput("diff {$file1} {$file2} || true");
print "<pre>\n";
foreach ($diff as $line) {
if (StringUtil::startsWith($line, '< ')) {
print sprintf("<span style=\"color: red\">%s: %s</span>\n", $locVersion, substr($line, 2));
} else {
if (StringUtil::startsWith($line, '> ')) {
print sprintf("<span style=\"color: green\">%s: %s</span>\n", $newLocVersion, substr($line, 2));
}
}
}
print "</pre>\n";
util_deleteFile($file1);
util_deleteFile($file2);
exit;
function util_assertModerator($type)
{
if (!util_isModerator($type)) {
FlashMessage::add('Nu aveți privilegii suficiente pentru a accesa această pagină.');
util_redirect(util_getWwwRoot());
}
}
<?php
require_once "../phplib/util.php";
require_once "../phplib/userPreferences.php";
util_assertNotLoggedIn();
$sendButton = util_getRequestParameter('send');
if ($sendButton) {
$userPrefs = util_getRequestCheckboxArray('userPrefs', ',');
$skin = util_getRequestParameter('skin');
session_setAnonymousPrefs($userPrefs);
if (session_isValidSkin($skin)) {
session_setSkin($skin);
}
FlashMessage::add('Preferințele au fost salvate.', 'info');
util_redirect('preferinte');
} else {
$userPrefs = session_getAnonymousPrefs();
$skin = session_getSkin();
}
foreach (preg_split('/,/', $userPrefs) as $pref) {
if (isset($userPreferencesSet[$pref])) {
$userPreferencesSet[$pref]['checked'] = true;
}
}
smarty_assign('userPrefs', $userPreferencesSet);
smarty_assign('skin', $skin);
smarty_assign('availableSkins', pref_getServerPreference('skins'));
smarty_assign('page_title', 'Preferințe');
smarty_displayCommonPageWithSkin('preferinte.ihtml');
<?php
require_once "../phplib/util.php";
setlocale(LC_ALL, "ro_RO.utf8");
DebugInfo::disable();
$locVersion = util_getRequestParameter('locVersion');
$modelType = util_getRequestParameter('modelType');
$modelType = ModelType::get_by_code($modelType);
// Use the ModelType object from this point on
if (!$locVersion || !$modelType) {
FlashMessage::add('Date incorecte');
util_redirect('scrabble');
}
LocVersion::changeDatabase($locVersion);
$models = FlexModel::loadByType($modelType->code);
$lexemModels = array();
foreach ($models as $m) {
$lexemModels[] = getLexemModel($m->exponent, $modelType->code, $m->number);
}
SmartyWrap::addCss('paradigm');
SmartyWrap::assign('page_title', 'Modele de flexiune');
SmartyWrap::assign('models', $models);
SmartyWrap::assign('lexemModels', $lexemModels);
SmartyWrap::assign('locVersion', $locVersion);
SmartyWrap::assign('modelType', $modelType);
SmartyWrap::display('modele-flexiune.ihtml');
/*************************************************************************/
/**
* Returns a LexemModel for a given word and model. Creates one if one doesn't exist.
**/
function getLexemModel($form, $modelType, $modelNumber)
if ($value) {
$m = Model::factory('FlexModel')->where_raw("concat(modelType, number) = '{$value}'")->find_one();
if ($m) {
$oldModelType = $lm->modelType;
$oldModelNumber = $lm->modelNumber;
$lm->modelType = $m->modelType;
$lm->modelNumber = $m->number;
$ifs = $lm->generateInflectedForms();
if (!is_array($ifs)) {
FlashMessage::add("Lexemul '{$l->formNoAccent}' nu poate fi flexionat cu modelul '{$value}'");
$errorMap[$l->id] = true;
$lm->modelType = $oldModelType;
$lm->modelNumber = $oldModelNumber;
}
} else {
FlashMessage::add("Modelul '{$value}' nu există pentru lexemul '{$l->formNoAccent}'.");
$errorMap[$l->id] = true;
}
}
break;
case 'verifSp':
$l->verifSp = 1;
break;
case 'comment':
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;
$detailsVisible = util_getRequestParameter('detailsVisible');
$userPrefs = util_getRequestCheckboxArray('userPrefs', ',');
$skin = util_getRequestParameter('skin');
$user = session_getUser();
if (!$user) {
util_redirect('auth/login');
}
if ($sendButton) {
$user->detailsVisible = $detailsVisible ? 1 : 0;
$user->preferences = $userPrefs;
if (session_isValidSkin($skin)) {
$user->skin = $skin;
}
$user->save();
session_setVariable('user', $user);
FlashMessage::add('Informațiile au fost salvate.', 'info');
} else {
$detailsVisible = $user->detailsVisible;
$skin = session_getSkin();
$userPrefs = $user->preferences;
}
foreach (preg_split('/,/', $userPrefs) as $pref) {
if (isset($userPreferencesSet[$pref])) {
$userPreferencesSet[$pref]['checked'] = true;
}
}
smarty_assign('detailsVisible', $detailsVisible);
smarty_assign('userPrefs', $userPreferencesSet);
smarty_assign('skin', $skin);
smarty_assign('availableSkins', pref_getServerPreference('skins'));
smarty_assign('privilegeNames', $PRIV_NAMES);
require_once "../phplib/util.php";
// Parse or initialize the GET/POST arguments
$nick = util_getRequestParameter('n');
$medalSaveButton = util_getRequestParameter('medalSaveButton');
$userId = util_getRequestParameter('userId');
$medalsGranted = util_getRequestParameter('medalsGranted');
if ($medalSaveButton) {
util_assertModerator(PRIV_ADMIN);
$user = User::get_by_id($userId);
$user->medalMask = Medal::getCanonicalMask(array_sum($medalsGranted));
$user->save();
util_redirect(util_getWwwRoot() . "utilizator/{$user->nick}");
}
$user = User::get_by_nick($nick);
if (!$user) {
FlashMessage::add('Utilizatorul ' . htmlspecialchars($nick) . ' nu există.');
util_redirect(util_getWwwRoot());
}
$userData = array();
$user->email = StringUtil::scrambleEmail($user->email);
// Find the rank of this user by number of words and number of characters
$topWords = TopEntry::getTopData(CRIT_WORDS, SORT_DESC, true);
$numUsers = count($topWords);
$rankWords = 0;
while ($rankWords < $numUsers && $topWords[$rankWords]->userNick != $nick) {
$rankWords++;
}
$userData['rank_words'] = $rankWords + 1;
if ($rankWords < $numUsers) {
$topEntry = $topWords[$rankWords];
$userData['last_submission'] = $topEntry->timestamp;
require_once "../../phplib/util.php";
util_assertModerator(PRIV_WOTD);
util_assertNotMirror();
$IGNORED_DIRS = array('.', '..');
$EXTENSIONS = array('gif', 'jpeg', 'jpg', 'png');
if (array_key_exists('file', $_FILES)) {
$rec = $_FILES['file'];
if ($rec['error'] > 0) {
FlashMessage::add('Eroare ' . $rec['error'] . ' la încărcarea fișierului.');
} else {
if ($rec['size'] > 100000000) {
FlashMessage::add('Dimensiunea maximă admisă este de 100 MB.');
} else {
if ($rec['type'] != 'application/zip') {
FlashMessage::add('Sunt permise numai fișiere .zip.');
} else {
// Create a working dir
$workDir = tempnam(Config::get('global.tempDir'), 'compress_');
@unlink($workDir);
mkdir($workDir);
chdir($workDir);
// Move the file there and decompress it
move_uploaded_file($rec['tmp_name'], "{$workDir}/uncompressed.zip");
OS::executeAndAssert("unzip {$workDir}/uncompressed.zip");
@unlink("{$workDir}/uncompressed.zip");
// Compress all the images inside it
$logFile = fopen("{$workDir}/raport.txt", 'a');
$beforeBytes = 0;
$afterBytes = 0;
recursiveScan($workDir, $logFile);
<?php
require_once "../phplib/util.php";
$submitButton = util_getRequestParameter('submitButton');
if ($submitButton) {
util_assertModerator(PRIV_ADMIN);
$order = 1;
$ids = util_getRequestParameter("ids");
foreach ($ids as $id) {
$src = Source::get_by_id($id);
$src->displayOrder = $order++;
$src->save();
}
FlashMessage::add('Ordinea a fost salvată.', 'info');
util_redirect('surse');
}
$sources = util_isModerator(PRIV_VIEW_HIDDEN) ? Model::factory('Source')->order_by_asc('displayOrder')->find_many() : Model::factory('Source')->where_not_equal('isOfficial', SOURCE_TYPE_HIDDEN)->order_by_asc('displayOrder')->find_many();
smarty_assign('sources', $sources);
smarty_assign('page_title', 'Surse');
smarty_displayCommonPageWithSkin('surse.ihtml');
$deleteId = util_getRequestParameter('deleteId');
$submitButton = util_getRequestParameter('submitButton');
if ($deleteId) {
$mt = MeaningTag::get_by_id($deleteId);
$mtms = MeaningTagMap::get_all_by_meaningTagId($mt->id);
if (count($mtms)) {
FlashMessage::add("Nu pot șterge eticheta «{$mt->value}», deoarece unele sensuri o folosesc.", 'error');
} else {
$mt->delete();
FlashMessage::add("Am șters eticheta «{$mt->value}».", 'info');
}
util_redirect('etichete-sensuri');
}
if ($submitButton) {
util_assertModerator(PRIV_ADMIN);
$values = explode(',', $value);
foreach ($values as $value) {
$value = trim($value);
if ($value && !MeaningTag::get_by_value($value)) {
$mt = Model::factory('MeaningTag')->create();
$mt->value = $value;
$mt->save();
}
}
FlashMessage::add('Etichetele au fost salvate.', 'info');
util_redirect('etichete-sensuri');
}
$meaningTags = Model::factory('MeaningTag')->order_by_asc('value')->find_many();
SmartyWrap::assign('meaningTags', $meaningTags);
SmartyWrap::assign('page_title', 'Etichete pentru sensuri');
SmartyWrap::display('etichete-sensuri.ihtml');
require_once "../../phplib/util.php";
util_assertModerator(PRIV_ADMIN);
util_assertNotMirror();
$MAX_AFFECTED = 1000;
$search = util_getRequestParameter('search');
$replace = util_getRequestParameter('replace');
$sourceId = util_getRequestParameter('source');
$realRun = util_getRequestParameter('realRun');
$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 (!($definition = Definition::get_by_id($definitionId))) {
return;
}
$comment = Model::factory('Comment')->where('definitionId', $definitionId)->where('status', Definition::ST_ACTIVE)->find_one();
$commentUser = $comment ? User::get_by_id($comment->userId) : null;
$oldInternalRep = $definition->internalRep;
if ($internalRep) {
$errors = array();
$definition->internalRep = AdminStringUtil::internalizeDefinition($internalRep, $sourceId);
$definition->htmlRep = AdminStringUtil::htmlize($definition->internalRep, $sourceId, $errors);
if (!empty($errors)) {
$hasErrors = true;
foreach ($errors as $error) {
FlashMessage::add($error);
}
}
}
if (isset($status)) {
$definition->status = (int) $status;
}
if ($sourceId) {
$definition->sourceId = (int) $sourceId;
}
//ugly workaround - TBD a better solution
if ($_POST) {
if ($similarSource) {
$definition->similarSource = 1;
} else {
$definition->similarSource = 0;
