ipfunctioncollection.php

Aller à la documentation de ce fichier.

<?php
class iPFunctionCollection
{

  function fetchHasAcceptedGTU( $user_id ) {

      $user = $user_id ? eZUser::fetch($user_id) : eZUser::currentUser();

      if (!$user) {

          throw new Exception(
             'ipediatreFunctionCollection::fetchHasAcceptedGTU()'
             .'n\'arrive pas à récupérer l\'utilisateur'
          );
      }

      $user = new iPUser($user);
      
      if ($ok = $user->hasAcceptedGTU()) {

          eZDebug::writeDebug("L'utilisateur `{$user->id()}` a déjà accepté les CGU");

      } else {

          eZDebug::writeDebug("L'utilisateur `{$user->id()}` n'a pas encore accepté les CGU");
      }

      return array('result'=>$ok);
  }

  function fetchCategories() {

    $countryCode  = eZLocale::instance()->countryCode(); // ex: FR, GB, MX, ...

    $categories = eZContentObjectTreeNode::fetchByURLPath($countryCode)
                  ->subTree(
        array(
            'ClassFilterType'=>'include',
            'ClassFilterArray'=>array('folder'),
            'SortBy'=> array(array('priority',true))
        )
    );

    return array('result' => $categories);
  }

  function fetchFolders( $user_id )
  {
    $user       = eZUser::fetch($user_id);
    $folder_ids = array();
    $folders    = array();

    if ( $user === null )
    {
        $result = array( 'error' => array( 'error_type' => 'kernel',
                                           'error_code' => eZError::KERNEL_NOT_FOUND ) );
    }
    else
    {
        // on récupère les articles sous le noeud de l'utilisateur
        $articles   = $user->contentObject()->mainNode()->children();
        $folder_ids = array_map(function($n){return $n->object()->mainParentNodeID();}, $articles);
        $folder_ids = array_unique($folder_ids);
        $folders    = array_map(array('eZContentObjectTreeNode', 'fetch'), $folder_ids);
        $result     = array( 'result' => $folders );
    }

    return $result;
  }

  function fetchArticles($user_id, $category, $age, $offset, $limit)
  {
    $articles = eZUser::fetch($user_id)->contentObject()
                                       ->mainNode()
                                       ->subTree(array( 'MainNodeOnly'     => false,
                                                        'ClassFilterType'  => 'include',
                                                        'ClassFilterArray' => array('article'),
                                                        'SortBy'           => array(array('priority',true))));

    if ($category) {
      $articles = array_filter($articles,
                               function($n1) use($category){
                                    $count = count(array_filter($n1->object()->assignedNodes(),
                                                             function($n2) use($category){
                                                                 return ($n2->attribute('parent_node_id')==$category);
                                                             }));
                                    return $count > 0;
                               });
    }

    if ($age) {
      $articles = array_filter($articles, function($n) use($age) {
                                            $dm = $n->dataMap();
                                            return in_array($age, explode(';',$dm['age_slot2']->DataText));
                                          });
    }

    if ($limit) {
        $articles = array_slice($articles, $offset, $limit);
    }
    return array( 'result' => $articles );
  }

  function fetchIsArticleFrom($object_id, $user_id)
  {
    $object = eZContentObject::fetch($object_id);
    $user   = eZUser::fetch($user_id);


    return array('result' => $object->mainParentNodeID() == $user->contentObject()->mainNodeID());
  }


  function fetchMyArticles($user_id)
  {
    $articles = eZUser::fetch($user_id)->contentObject()
                                       ->mainNode()
                                       ->subTree(array( 'MainNodeOnly'     => true,
                                                        'Depth'            => 1,
                                                        'DepthOperator'    => 'eq',
                                                        'IgnoreVisibility' => true,
                                                        'ClassFilterType'  => 'include',
                                                        'ClassFilterArray' => array('article'),
                                                        'SortBy'           => array(array('published',true))));

    foreach ($articles as $article)
    {
      foreach ($article->object()->assignedNodes() as $node)
      {
        if ($node->fetchParent()->classIdentifier() == 'folder') {
          $article_list[$node->attribute('parent_node_id')][] = $article;
          break;
        }
      }
    }

    uksort($article_list, function($group1, $group2){return eZContentObjectTreeNode::fetch($group1)->attribute('priority') - eZContentObjectTreeNode::fetch($group2)->attribute('priority');});


    if ( $article_list=== null )
    {
        $result = array( 'error' => array( 'error_type' => 'kernel',
                                           'error_code' => eZError::KERNEL_NOT_FOUND ) );
    }
    else
    {
        $result = array( 'result' => $article_list );
    }
    return $result;
  }

