SpinOneSolutions » Model

Magento Partial Refund Amount Correction for Authorize.net

Will Wright — Wed, 20 Jan 2010 22:04:48 +0000

The Problem:

You’ve enabled partial refunds in the Authorizenet Model, but it’s not refunding the proper amounts. This is due to, in my view, a bug in the core which I’ll show you how to patch!

The Solution:

What you need to do is overload the refund method in the Authorizenet model.

Create a new model that extends the original Authorizenet model. You’ll need to follow the general instructions for how to create a custom module if you don’t already know how to do so.

class Spinonesolutions_General_Model_Paygate_Authorizenet extends Mage_Paygate_Model_Authorizenet {
//Override Mage_Paygate_Model_Authorizenet

protected $_canRefund = true;

public function refund(Varien_Object $payment, $amount) {
  $error = false;
  if ($payment->getRefundTransactionId() && $amount>0) {
    $payment->setAnetTransType(self::REQUEST_TYPE_CREDIT);
    $request = $this->_buildRequest($payment, $amount);
    $request->setXTransId($payment->getRefundTransactionId());
    $result = $this->_postRequest($request);
    if ($result->getResponseCode()==self::RESPONSE_CODE_APPROVED) {
      $payment->setStatus(self::STATUS_SUCCESS);
    } else {
      $error = $result->getResponseReasonText();
    }
  } else {
    $error = Mage::helper('paygate')->__('Error in refunding the payment');
  }

  if ($error !== false) {
    Mage::throwException($error);
  }

  return $this;
}
}

Now all we need to do is let Magento know that we’ve got a custom model. In config.xml add



  
    
      0.0.1
    
  
  
    
      ...
      
        
          Imagistic_General_Model_Paygate_Authorizenet
        
      
      ...

That should do it! Questions and comments welcome.

Magento – Enable Paygate Refunds

Will Wright — Wed, 28 Oct 2009 21:43:26 +0000

The Problem:

You want to issue a refund, electronically, through your payment gateway from Magento.

The Solution:

By default, the community edition of Magento has refunds disabled in the Paygate Models. In order to enable them you need to create a custom Model and overwrite a protected variable. Refer to Part IV: Extending Models for more details on extending a Model.

First, lets take a look at the native Model so that you can understand what’s standing in the way. I’m going to use the Authorize.net gateway as my example.

The top portion of Mage_Paygate_Model_Authorizenet (/Mage/Paygate/Model/Authorizenet.php)

class Mage_Paygate_Model_Authorizenet extends Mage_Payment_Model_Method_Cc
{
    const CGI_URL = 'https://secure.authorize.net/gateway/transact.dll';

    const REQUEST_METHOD_CC     = 'CC';
    const REQUEST_METHOD_ECHECK = 'ECHECK';

    const REQUEST_TYPE_AUTH_CAPTURE = 'AUTH_CAPTURE';
    const REQUEST_TYPE_AUTH_ONLY    = 'AUTH_ONLY';
    const REQUEST_TYPE_CAPTURE_ONLY = 'CAPTURE_ONLY';
    const REQUEST_TYPE_CREDIT       = 'CREDIT';
    const REQUEST_TYPE_VOID         = 'VOID';
    const REQUEST_TYPE_PRIOR_AUTH_CAPTURE = 'PRIOR_AUTH_CAPTURE';

    const ECHECK_ACCT_TYPE_CHECKING = 'CHECKING';
    const ECHECK_ACCT_TYPE_BUSINESS = 'BUSINESSCHECKING';
    const ECHECK_ACCT_TYPE_SAVINGS  = 'SAVINGS';

    const ECHECK_TRANS_TYPE_CCD = 'CCD';
    const ECHECK_TRANS_TYPE_PPD = 'PPD';
    const ECHECK_TRANS_TYPE_TEL = 'TEL';
    const ECHECK_TRANS_TYPE_WEB = 'WEB';

    const RESPONSE_DELIM_CHAR = ',';

    const RESPONSE_CODE_APPROVED = 1;
    const RESPONSE_CODE_DECLINED = 2;
    const RESPONSE_CODE_ERROR    = 3;
    const RESPONSE_CODE_HELD     = 4;

    protected $_code  = 'authorizenet';

    /**
     * Availability options
     */
    protected $_isGateway               = true;
    protected $_canAuthorize            = true;
    protected $_canCapture              = true;
    protected $_canCapturePartial       = false;
    protected $_canRefund               = false;
    protected $_canVoid                 = true;
    protected $_canUseInternal          = true;
    protected $_canUseCheckout          = true;
    protected $_canUseForMultishipping  = true;
    protected $_canSaveCc = false;

