¿Ayudante vs modelo? ¿Cuál debería usar?

Estoy trabajando con la API de Instagram en magento. Les doy cupones a mis seguidores de Instagram si siguen nuestra tienda en Instagram.

Estoy haciendo las llamadas API a instagram en PHP usando curl. Actualmente estoy envolviendo las llamadas API en funciones auxiliares dentro de mi módulo personalizado. ¿Debería envolver estas llamadas en una función dentro de un modelo?

Por ejemplo. Estoy haciendo una llamada API a Instagram para determinar si el usuario actual está siguiendo mi cuenta. Entonces, en mi controlador, estoy haciendo una llamada a mi función auxiliar que devuelve el estado de seguimiento a mi controlador. En mi controlador, actualizaré mis modelos si es necesario.

¿Estoy en lo correcto al poner estas llamadas API dentro de las funciones de ayuda? ¿Cuándo uso ayudantes en lugar de modelos?

<?php

class Company_SocialCoupons_InstagramController extends Mage_Core_Controller_Front_Action
{
    public function followAction() {

       $status = Mage::helper('socialcoupons/instagram')->getFollow();

       if ($status == 'follows') {

            // 1. ADD DATA TO MY DATABASE using my custom model
            //    - Ex. Mage::getModel('socialcoupons/instagram')->setInstagramId(*IGID*), etc. 
            // 2. CREATE COUPON
            // 3. EMAIL COUPON TO CUSTOMER
       }
}

class Company_SocialCoupons_Helper_Instagram extends Mage_Core_Helper_Abstract
{

public function getfollow() {

    $accessToken = $this->getAccessToken();
    $relationshipsUrl = 'https://api.instagram.com/v1/users/' . $this->getUserId() . '/relationship?access_token=' . $accessToken;

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $relationshipsUrl);
    curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: application/json'));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    $jsonData = curl_exec($ch);
    curl_close($ch);

    $response = json_decode($jsonData, true);
    $status = $response['data']['outgoing_status'];
    return $status;
}

public function generateAccessToken($code) {

    // exchange code for access token
    $accessTokenUrl = 'https://api.instagram.com/oauth/access_token';
    $data = array(
        'client_id'     => $this->getClientId(),
        'client_secret' => $this->getClientSecret(),
        'code'          => $code,
        'grant_type'    => 'authorization_code',
        'redirect_uri'  => $this->getRedirectUri()
    );       

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $accessTokenUrl);
    curl_setopt($ch, CURLOPT_POST, count($data));
    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: application/json'));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    $jsonData = curl_exec($ch);
    curl_close($ch);

    $response = json_decode($jsonData, true);

    if (isset($response['error_type'])) { // no error

        Mage::getSingleton('core/session')->unsInstagramAccessToken();
        Mage::getSingleton('core/session')->addError($response['error_message']);
        return $this->_redirect('*/*/authorize');  
    } 

    $accessToken = $response['access_token'];
    $id          = $response['user']['id'];
    $username    = $response['user']['username'];

    Mage::getSingleton('core/session')->setInstagramAccessToken($accessToken);      

    return array(
        'id'       => $id,
        'username' => $username
    );
}

}

Primero debe preguntarse cuál es la diferencia entre un modelo y un ayudante. La respuesta más común es "un modelo tiene una mesa detrás". Luego pregúntese "por qué los Observadores se enumeran como modelos y no como ayudantes".

Los ayudantes no deberían existir. Pero la práctica más común es ... cuando no sabes dónde poner un código, lo pones como ayuda.
Esto está mal, en mi opinión. Usar ayudantes no está realmente en el espíritu OOP. Solo está agrupando algunas funciones independientes dentro de una clase.

Pero suficiente conversación filosófica.
Yo usaría un modelo. Principalmente porque los ayudantes son siempre solteros. Mage::helper()siempre devuelve la misma instancia de una clase auxiliar.
Para los modelos, puede obtener nuevas instancias y singletons, según lo que necesite. Entonces es un poco más flexible usar un modelo.

Pero en este caso específico, si solo necesita una instancia de su clase, puede usar un asistente o un modelo. No hay diferencia. Justo lo que te hace sentir cómodo.

Yo diría que es más adecuado para un modelo, ya que su objetivo principal es acceder y representar datos.

Modelo:

echo $MyModel->getUserName();

Ayudante:

echo $MyHelper->getFullname($SomeModelThatImplementsSomeStuff)..

Si tiene un ESTADO INTERNO es un modelo. Si no es así, es un ayudante con todas las funciones matemáticas correctas, como sin(x)o str_tolower($text). Un Modelo tiene un estado interno, un Ayudante obtiene un estado inyectado como dependencia.

Si los métodos son utilizados por muchas clases (bloques / modelos / controladores) y son comunes entre múltiples modelos, entonces un ayudante es la opción obvia.

Si los métodos solo se usan cuando se crea una instancia de un solo modelo, entonces dentro de ese modelo está el lugar correcto.