  function fetchPublishedArticles($user_id)
  {
    $parentNodeID = eZContentObject::fetch($user_id)->mainNodeID();
    $countryCode  = eZLocale::instance()->countryCode();
    $contentRoot  = eZContentObjectTreeNode::fetchByURLPath($countryCode);

    $articles = eZUser::fetch($user_id)->contentObject()
                                       ->mainNode()
                                       ->subTree(array( 'MainNodeOnly'     => false,
                                                        'ClassFilterType'  => 'include',
                                                        'ClassFilterArray' => array('article'),
                                                        'SortBy'           => array(array('published',true))));

    foreach ($articles as $article) {
      foreach ($article->object()->assignedNodes() as $node) {
        if ($node->fetchParent()->classIdentifier() == 'folder') {
          $article_list[$node->attribute('parent_node_id')][] = $article;
          break;
        }
      }
    }

    uksort($article_list, function($group1, $group2){return eZContentObjectTreeNode::fetch($group1)->attribute('priority') - eZContentObjectTreeNode::fetch($group2)->attribute('priority');});

    if ( $article_list=== null )
    {
        $result = array( 'error' => array( 'error_type' => 'kernel',
                                           'error_code' => eZError::KERNEL_NOT_FOUND ) );
    }
    else
    {
        $result = array( 'result' => $article_list );
    }
    return $result;
  }

  function fetchUnpublishedArticles($user_id)
  {
    $countryCode  = eZLocale::instance()->countryCode();
    $contentRoot  = eZContentObjectTreeNode::fetchByURLPath($countryCode);
    $userNodeID   = eZContentObject::fetch($user_id)->mainNodeID();
    $countryCode  = eZLocale::instance()->countryCode();
    $contentRoot  = eZContentObjectTreeNode::fetchByURLPath($countryCode);


    $subnodes = eZUser::fetch($user_id)->contentObject()
                                       ->mainNode()
                                       ->subTree(array( 'MainNodeOnly'     => false,
                                                        'IgnoreVisibility' => true,
                                                        'ClassFilterType'  => 'include',
                                                        'ClassFilterArray' => array('article'),
                                                        'SortBy'           => array(array('published',true))));


    $published_articles   = array_filter($subnodes, function($n){return $n->attribute('is_hidden')==false;});
    $unpublished_articles = array_filter($subnodes, function($n) use($userNodeID) {return ($n->attribute('is_hidden')==true) && ($n->object()->mainParentNodeID()==$userNodeID);});

    $published_articles_node_ids   = array_map(function($n){return $n->attribute('node_id');}, $published_articles);
    $unpublished_articles_node_ids = array_map(function($n){return $n->attribute('node_id');}, $unpublished_articles);




    foreach ($contentRoot->children() as $category)
    {
      $tmp = array();
      $articles_tmp = $category->subTree(array( 'MainNodeOnly'     => true,
                                                 'ClassFilterType'  => 'include',
                                                 'ClassFilterArray' => array('article'),
                                                 'SortBy'           => array(array('published',true)) ));

      foreach ($articles_tmp as $t) {

        // On récupère les parent_node_id des noeuds de l'objet
        $locations = array_map(function($n){return $n->attribute('parent_node_id');}, $t->object()->assignedNodes());

        if (!in_array($userNodeID, $locations)) {
          $tmp[] = $t;
        }
      }

      $articles[$category->attribute('node_id')] = $tmp;
    }

    foreach ($unpublished_articles as $a) {

        $art = new iPArticle($a->object());
        $cat = $art->getCategory();

        if(!$cat) continue;

        $cat_id = $cat->attribute('node_id');
        $articles[$cat_id][] = $a;
    }

    uksort($articles, function($group1, $group2){return eZContentObjectTreeNode::fetch($group1)->attribute('priority') - eZContentObjectTreeNode::fetch($group2)->attribute('priority');});

    if ( $articles=== null )
    {
        $result = array( 'error' => array( 'error_type' => 'kernel',
                                           'error_code' => eZError::KERNEL_NOT_FOUND ) );
    }
    else
    {
        $result = array( 'result' => $articles );
    }
    return $result;
  }