    protected $_allowCurrencyCode = array('USD');

The variable that we’re interested in is _canRefund. The game plan is to create a custom Model that overrides Mage_Paygate_Model_Authorizenet and in that Model, override _canRefund. If you’re thinking, why not just change false to true right here, right now! Well my friend, you certainly could, but you’d certainly break your upgrade path too, check out Part IV: Extending Models and Part I: Custom Module.

I’m going to create the class: Spinonesolutions_Paygate_Model_Authorizenet (/local/Spineonesolutions/Paygate/Model/Authorizenet.php) and extend Mage_Paygate_Model_Authorizenet. Now I just override _canRefund and we’re halfway there.

If you read Part IV: Extending Models you’ll know that there’s one last step, and that is to modify config.xml so that our custom Model overrides the native Model.

/Spinonesolutions/Paygate/etc/config.xml


  
  ...
    
      
        Spinonesolutions_Paygate_Model_Authorizenet
      
    
  ...

That should do it! If you’ve got everything else setup correctly this should enable the Model to post refunds electronically to your gateway. Of course, if you want to enable more than one gateway, or perhaps a gateway that’s not Authorize.net you can do that by just following the same steps above with the Model for the gateway of your choice.

As always, questions and comments are welcome!

Update: From Commenter Cindy

Afer doing the above (and not forgetting to fill in app/etc/modules/MyNameSpace_All.xml to activate the new module), I still wasn’t getting authorize.net to really refund the cc.

I found that I needed to add the CC to the request, and then add the actual amount to be refunded. Now issuing a credit memo on the invoice will cause authorize.net to issue a refund to the CC.

Also, it appears that the ‘refund’ button only shows up if you click credit memo from an invoice – it doesn’t show up if you click credit memo on an order (only ‘refund offline’ shows up then).

Anyway, this is the code to make this work for me:

//
// Override Mage_Paygate_Model_Authorizenet
//    enable online refunds via credit memos
//    enable partial refunds
//
class Sbr_Paygate_Model_Authorizenet extends Mage_Paygate_Model_Authorizenet {
  protected $_canCapturePartial = true;
  protected $_canRefund = true;

  //
  // override _buildRequest to fill in the CC number as it is required yet not set peviously
  //
  protected function _buildRequest (Varien_Object $payment) {
    if (($payment->getAnetTransMethod() == self::REQUEST_METHOD_CC) &&($payment->getCcLast4()))
      $payment->setCcNumber($payment->getCcLast4());
   
      return parent::_buildRequest($payment);
  }

  // Override refund in order to fill out the amount
  //
  public function refund(Varien_Object $payment, $amount) {
    $error = false;
    if ($payment->getRefundTransactionId() && $amount>0) {
      $payment->setAnetTransType(self::REQUEST_TYPE_CREDIT);
      $request = $this->_buildRequest($payment);

      // set the amount (beginning of changes)
      $order = $payment->getOrder();
      $request->setXAmount($amount,2);
      $request->setXCurrencyCode($order->getBaseCurrencyCode());
      // (end of changes)

      $request->setXTransId($payment->getRefundTransactionId());
      $result = $this->_postRequest($request);

      if ($result->getResponseCode() == self::RESPONSE_CODE_APPROVED) {
        $payment->setStatus(self::STATUS_SUCCESS);
      } else {
        $error = $result->getResponseReasonText();
      }
    } else {
      $error = Mage::helper(’paygate’)->__(’Error in refunding the payment’);
    }

    if ($error !== false) {
      Mage::throwException($error);
    }

    return $this;
}

Magento – Part V: Data Layer

Will Wright — Wed, 28 Oct 2009 21:03:35 +0000

The Problem:

You need a custom Model to interact with a database.

The Solution:

By now you’ve read all the previous posts, right, and you want to take your custom module to the next level. You not only have business logic to perform, but you need to read and write data to a custom database table. No problem, let’s take a look at Magento’s database layer.

There’s a lot of voodoo that goes into the Database layer, most of the confusion stems from a heavy reliance on naming conventions. Once you understand these conventions you’ll have a much easier time getting data in and out of your database.

As always I’m going to use an example. Let’s say that you need to create a Widget Model that stores Widgets into a database table. We’ll need a Model to describe our Widget, a Class for the data layer, and the appropriate config files to let Magento know about our customizations.

I’m going to start with the Widget Model since it’s already been covered and should be the most familiar.

/app/code/local/Spinonesolutions/Helloworld/Model/Widget.php:

class Spinonesolutions_Helloworld_Model_Widget extends Mage_Core_Model_Abstract {
  function __construct() {
    parent::__construct();
    $this->_init("spinonesolutions_helloworld/widget");
  }

