public static function getUsersRankedByBest()
{
$c = new Criteria();
$c->addDescendingOrderByColumn(UserPeer::WINS);
$c->addDescendingOrderByColumn(UserPeer::KILLS);
return self::doSelect($c);
}
public function execute($request)
{
if (!$this->context->user->hasCredential(array('contributor', 'editor', 'administrator'), false)) {
QubitAcl::forwardUnauthorized();
}
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
switch ($request->sort) {
case 'nameDown':
$criteria->addDescendingOrderByColumn('identifier');
break;
case 'nameUp':
$criteria->addAscendingOrderByColumn('identifier');
break;
case 'updatedDown':
$criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
break;
case 'updatedUp':
$criteria->addAscendingOrderByColumn(QubitObject::UPDATED_AT);
break;
default:
if (!$this->getUser()->isAuthenticated()) {
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
} else {
$criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
}
}
// Page results
$this->pager = new QubitPager('QubitAccession');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
}
public function executeList()
{
$title = "Most recent bug reports and feature suggestions";
$tab = str_replace(' ', '', $this->getRequestParameter('tab', 'mostrecent'));
$c = new Criteria();
if ($tab == 'mostrecent') {
$c->addDescendingOrderByColumn(SuggestedFeaturePeer::CREATED_AT);
} elseif ($tab == 'mostpopular') {
$c2 = new Criteria();
$c2->add(sfRecommendationPeer::RECOMMENDABLE_MODEL, 'SuggestedFeature');
$c2->addDescendingOrderByColumn(sfRecommendationPeer::SCORE);
$recommendations = sfRecommendationPeer::doSelect($c2);
// this loop has got to be SUPER intensive, it has to change soon
$features = array();
foreach ($recommendations as $recommended) {
$features[] = SuggestedFeaturePeer::retrieveByPK($recommended->getRecommendableId());
}
$title = "Most popular bug reports and feature suggestions";
} elseif ($tab == 'bugs') {
$c->add(SuggestedFeaturePeer::TYPE, sfConfig::get('app_feature_type_bug'));
$c->addDescendingOrderByColumn(SuggestedFeaturePeer::CREATED_AT);
$title = 'Bug Reports';
} elseif ($tab == 'features') {
$c->add(SuggestedFeaturePeer::TYPE, sfConfig::get('app_feature_type_feature'));
$c->addDescendingOrderByColumn(SuggestedFeaturePeer::CREATED_AT);
$title = 'Feature Suggestions';
}
//This only works while it's not a pager, not a long term solution!
if (!isset($features)) {
$this->features = SuggestedFeaturePeer::doSelect($c);
} else {
$this->features = $features;
}
myToolkit::prependPageTitle($title);
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
switch ($request->sort) {
case 'nameDown':
$criteria->addDescendingOrderByColumn('authorized_form_of_name');
break;
case 'nameUp':
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
break;
case 'updatedDown':
$criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
break;
case 'updatedUp':
$criteria->addAscendingOrderByColumn(QubitObject::UPDATED_AT);
break;
default:
if (!$this->getUser()->isAuthenticated()) {
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
} else {
$criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
}
}
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, 'QubitFunction');
// Page results
$this->pager = new QubitPager('QubitFunction');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
}
public function execute($request)
{
if (!isset($request->limit)) {
$request->limit = sfConfig::get('app_hits_per_page');
}
$criteria = new Criteria();
if (isset($this->getRoute()->resource)) {
$this->resource = $this->getRoute()->resource;
$criteria->add(QubitInformationObject::PARENT_ID, $this->resource->id);
} else {
$criteria->add(QubitInformationObject::PARENT_ID, QubitInformationObject::ROOT_ID);
}
if (isset($request->repositoryId)) {
$criteria->add(QubitInformationObject::REPOSITORY_ID, $request->repositoryId);
}
if (isset($request->collectionType)) {
$criteria->add(QubitInformationObject::COLLECTION_TYPE_ID, $request->collectionType);
}
$fallbackTable = 'QubitInformationObject';
switch ($request->sort) {
case 'repositoryDown':
$fallbackTable = 'QubitActor';
$criteria->addJoin(QubitInformationObject::REPOSITORY_ID, QubitActor::ID, Criteria::LEFT_JOIN);
$criteria->addDescendingOrderByColumn('authorized_form_of_name');
break;
case 'repositoryUp':
$fallbackTable = 'QubitActor';
$criteria->addJoin(QubitInformationObject::REPOSITORY_ID, QubitActor::ID, Criteria::LEFT_JOIN);
$criteria->addAscendingOrderByColumn('authorized_form_of_name');
break;
case 'titleDown':
$criteria->addDescendingOrderByColumn('title');
break;
case 'titleUp':
$criteria->addAscendingOrderByColumn('title');
break;
case 'updatedDown':
$criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
break;
case 'updatedUp':
$criteria->addAscendingOrderByColumn(QubitObject::UPDATED_AT);
break;
default:
if (!$this->getUser()->isAuthenticated()) {
$criteria->addAscendingOrderByColumn('title');
} else {
$criteria->addDescendingOrderByColumn(QubitObject::UPDATED_AT);
}
}
// Do source culture fallback
$criteria = QubitCultureFallback::addFallbackCriteria($criteria, $fallbackTable);
// Filter drafts
$criteria = QubitAcl::addFilterDraftsCriteria($criteria);
// Page results
$this->pager = new QubitPager('QubitInformationObject');
$this->pager->setCriteria($criteria);
$this->pager->setMaxPerPage($request->limit);
$this->pager->setPage($request->page);
}
/**
* retrieve the last record of the emendamento_has_iter table
* for the given emendamento
*
* @return OppEmIter object
* @author Guglielmo Celata
*/
public function getLastStatus()
{
$c = new Criteria();
$c->add(OppEmendamentoHasIterPeer::EMENDAMENTO_ID, $this->getId());
$c->addJoin(OppEmendamentoHasIterPeer::EM_ITER_ID, OppEmIterPeer::ID);
$c->addDescendingOrderByColumn(OppEmendamentoHasIterPeer::DATA);
$c->addDescendingOrderByColumn(OppEmendamentoHasIterPeer::CREATED_AT);
return OppEmendamentoHasIterPeer::doSelectOne($c);
}
public function getTemplateMatches()
{
$c = new Criteria();
$c->add(AutodiscoveryDeviceTemplateMatchPeer::DEVICE_ID, $this->getId());
$c->addDescendingOrderByColumn(AutodiscoveryDeviceTemplateMatchPeer::PERCENT);
$c->addDescendingOrderByColumn(AutodiscoveryDeviceTemplateMatchPeer::COMPLEXITY);
$matches = AutodiscoveryDeviceTemplateMatchPeer::doSelect($c);
return $matches;
}
public function getSubscriptions($criteria = null, PropelPDO $con = null)
{
if (is_null($criteria)) {
$criteria = new Criteria();
}
$criteria->addDescendingOrderByColumn(SubscriptionPeer::STOP);
$criteria->addDescendingOrderByColumn(SubscriptionPeer::START);
return parent::getSubscriptions($criteria, $con);
}
protected function doSort()
{
if ($this->sortColumn) {
$this->criteria->clearOrderByColumns();
if ($this->sortDir === 'DESC') {
$this->criteria->addDescendingOrderByColumn($this->sortColumn);
} else {
$this->criteria->addAscendingOrderByColumn($this->sortColumn);
}
}
}
/**
* @return BulkUploadResult
*/
public static function retrieveLastByBulkUploadId($bulkUploadId)
{
$criteria = new Criteria();
$criteria->add(BulkUploadResultPeer::BULK_UPLOAD_JOB_ID, $bulkUploadId);
$criteria->addDescendingOrderByColumn(BulkUploadResultPeer::LINE_INDEX);
return self::doSelectOne($criteria);
}
public static function getByPersonId($person_id)
{
$c = new Criteria();
$c->add(self::PERSON_ID, $person_id);
$c->addDescendingOrderByColumn(self::TITLE);
return self::doSelectOne($c);
}
function getCalendarBusinessHours($CalendarUid)
{
$Criteria = new Criteria('workflow');
$Criteria->clearSelectColumns();
$Criteria->addSelectColumn(CalendarBusinessHoursPeer::CALENDAR_UID);
$Criteria->addSelectColumn(CalendarBusinessHoursPeer::CALENDAR_BUSINESS_DAY);
$Criteria->addSelectColumn(CalendarBusinessHoursPeer::CALENDAR_BUSINESS_START);
$Criteria->addSelectColumn(CalendarBusinessHoursPeer::CALENDAR_BUSINESS_END);
$Criteria->add(CalendarBusinessHoursPeer::CALENDAR_UID, $CalendarUid, CRITERIA::EQUAL);
$Criteria->addDescendingOrderByColumn(CalendarBusinessHoursPeer::CALENDAR_BUSINESS_DAY);
$Criteria->addAscendingOrderByColumn(CalendarBusinessHoursPeer::CALENDAR_BUSINESS_START);
//$Criteria->addDescendingOrderByColumn ( CalendarBusinessHoursPeer::CALENDAR_BUSINESS_START );
$rs = CalendarBusinessHoursPeer::doSelectRS($Criteria);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rs->next();
$row = $rs->getRow();
$fields = array();
$count = 0;
while (is_array($row)) {
$count++;
$fields[$count] = $row;
$rs->next();
$row = $rs->getRow();
}
return $fields;
}
public function applyFilter(Criteria $criteria_to_filter)
{
if (!$this->enable) {
return;
}
if (!isset($criteria_to_filter->creteria_filter_attached)) {
$criteria_to_filter->creteria_filter_attached = true;
// copy all constraints from the criteria to $criteria_to_filter
$columns = $this->criteria->keys();
foreach ($columns as $column) {
$filter_criterion = $this->criteria->getCriterion($column);
$new_crit = $criteria_to_filter->getNewCriterion($filter_criterion->getTable() . "." . $filter_criterion->getColumn(), $filter_criterion->getValue(), $filter_criterion->getComparison());
$existing_criterion = $criteria_to_filter->getCriterion($column);
// don't add duplicates !!
if ($existing_criterion && ($existing_criterion->getValue() == $filter_criterion->getValue() && $existing_criterion->getComparison() == $filter_criterion->getComparison())) {
continue;
}
// go one step deeper to copy the inner clauses
$this->addClauses($this->criteria, $filter_criterion, $new_crit);
$criteria_to_filter->addAnd($new_crit);
}
// TODO - adda more robust way to copy the orderBy from this->criteria
$orderBy = $this->criteria->getOrderByColumns();
if ($orderBy) {
foreach ($orderBy as $orderByColumn) {
@(list($name, $order) = explode(" ", $orderByColumn));
if ($order == Criteria::ASC) {
$criteria_to_filter->addAscendingOrderByColumn($name);
} else {
$criteria_to_filter->addDescendingOrderByColumn($name);
}
}
}
}
}
public static function addOrderByPreorder(Criteria $criteria, $order = Criteria::ASC)
{
if ($order == Criteria::DESC) {
return $criteria->addDescendingOrderByColumn(QubitPhysicalObject::LFT);
}
return $criteria->addAscendingOrderByColumn(QubitPhysicalObject::LFT);
}
public function executeIndex()
{
//perlu di rapihkan
$field_name = $this->name;
$reflection = new ReflectionClass($this->model . 'Peer');
$method = $reflection->getMethod('doSelect');
$c = new Criteria();
$filter_field = strtoupper($this->filter_field);
$filter_content = $this->filter_content;
if (!empty($filter_field)) {
if ($this->case == 'equal') {
$c->add($reflection->getConstant($filter_field), $filter_content, Criteria::EQUAL);
} else {
if ($this->case == 'not_equal') {
$c->add($reflection->getConstant($filter_field), $filter_content, Criteria::NOT_EQUAL);
}
}
}
$order_column = $this->order_column;
$order_type = $this->order_type;
if (!empty($order_column)) {
if ($order_type == 'desc') {
$c->addDescendingOrderByColumn($order_column);
} else {
$c->addAscendingOrderByColumn($order_column);
}
}
$reg_info = $method->invoke($method, $c);
$this->data = $reg_info;
$this->name = $field_name;
$this->desc = !isset($this->desc) ? 'Name' : $this->desc;
}
public function executePropertylist()
{
$c = new Criteria();
$c->add(ConceptPropertyPeer::CONCEPT_ID, $this->conceptId);
$c->addDescendingOrderByColumn(ConceptPropertyPeer::SKOS_PROPERTY_ID);
$this->properties = ConceptPropertyPeer::doSelect($c);
}
public static function getNewslettersWithSentInfo($iLimit = 10)
{
$oCriteria = new Criteria();
$oCriteria->addDescendingOrderByColumn(self::CREATED_AT);
$oCriteria->addAscendingOrderByColumn(self::SUBJECT);
$oCriteria->addJoin(self::ID, NewsletterMailingPeer::NEWSLETTER_ID, Criteria::LEFT_JOIN);
$oCriteria->setLimit($iLimit);
$aResult = array();
foreach (self::doSelect($oCriteria) as $oNewsletter) {
$oNewsletterName = '[' . $oNewsletter->getCreatedAt('Y-m-d') . '] ' . $oNewsletter->getSubject();
$aSentFirstletters = array();
if ($oNewsletter->hasNewsletterMailings()) {
foreach ($oNewsletter->getNewsletterMailings() as $oNewsletterMailing) {
if ($oNewsletterMailing->getSubscriberGroup()) {
$aSentFirstletters[] = $oNewsletterMailing->getSubscriberGroup()->getNameFirstLetter();
} elseif ($oNewsletterMailing->getExternalMailGroupId()) {
$aSentFirstletters[] = 'Ext';
}
}
if (count($aSentFirstletters) > 0) {
$oNewsletterName .= ' [' . TranslationPeer::getString('newsletter_mailing.sent_info') . ' ' . implode(', ', $aSentFirstletters) . ']';
}
}
$aResult[$oNewsletter->getId()] = $oNewsletterName;
}
return $aResult;
}
public function getConfigFieldCategoryValue($configFieldCategory)
{
$resultStr = '';
$cFields = new Criteria();
$cFields->add(ConfigFieldPeer::CATEGORY_ID, $configFieldCategory->getId());
$cFields->addDescendingOrderByColumn(ConfigFieldPeer::WEIGTH);
$fields = ConfigFieldPeer::doSelect($cFields);
//make fields id array
$fieldsIdArr = array();
foreach ($fields as $field) {
$fieldsIdArr[] = $field->getId();
}
//print_r($fields);
//exit();
//
$cValue = new Criteria();
$cValue->add(FieldValuePeer::FIELD_ID, $fieldsIdArr, Criteria::IN);
$cValue->add(FieldValuePeer::CONFIG_ID, $this->getId());
$fieldValues = FieldValuePeer::doSelect($cValue);
foreach ($fieldValues as $fieldValue) {
if (strlen($fieldValue->getValue()) > 0) {
$resultStr .= $fieldValue->getValue() . $fieldValue->getHtmlComment() . '-';
}
}
return $resultStr;
}
public static function getProblematicUsers()
{
$c = new Criteria();
$c->add(self::DELETIONS, 0, Criteria::GREATER_THAN);
$c->addDescendingOrderByColumn(self::DELETIONS);
return self::doSelect($c);
}
/**
* Executes sessions action
*
*/
public function executeSessions()
{
if (!empty($_COOKIE["timer"])) {
$this->redirect('/dashboard/rating');
}
$name = explode("/", $_SERVER['REQUEST_URI']);
$query = mysql_query("select * from user where username='******' ") or die(mysql_error());
$row = mysql_fetch_array($query);
$userId = $row['id'];
$this->userName = $row['name'];
$loginUserId = $this->getUser()->getRaykuUserId();
// query
$criteria = new Criteria();
// sub query A: (is_public and (asker = user or expert = user))
$cPublicA = $criteria->getNewCriterion(WhiteboardChatPeer::IS_PUBLIC, true);
$cPublicA1 = $criteria->getNewCriterion(WhiteboardChatPeer::ASKER_ID, $userId);
$cPublicA2 = $criteria->getNewCriterion(WhiteboardChatPeer::EXPERT_ID, $userId);
$cPublicA1->addOr($cPublicA2);
$cPublicA->addAnd($cPublicA1);
// sub query B: (is_private and (asker = login_user or expert = login_user))
$cPublicB = $criteria->getNewCriterion(WhiteboardChatPeer::IS_PUBLIC, false);
$cPublicB1 = $criteria->getNewCriterion(WhiteboardChatPeer::ASKER_ID, $loginUserId);
$cPublicB2 = $criteria->getNewCriterion(WhiteboardChatPeer::EXPERT_ID, $loginUserId);
$cPublicB1->addOr($cPublicB2);
$cPublicB->addAnd($cPublicB1);
// (sub query A OR sub query B)
$cPublicA->addOr($cPublicB);
$criteria->add($cPublicA);
$criteria->add(WhiteboardChatPeer::STARTED_AT, null, Criteria::ISNOTNULL);
$criteria->addDescendingOrderByColumn(WhiteboardChatPeer::ID);
$this->chat_list = WhiteboardChatPeer::doSelect($criteria);
}
/**
*
* @return array of PcContactNote
*/
public function getNotes()
{
$c = new Criteria();
$c->add(PcContactNotePeer::CONTACT_ID, $this->getId());
$c->addDescendingOrderByColumn(PcContactNotePeer::CREATED_AT);
return PcContactNotePeer::doSelect($c);
}
public function getLatestPostByQuery()
{
$c = new Criteria();
$c->add(sfSimpleForumPostPeer::FORUM_ID, $this->getId());
$c->addDescendingOrderByColumn(sfSimpleForumPostPeer::CREATED_AT);
return sfSimpleForumPostPeer::doSelectOne($c);
}
public function executeIndex(sfWebRequest $request)
{
//get request parameters
$this->selectedBrand = $this->getRequestParameter('brand');
$this->selectedSeries = $this->getRequestParameter('series');
$this->selectedModel = $this->getRequestParameter('model');
$cConfig = new Criteria();
$cConfig->addJoin(ConfigPeer::MODEL_ID, ModelPeer::ID);
$cConfig->addJoin(ModelPeer::SERIES_ID, SeriesPeer::ID);
$cConfig->addJoin(SeriesPeer::BRAND_ID, BrandPeer::ID);
if ($this->selectedBrand) {
$cConfig->add(BrandPeer::ID, $this->selectedBrand);
}
if ($this->selectedSeries) {
$cConfig->add(SeriesPeer::SERIES_NAME, $this->selectedSeries, Criteria::LIKE);
}
if ($this->selectedModel) {
$cConfig->add(ModelPeer::MODEL_NAME, $this->selectedModel, Criteria::LIKE);
}
//$this->Configs = ConfigPeer::doSelect($cConfig);
//paginatiom
$pager = new sfPropelPager('Config', 15);
$pager->setCriteria($cConfig);
$pager->setPage($this->getRequestParameter('page'));
$pager->init();
$this->pager = $pager;
//get config columns
$c = new Criteria();
$c->addDescendingOrderByColumn(ConfigFieldCategoryPeer::WEIGHT);
$this->configFieldCategories = ConfigFieldCategoryPeer::doSelect($c);
//get brands
$cBrand = new Criteria();
$this->brands = BrandPeer::doSelect($cBrand);
}
public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser)
{
$limit = $this->getP("page_size", 20);
$limit = min($limit, 100);
$page = $this->getP("page", 1);
$offset = ($page - 1) * $limit;
$c = new Criteria();
$c->addAnd(BatchJobPeer::PARTNER_ID, $partner_id);
$c->addAnd(BatchJobPeer::JOB_TYPE, BatchJobType::BULKUPLOAD);
$c->addDescendingOrderByColumn(BatchJobPeer::ID);
$count = BatchJobPeer::doCount($c);
$c->setLimit($limit);
$c->setOffset($offset);
$jobs = BatchJobPeer::doSelect($c);
$obj = array();
foreach ($jobs as $job) {
$jobData = $job->getData();
if (!$jobData instanceof kBulkUploadJobData) {
continue;
}
$bulkResults = BulkUploadResultPeer::retrieveWithEntryByBulkUploadId($job->getId());
$obj[] = array("uploadedBy" => $jobData->getUploadedBy(), "uploadedOn" => $job->getCreatedAt(null), "numOfEntries" => count($bulkResults), "status" => $job->getStatus(), "error" => $job->getStatus() == BatchJob::BATCHJOB_STATUS_FAILED ? $job->getMessage() : '', "logFileUrl" => requestUtils::getCdnHost() . "/index.php/extwidget/bulkuploadfile/id/{$job->getId()}/pid/{$job->getPartnerId()}/type/log", "csvFileUrl" => requestUtils::getCdnHost() . "/index.php/extwidget/bulkuploadfile/id/{$job->getId()}/pid/{$job->getPartnerId()}/type/csv");
}
$this->addMsg("count", $count);
$this->addMsg("page_size", $limit);
$this->addMsg("page", $page);
$this->addMsg("bulk_uploads", $obj);
}
public static function getAllOrderedByStartDate()
{
$c = new Criteria();
$c->addAscendingOrderByColumn(self::START_DATE);
$c->addDescendingOrderByColumn(self::ALL_DAY);
return self::doSelect($c);
}
public function reorderParametrosByColumn($column = ParametroPeer::NOMBRE, $type = "asc")
{
$c = new Criteria();
if ($type == "asc") {
$c->addAscendingOrderByColumn($column);
} else {
$c->addDescendingOrderByColumn($column);
}
$parametros = $this->getParametros($c);
try {
$con = Propel::getConnection(ParametroPeer::DATABASE_NAME);
$con->beginTransaction();
$orden = 1;
foreach ($parametros as $parametro) {
$parametro->setOrden($orden);
$parametro->save($con);
$orden++;
}
$con->commit();
} catch (Exception $e) {
$con->rollBack();
throw $e;
}
return true;
}
public static function getForUserCriteria($user_id)
{
$c = new Criteria();
$c->add(self::USER_ID, $user_id);
$c->addDescendingOrderByColumn(self::UPDATED_AT);
return $c;
}
public static function getWidgetOrderedPager($order, $pageSize, $page, $criteria = null)
{
$c = $criteria;
if ($c == null) {
$c = new Criteria();
}
if ($order) {
$order_dir = 1;
if ($order[0] == '+' || $order[0] == '-') {
$order_dir = $order[0] == '+' ? $order_dir = 1 : ($order_dir = -1);
$order = substr($order, 1);
}
$fixed_order = "widget_log." . strtoupper($order);
$should_sort = in_array($fixed_order, array(WidgetLogPeer::ID, WidgetLogPeer::KSHOW_ID, WidgetLogPeer::ENTRY_ID, WidgetLogPeer::REFERER, WidgetLogPeer::VIEWS, WidgetLogPeer::PLAYS, WidgetLogPeer::IP1_COUNT, WidgetLogPeer::CREATED_AT));
if ($should_sort) {
if ($order_dir == 1) {
$c->addAscendingOrderByColumn($fixed_order);
} else {
$c->addDescendingOrderByColumn($fixed_order);
}
}
}
$pager = new sfPropelPager('WidgetLog', $pageSize);
$pager->setPeerMethod("doSelectJoinentry");
$pager->setPeerCountMethod("doCountJoinentry");
$pager->setCriteria($c);
$pager->setPage($page);
$pager->init();
return $pager;
}
public function execute()
{
$this->forceSystemAuthentication();
myDbHelper::$use_alternative_con = null;
$partnerId = $this->getRequestParameter("partnerId", null);
$uiConfId = $this->getRequestParameter("uiConfId", null);
$page = $this->getRequestParameter("page", 1);
if ($partnerId !== null && $partnerId !== "") {
$pageSize = 50;
$c = new Criteria();
$c->add(widgetPeer::PARTNER_ID, $partnerId);
if ($uiConfId) {
$c->add(widgetPeer::UI_CONF_ID, $uiConfId);
}
$c->addDescendingOrderByColumn(widgetPeer::CREATED_AT);
$total = widgetPeer::doCount($c);
$lastPage = ceil($total / $pageSize);
$c->setOffset(($page - 1) * $pageSize);
$c->setLimit($pageSize);
$widgets = widgetPeer::doSelect($c);
} else {
$total = 0;
$lastPage = 0;
$widgets = array();
}
$this->uiConfId = $uiConfId;
$this->page = $page;
$this->lastPage = $lastPage;
$this->widgets = $widgets;
$this->partner = PartnerPeer::retrieveByPK($partnerId);
$this->partnerId = $partnerId;
}
/**
* fetch the best conversion profile for the partner - depending on the data in the DB only (no hint from the user)
*/
public static function retrieveByPartner($partner_id)
{
$c = new Criteria();
$c->addDescendingOrderByColumn(self::UPDATED_AT);
// make sure the first profile is the most updated
// $c->addAnd ( self::PROFILE_TYPE, $profile_type);
if ($partner_id) {
$crit = $c->getNewCriterion(self::PARTNER_ID, ConversionProfile::GLOBAL_PARTNER_PROFILE, Criteria::EQUAL);
$crit->addOr($c->getNewCriterion(self::PARTNER_ID, $partner_id, Criteria::EQUAL));
$c->add($crit);
} else {
$c->add(self::PARTNER_ID, $partner_id, Criteria::EQUAL);
}
$conv_list = self::doSelect($c);
if ($conv_list == null) {
return null;
}
foreach ($conv_list as $conv) {
// select the first conversion profile that matchs the partner
if ($conv->getPartnerId() == $partner_id) {
return $conv;
}
}
// if no conv_prof found for partner - use the global ones
return $conv_list[0];
// first profile returned
}