  function fetchNewArticles($owner_id)
  {


    $countryCode = eZLocale::instance()->countryCode();

    $node = eZContentObjectTreeNode::fetchByURLPath($countryCode);

    $articles = $node->subTree(array('MainNodeOnly'     => false,
                                     'AttributeFilter'  => array(array('published','>',(time()-30*24*60*60))),
                                     'ClassFilterType'  => 'include',
                                     'ClassFilterArray' => array('article')));

    $authorized_articles = array_filter($articles, function($n) use($userNode) {return !$n->attribute('is_hidden') || ($n->attribute('parent_node_id') == $userNode->attribute('node_id'));});

    foreach ($authorized_articles as $article)
    {
        $art    = new iPArticle($article->object());
        $cat_id = $art->getCategory()->attribute('node_id');

        $articles_list[$cat_id][] = $article;
    }

    uksort($articles_list, function($group1, $group2){return eZContentObjectTreeNode::fetch($group1)->attribute('priority') - eZContentObjectTreeNode::fetch($group2)->attribute('priority');});

    return array('result' => $articles_list);

  }

  function fetchAllArticles($owner_id)
  {
    $countryCode = eZLocale::instance()->countryCode();
    $contentRoot = eZContentObjectTreeNode::fetchByURLPath($countryCode);

    $filter = array( 'MainNodeOnly'      => true,              // On est obligé de mettre MainNodeOnly pour ne pas voir les articles des autres
                     'ClassFilterType'   => 'include',
                     'ClassFilterArray'  => array('article') );

    foreach ($contentRoot->children() as $child)
    {
      $articles[$child->attribute('node_id')] = $child->subTree($filter);
    }

   // A ce stade, $articles contient tous les articles communs mais pas les articles du péditre
   // Nous allons donc les récupérer et les ajouter

    $myarticles = eZUser::fetch($owner_id)->contentObject()
                                          ->mainNode()
                                          ->subTree(array( 'MainNodeOnly'     => true,
                                                           'Depth'            => 1,
                                                           'DepthOperator'    => 'eq',
                                                           'IgnoreVisibility' => true,
                                                           'ClassFilterType'  => 'include',
                                                           'ClassFilterArray' => array('article'),
                                                           'SortBy'           => array(array('published',true))));

    foreach ($myarticles as $article) {
        foreach ($article->object()->assignedNodes() as $node) {     // Un seul noeud parent nous intéresse: celui de la rubrique
            if ($node->fetchParent()->classIdentifier() == 'folder') {
                $articles[$node->attribute('parent_node_id')][] = $article;
                break;
            }
        }
    }

    // Maintenant il nous faut trier les articles des rubriques par ordre chronologique
    foreach ($articles as $k=>$v) {
        usort($articles[$k], function($b,$a){return $a->object()->attribute('published') - $b->object()->attribute('published');});
    }

    uksort($articles, function($group1, $group2){return eZContentObjectTreeNode::fetch($group1)->attribute('priority') - eZContentObjectTreeNode::fetch($group2)->attribute('priority');});

    return array('result' => $articles);

  }


  function fetchIsPublished($object_id, $user_id)
  {
    $article = eZContentObject::fetch($object_id);

    $user = $user_id ? eZUser::fetch($user_id) : eZUser::currentUser();

    if (!$article || !$user) {
        return array( 'error' => array( 'error_type' => 'kernel',
                                        'error_code' => eZError::KERNEL_NOT_FOUND ) );
    }
    $nodes = $article->assignedNodes();
    foreach ($nodes as $node) {

        if ($node->attribute('parent_node_id') == $user->contentObject()->mainNodeID() && !$node->attribute('is_hidden')) {

            return array( 'result' => true );
        }
    }

    return array('result'=>false);
  }

    function fetchCategory($object_id)
    {
        $article = eZContentObject::fetch($object_id);

        if ($article) {

            $nodes = $article->assignedNodes();

            foreach ($nodes as $node) {
                $parent = $node->fetchParent();
                if ($parent->classIdentifier() == 'folder') {

                    return array( 'result' => $parent);
                }
            }
        }

        return array( 'error' => array( 'error_type' => 'kernel',
                                        'error_code' => eZError::KERNEL_NOT_FOUND ) );
    }

    protected function getCategoryOfNode($node)
    {
        $article = new iPArticle($node->object());

        return $article->getCategory();
    }

  protected function getCategoryOfObject($object) {

      $nodes = $object->assignedNodes();

      foreach ($nodes as $node) {

          $parent = $node->fetchParent();

          if ($parent->classIdentifier() == 'folder') {

              return $parent;
          }
      }
  }
}