  public function save() {
    $this->setCreated(now());
    $this->setUpdated(now());

    parent::save();
    return $this;
  }
}

There are a couple of important things to make note of in the Class above. First, I’ve extended Mage_Core_Model_Abstract, this is Magento’s basic Data Layer Class and it will provide the functions that we need to interact with the database.

Second, the _init() function’s parameter should match your config.xml, as we’ll see in just a moment. Lastly, I’ve put a little bit of business logic in the save() method. As we’ll see this sets the created, and modified fields in our table to the current datetime when we call save().

/app/code/local/Spinonesolutions/etc/config.xml:



  
    
      0.1.0
    
  
  
    
       
        standard 
        
          Spinonesolutions_Helloworld 
          spinonesolutions 
        
      
    
  
  
    
       
        Spinonesolutions_Helloworld_Model 
        spinonesolutions_helloworld_mysql4 
      
       
        Spinonesolutions_Helloworld_Model_Mysql4
        
          widget 
        
      
      
        
          Imagistic_General_Model_Paygate_Authorizenet
        
      
    
    
     
       core_write
     
     
       core_read

Let’s start at the top and work our way down. Note: I’m going to skip the custom Model stuff and just focus on what’s new for this post.

 
  Spinonesolutions_Helloworld_Model 
  spinonesolutions_helloworld_mysql4

We just mapped a new resource Model (spinonesolutions_helloworld_model_mysql4) to spinonesolutions_helloworld. You’ll notice that the Model itself is defined right after this line.

 
  Spinonesolutions_Helloworld_Model_Mysql4
  
    widget

Just as we did for our custom Model before, we’ve now defined a new Model (spinonesolutions_helloworld_mysql4) and told Magento what its class is (Spinonesolutions_Helloworld_Model_Mysql4). Notice that we’ve already used this new Model as the resourceModel for spinonesolutions_helloworld.

As well as linking this Model to its Class we’ve also mapped a table to it in the entities section. Now the “widget” entity maps to the table “widget” in our magento database.

We need one more file; we’ve mapped spinonesolutions_helloworld_mysql4 to the class Spinonesolutions_Helloworld_Model_Mysql4 so we need to create a file to house this code.

/app/code/local/Spinonesolutions/Helloworld/Model/Mysql4/Widget.php:

class Spinonesolutions_Helloworld_Model_Mysql4_Widget extends Mage_Core_Model_Mysql4_Abstract {
  public function _construct() {
    $this->_init("spinonesolutions_helloworld/widget", "id");
  }
}

Throughout this tutorial I’ve been following Magento’s naming conventions for Class definitions and file names.

The first parameter passed to the _init() function is the Model that defines our table, and the second parameter is the name of the PrimaryKey field.

Last but not least we have the “resources” section of the config.xml. The read and write sections tell Magento what connection to use for read operations and write operations. As long as you keep true to the naming conventions you shouldn’t need to change these values too much.

Let’s put it all together and do a test. I’m going to create a table “widgets”:

widgets
id (int) – PK
title (varchar255)
description (varchar255)
created(datetime)
modified(datetime)

Now we’ll create a controller to manage CRUD for our new Model. I’ll call it WidgetController.

/app/code/local/Spinonesolutions/Helloworld/controllers/WidgetController.php

class Spinonesolutions_Helloworld_WidgetController extends Mage_Core_Controller_Front_Action {
  //indexAction is the default Action for any controller
  function indexAction() {
    echo "Spinonesolutions_Helloworld_WidgetController.indexAction()";
  }

  //{base}/spinonesolutions/widget/create/
  function createAction() {
    echo "Spinonesolutions_Helloworld_WidgetController.createAction()";
    $widget = Mage::getModel("spinonesolutions_helloworld/widget");
    $data = array(
      "title" => "My new title",
      "description" => "My new description"
    );

    $widget->setData($data);
    $widget->save();
  }
}

Requesting {base}/spinonesolutions/widget/create/ results in the insertion of a new record into my widget table! Let’s deconstruct what I’ve done a little bit to gain some understanding.

You’ll recognize the instantiation of the Model from my previous posts on custom Modules and Models. Magento stores all of an object’s data in an array which is stored in a private variable _data. Each of the array elements corresponds to a field in the table. All Models derived from the abstract classes have getters and setters for their variables. You can always call them by using the “get” and “set” prefix followed by camel case variable name.

So if the field in my database table is named “foo_bar”. In the object, the value will be stored in _data[“foo_bar”]. I can set the value by calling $object->setFooBar(“value”). I can get the value by calling $object->getFooBar();

That’s all for this post! I’ll go over widget CRUD in the next!

Download the source – Helloworld_v4

Magento – Part II : Models

Will Wright — Fri, 02 Oct 2009 16:18:49 +0000

The Problem:

You need to work with Magento Models, how chic!

The Solution:

Well, let’s be honest… I don’t have THE solution, but I do have some useful snippets of information to pass along.

Models are the meat of an MVC application. They contain the definitions for your application’s components. Stop for a moment and think conceptually about your application. Anything that is represented by a database table is most likely going to be a Model. Anything that can be mentally packaged up and labeled could be a Model. How are Models built, used, and made use of in Magento? Let’s find out.

In the Previous post I showed you how to create a custom Module and one of the main pieces of that Module was the Model Helloworld.

Hello World! My argument is : " . $arg;
  }
}

