Helper vs Model? Quale dovrei usare?

Sto lavorando con l'API di Instagram in magento. Sto offrendo coupon ai miei follower su Instagram se seguono il nostro negozio su Instagram.

Sto effettuando le chiamate API a instagram in PHP usando curl. Attualmente sto avvolgendo le chiamate API nelle funzioni di supporto all'interno del mio modulo personalizzato. Dovrei invece racchiudere queste chiamate in una funzione all'interno di un modello?

Per esempio. Sto effettuando una chiamata API su Instagram per determinare se l'utente corrente sta seguendo il mio account. Quindi, nel mio controller, sto effettuando una chiamata alla mia funzione di supporto che restituisce il seguente stato al mio controller. Nel mio controller, aggiornerò quindi i miei modelli se necessario.

È corretto inserire queste chiamate API all'interno delle funzioni di supporto? Quando uso gli helper anziché i modelli?

<?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
    );
}

}

Per prima cosa devi chiederti qual è la differenza tra un modello e un assistente. La risposta più comune è "un modello ha una tabella dietro". Quindi chiediti "perché gli osservatori sono elencati come modelli e non come aiutanti".

Gli helper non dovrebbero esistere. Ma la pratica più comune è ... quando non sai dove mettere un po 'di codice, lo metti in un aiuto.
Questo è sbagliato, secondo me. L'uso degli helper non è proprio nello spirito OOP. Stai solo raggruppando alcune funzioni indipendenti all'interno di una classe.

Ma abbastanza discorsi filosofici.
Vorrei usare un modello. Principalmente perché gli helper sono sempre dei singoli. Mage::helper()restituisce sempre la stessa istanza di una classe helper.
Per i modelli è possibile ottenere nuove istanze e singoli, a seconda delle esigenze. Quindi è un po 'più flessibile usando un modello.

Ma in questo caso specifico, se hai bisogno solo di un'istanza della tua classe, puoi usare un aiutante o un modello. Non c'è differenza. Proprio quello che ti fa sentire a tuo agio.

Direi che è più adatto a un modello, poiché il suo scopo principale è accedere e rappresentare i dati.

Modello:

echo $MyModel->getUserName();

helper:

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

Se ha uno STATO INTERNO è un modello. Altrimenti è un aiuto con tutte le funzioni matematiche corrette, come sin(x)o str_tolower($text). Un modello ha uno stato interno che un assistente ottiene uno stato iniettato come dipendenza.

Se i metodi sono usati da molte classi (blocchi / modelli / controller) e comuni tra più modelli, allora un aiuto è la scelta ovvia.

Se i metodi vengono sempre utilizzati solo quando viene istanziato un singolo modello, all'interno di quel modello si trova il posto giusto.