/** * 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;