I’m going to examine it now, in more detail, to flush out some of the intricacies of Magento.

Notice the class definition:

Spinonesolutions_Helloworld_Model_Helloworld

It’s important to maintain this naming convention since Magento uses an autoloader to load class files when they’re called for. If they’re not named correctly it will look at the wrong place in the file system for the file which SHOULD contain the class it’s looking for, but alas it will not be there, and thus; it will not find it and you will receive an error.

Deconstructing the above:

Spinonsolutions_Helloworld_Model_Helloworld
{Namespace}_{Module}_Model_{Model}.php

Let’s look at some permutations to get a deeper understanding:

Spinonesolutions_Helloworld_Model_Worldhello
\Spinonesolutions\Helloworld\Model\Worldhello.php

Spinonesolutions_Helloworld_Model_Foo_Bar
\Spinonesolutions\Helloworld\Model\Foo\Bar.php

Spinonesolutions_Helloworld_Model_Foo_Helloworld
\Spinonesolutions\Helloworld\Model\Foo\Helloworld.php

Picking up the pattern? Good!

The __consruct method is called when Magento builds an instance of this Model. My constructors always contain, at least, a call to the parent constructor and sometimes more depending on the Model.

To instantiate an instance of a Model use Mage::getModel($modelClass,$arguments) or Mage::getSingleton($modelClass,$arguments). The parameter $modelClass is a string, the construction of which is partially determined by the config.xml and partly by the Model’s class definition. Let’s look at IndexController from Part I, line 23.

helloworld("helloworld");
  }
}

The piece of $modelClass that comes before the backslash (spinonesolutions_helloworld) is defined in the config.xml file included in the etc directory of your Module.





0.1.0




 
standard 

Spinonesolutions_Helloworld 
spinonesolutions 






 
Spinonesolutions_Helloworld_Model

Notice the models element. It’s defining a label for the class (and folder) Spinonesolutions_Helloworld_Model. Said in another way; given spinonesolutions_helloworld, the models element tells Magento what class and, by naming convention, what folder to look in for the second piece; that which comes after the backslash.

The piece that comes after the backslash (helloworld) tells Magento what particular Model you’re looking for. In my example, it’s simply helloworld, so the autoloader is going to be looking for a file named Helloworld.php that contains a class definition Spinonesolutions_Helloworld_Model_Helloworld. Lets extend the permutations that we used earlier adding how to instantiate each.

Spinonesolutions_Helloworld_Model_Worldhello
\Spinonesolutions\Helloworld\Model\Worldhello.php
$objModel = Mage::getModel(‘spinonesolutions_helloworld/worldhello’);

Spinonesolutions_Helloworld_Model_Foo_Bar
\Spinonesolutions\Helloworld\Model\Foo\Bar.php
$objModel = Mage::getModel(‘spinonesolutions_helloworld/foo_bar’);

Spinonesolutions_Helloworld_Model_Foo_Helloworld
\Spinonesolutions\Helloworld\Model\Foo\Helloworld.php
$objModel = Mage::getModel(‘spinonesolutions_helloworld/foo_helloworld’);

A great way to get a handle on how the naming conventions work is to meander through the core and note of name of the file and the folder structure it’s been placed in; then compare that to the class definition contained within.

One more time; since it took me a while to figure this out!

\Spinonesolutions\Helloworld\Model\Helloworld.php

Spinonesolutions_Helloworld_Model_Helloworld

Spinonesolutions_Helloworld_Model

$objModel = Mage::getModel(‘spinonesolutions_helloworld/helloworld);

Do you see it! Do you!?

One awesome, and very useful, property of Models is that they can extend any other Model you want. This is, in general, how you extend core Models with your own functionality.

This is absolutely essential when you want to add on to the Magento code base. If you just fire up your text editor and make your changes to the core, the next time you upgrade Magento, there’s a relatively good chance you’ll lose all your work.

That’s all for Models! Not really though, I’ve just covered the basics here, read on for more as I cover extending!

Download the source – Helloworld