Although it’s very complete, sometimes you may want to customize a few things and for this you can create a custom action.

If you have, for example, a list of articles. It would be good if you could bulk publish them, instead of going and editing one by one. Fortunately this is possible and quite simple, although it’s not very clear in Rails Admin manual.

1. Create your custom action

Let’s create our custom action. Create file lib/rails_admin_publish.rb with the following content:

require 'rails_admin/config/actions'
require 'rails_admin/config/actions/base'

module RailsAdminPublish
end

module RailsAdmin
  module Config
    module Actions
      class Publish < RailsAdmin::Config::Actions::Base
        # There are several options that you can set here.
        # Check https://github.com/sferik/rails_admin/blob/master/lib/rails_admin/config/actions/base.rb for more info.

        register_instance_option :bulkable? do
          true
        end

        register_instance_option :controller do
          Proc.new do
            # Get all selected rows
            @objects = list_entries(@model_config, :destroy)

            # Update field published to true
            @objects.each do |object|
              object.update_attribute(:published, true)
            end

            flash[:success] = "#{@model_config.label} successfully published."

            redirect_to back_or_index
          end
        end
      end
    end
  end
end

What exactly this does? Well, first it defines this action as bulkable. There are many other options that you can set here, check the comment next to that line for more information.

After that, we create a Proc with our action. In summary, it’s getting all entries and looping to update the attribute published. After that, it sets a flash message and redirect to index.

2. Let Rails Admin know that your custom action exists

Open config/initializers/rails_admin.rb and add the following code before RailsAdmin.config:

require Rails.root.join('lib', 'rails_admin_publish.rb')

Them add this inside RailsAdmin.config:

# Register the class in lib/rails_admin_publish.rb
module RailsAdmin
  module Config
    module Actions
      class Publish < RailsAdmin::Config::Actions::Base
        RailsAdmin::Config::Actions.register(self)
      end
    end
  end
end

c.actions do
  # root actions
  dashboard                     # mandatory
  # collection actions
  index                         # mandatory
  new
  export
  history_index
  bulk_delete
  # member actions
  show
  edit
  delete
  history_show
  show_in_app

  # Set the custom action here
  publish do
    # Make it visible only for article model. You can remove this if you don't need.
    visible do
      bindings[:abstract_model].model.to_s == "Article"
    end
  end
end

What it does is to first register the publish action and them tell Rails Admin where it should be visible. If you want to make it visible for all models, simply remove that visible part and it should work correctly.

That’s it, restart your server and test. The bulk action should be there.

In case you still have questions I’ve forked dummy_app, which is a sample app created to show Rails Admin, and used it to create a custom action. Check it out in Github https://github.com/fernandomm/dummy_app

Here are the steps that i took to fix this problem:

1. Change the path/url in model

Before:

class User < ActiveRecord::Base
  has_attached_file :image
end

After:

class User < ActiveRecord::Base
  has_attached_file :image,
     :path => ":rails_root/public/system/users/images/:id/:style/:filename",
     :url => "/system/users/images/:id/:style/:filename"
end

This will make them to be stored in public/system/users/images/. If you have other models like Post or Article, edit them too but use different paths.

2. Move your current data

If you already have some files, it’s time to move them as Paperclip won’t do it for you. To do it i created a rake task. Place it in lib/tasks/copy_paperclip_data.rb:

desc "Copy paperclip data"
task :copy_paperclip_data => :environment do
  @users = User.find :all
  @users.each do |user|
    unless user.image_file_name.blank?
      filename = Rails.root.join('public', 'system', 'images', user.id.to_s, 'original', user.image_file_name)

      if File.exists? filename
        image = File.new filename
        user.image = image
        user.save

        image.close
      end
    end
  end
end

You probably have to adapt this in case you are working on another model or field. In this case, i’m working on model Users and field image.

Note that i’m copying data. In case something goes wrong, you can revert it back. Remove it after you’re done.

Now simply run:

rake copy_paperclip_data

Hope this helps you.

Fatal error: Uncaught exception 'Zend_Application_Resource_Exception'
with message 'Bootstrap file found for module "default" but
bootstrap class "Default_Bootstrap" not found'

This usually happens if you declare your controllerDirectory on Front Controller before defining a different defaultModule.

Something like this on application.ini:

resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.defaultModule = "core"

Removing controllerDirectory declaration should do the trick ( it’s not necessary since you are using modules ).

Or, you can simply place it below defaultModule declaration.

With so many technologies coming up, sometimes is difficult to analyze all of them in order to know which will fit better in your project. The purpose of this post is to show what makes ZF different from other solutions around. So let’s start…

Zend Framework is PHP MVC framework. It’s fully OOP and is actively developed. So far nothing exceptional, right? So let me show you some of the things that make it different.

1. Translation and localization done right!

The ZF developers have taken care of allowing translation of every component in brilliant way.  Not everyone speaks English and it sucks to start using a component and find out that you can’t easily translate the error messages, which are in English.

Zend Locale wonderfully does its job by detecting the language and country/region of the user and allowing others components to make use of this information.

• Zend Currency will know the currency symbol of the user’s country.
  Eg.: $ 4.00 for Americans and R$ 4,00 for Brazilians.

• If you have a Zend Form field declared as float, it will flawless validate depending  if user uses comma or dots as decimal symbols.
  Eg.: 1.23 for Americans and 1,23 for Brazilians

• Zend Route will take care to make the urls of your website fully localized, improving SEO.
  Eg.: /contact-us/ for Americans and /contacte-nos/ for Brazilians.

• And we can’t forget Zend Date, which will show the date in a way that user understand.
  Eg.: 12/31/2010 for Americans and 31/12/2010 for Brazilians.

• There is much more, but i can’t write all night

And no, you don’t have to manually insert this info. It doesn’t matter if your user is from Brazil, USA, Russia or India, their localization info is already in the framework ready to use.

2. High number of well tested and useful components.

Zend Framework offers a vast number of components for different purposes ( checkout their page to see all of them ) They are well tested as the framework development is test driven, so closed bugs are very unlikely to come back.

Whether you are trying to access your twitter account, getting a video info from Youtube or creating a tag cloud for your website, there are components for it saving you a lot of time.

3. Get used to the components and use them, everywhere.

Zend Framework is separated in components and it allows you to use them separately without requiring the full framework structure. There are, of course, some components with dependencies but most of them can be used alone.

Example, you can get the Zend Pdf component and use it in a project with Code Igniter or Cake PHP framework.

So, once you start working more and more with ZF but them have to work on another project, you will be able to use the same components that you are already used for.

4. Let’s bring some coding standards to PHP.

I have to admit, PHP sucks in coding standards. Even on the modules included in language you will find function’s name written in camelCase and functions written with underscore ( no_camel_case ).

It’s not good when you get some code from another developer and he is using camelCase while you are used to use underscores.

Another example are brackets. On an if condition, some developers likes to use in the same line, others in the next line.

The discussion here isn’t which is best, but there must be a standard so that, next time you get a code, you won’t get a bizarre monster made by 5 developers with their own preferences.

ZF clearly dictates some coding standards that you have to follow. All components in the framework use this standard and most of the code that you get is using it too.

5. If there is a standard, use it! Do not create your own!

Another thing that developers have taken care of is to use standards. It’s horrible to get new component that doesn’t follow any standards in its area and tries to create its own. Specially when you already know the standard.

An example:

PHP date’s function consider m as month char and i as minute char. It’s ok, but other’s libraries considers o for month and m for minute.

This is a simple example but when you are dealing with complex stuff, it can make you lose a lot of time.

Zend Date implementation uses ISO 8601 standard. Damn, there is a ISO standard for this, why will you create your own?

Ok, but what make it sucks?

I have written only a few aspects that make ZF rocks. So I will save some of them for a next post. Let’s talk about what make it sucks.

The main thing that still sucks in Zend Framework is the documentation. Although all components are documented there are too few examples and some of them do not work correctly, requiring some changes to achieve their purpose.

This is bad specially when you are learning something new. I often have to dig in the code of a component to find how a feature works. Sometimes because the example in manual is wrong and sometimes because the manual simply ignore the feature that i am trying to use.

Fortunately the developers are aware of this and one of the things which will be worked in version 2.0 is a better manual specially for people that are starting with the framework. Let’s hope that they can improve this

Conclusion

I have been working with Zend Framework for approximately 2 years and it has been a fun and productive experience.I am doing things much faster ( and IMO, cleaner ) than with any other framework that i worked before, like CodeIgniter or Symfony.

Unfortunately i cannot work with it full time because of other projects, but whenever a new project shows up, ZF is always my first choice as i know that it will save a lot of time.

Learning a new framework is a hard task. At the beginning you have to “learn again” lots of things and sometimes change your way of solving some kind of problems. With ZF is not different, but i would really recommend that you give it a try. I haven’t regretted at all!

One day you might need to get the date from a Zend Date object into Mysql format, but you will find out that none of the constants provides this. It’s a decision from developers to don’t mix database stuff with Zend Date.

Fortunately there is an easy way of doing this. If you have date fields on Mysql, you can use:

$date = new Zend_Date();

// Date field
echo $date->get('yyyy-MM-dd');

// Date time field
echo $date->get('yyyy-MM-dd HH:mm:ss');

But hold on, don’t start to write ‘yyyy-MM-dd’ everywhere on your application. If one day you change your database engine, or use a MySQL server with a different locale, you will need a good search and replace software to do it.

Instead of it, you can use a class with constants for the two field types. In this example i called the class Fm_Utils, but you can use the name that fits better on your application:

<?php
class Fm_Utils
{
    const DATABASE_DATE = 'yyyy-MM-dd';
    const DATABASE_DATETIME = 'yyyy-MM-dd HH:mm:ss';
}

Now you can simple use this to get date in Mysql format:

$date = new Zend_Date();

// Date field
echo $date->get(Fm_Utils::DATABASE_DATE);

// Date time field
echo $date->get(Fm_Utils::DATABASE_DATETIME);

And if one day you need to change your data platform, simply change the constant on this class.

I am still learning more about git, but it seems like a great tool

Here is the repository for all blog tutorials: http://github.com/fernandomm/Blog-Tutorials

echo Zend_Version::VERSION;

Which will result in something like this: 1.10.8.

Or open file Zend/Version.php and verify constant VERSION.

The objetive of this article is to explain how Zend Framework bootstrap works and, at a second part, show samples of bootstrap for common components.

The bootstrap class is used to load common components or resources that are used by all or most of your controllers, views etc. On “non-framework” applications it is common to have something like includes/common.php to “bootstrap” your application.

At this place you usually:

• Connect to database;
• Start session;
• Load config files;
• Load common libraries;

On ZF bootstrap, the idea is almost the same. Let’s now, try with an example. Consider the following empty bootstrap:

<?php
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{

}

With ZF, all bootstrap methods starts with _init and are protected. Example:

<?php
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
        protected function _initMonkeyAttack()
        {
                // Do your thing here
        }
}

This is just an example and you should always use things that describe what the method is doing. Unless you are really starting a monkey attack ( in this case, call me! ) change to something else.

Anything that starts with _init will be executed before application bootstrap.

What if i need to run method1 before method2?

It is common to require that one method is only called after another one. Example: the method that starts session should only start after the method that loads database, since your sessions are stored on database.

In this case, you can use $this->bootstrap( ‘nameOfTheMethod’ ); which will load a resource before the current one. Example:

<?php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
	protected function _initDb()
	{
		// Start database connection here
	}

	protected function _initSession()
	{
		// Bootstrap db first
		$this->bootstrap( 'db' );

		// Now start session
	}
}

That’s it. This is the first part of this article.  At the second part i will show bootstrap for common components like Zend_Db, Zend_Session, Zend_Translate, Zend_Locale etc.

The source code of this post is available at GitHub.

At this short tutorial i will show to how use Zend_Service_Twitter and Zend_OAuth. I’m considering that:

1. You have a working ZF environment.
2. You have registered your application at Twitter.com and have the consumer key and secret.

I won’t get into the details of how OAuth work, since there are many tutorials about it. But to summarize what our controller will do:

1. User access authenticate action and it’s redirected to Twitter.com
2. If user allow application access, he gets back to our application on callback action.
3. Callback action process the request and if user is authenticated, redirect to index action.
4. Index action uses twitter service class to get user timeline ( or do other actions ).

The first thing is to define a few configuration parameters. Since they are common between your controller actions, we will place it at application.ini. So open file applications/configs/application.ini and add the following lines:

twitter.callbackUrl = "http://localhost/twitter/callback"
twitter.siteUrl = "http://twitter.com/oauth"
twitter.consumerKey = "yourConsumerKey"
twitter.consumerSecret = "yourConsumerSecret"

The directives are self explanatory, just make sure that the callback url is set to the correct action.

Now that you have the config, let’s create a controller for it. In this example, it will be called twitter:

<?php

class TwitterController extends Zend_Controller_Action
{
	public function init()
	{

	}

	public function indexAction()
	{

	}

	public function authenticateAction()
	{

	}

	public function callbackAction()
	{

	}
}

Since we will need the config variables on all actions, we define it at init method:

	public function init()
	{
		// Define zend config on registry. I'm doing it here, but you probably have this on your bootstrap
		$zendConfig = new Zend_Config_Ini( APPLICATION_PATH . '/configs/application.ini', APPLICATION_ENV );
		Zend_Registry::set( 'Zend_Config' , $zendConfig );
	}

We have to redirect user to Twitter.com, so that he can allow our application to access his account. This is done at authenticate action:

	public function authenticateAction()
	{
		$zendConfig = Zend_Registry::get( 'Zend_Config' );

		// Instance oauth consumer with config options
		$consumer = new Zend_Oauth_Consumer($zendConfig->twitter->toArray());

		// Using the default session namespace, we store the request token serialized
		$session = new Zend_Session_Namespace();
		$session->requestToken = serialize( $consumer->getRequestToken() );

		// Redirect user to twitter.com
		$consumer->redirect();
	}

If user clicks on allow, he will be redirected to the callback action with a series of GET parameters containing the auth info. We have to process it in order to get the access token.

	public function callbackAction()
	{
		$zendConfig = Zend_Registry::get( 'Zend_Config' );

		// Instance oauth consumer with config options
		$consumer = new Zend_Oauth_Consumer($zendConfig->twitter->toArray());

		// Use default session namespace
		$session = new Zend_Session_Namespace();

		// Check if we got a get request and that  user already have a request token
		if ( !empty( $this->_request->getQuery() ) && !empty( $session->requestToken ) ) {

			// Get access token
			$token = $consumer->getAccessToken( $this->_request->getQuery() , unserialize( $session->requestToken ) );

			// Store access token on a session variable. You can also store on DB, in case you want to use later
			$session->accessToken = serialize( $token );

			// Remove request token, not necessary anymore
			unset( $session->requestToken );

			// Redirect to index action
			return $this->_helper->redirector( 'index' );
		} else {
			throw new Exception( 'Invalid access. No token provided.' );
		}
	}

As you can see, if everything works user is redirected to index action. At index action, i’ve placed an example of how to get user recent tweets. Zend_Service_Twitter offers many functions, you can check them at ZF manual.

	public function indexAction()
	{
		// Default namespace
		$session = new Zend_Session_Namespace();

		try {
			// Check if user have access token.
			if ( empty( $session->accessToken ) ) {
				throw new Exception( 'You are not logged in. Please, try again.' );
			}

			// Unserialize access token
			$token = unserialize($session->accessToken);

			$zendConfig = Zend_Registry::get( 'Zend_Config' );

			// Prepare a config array with access token and config options
			$config = $zendConfig->twitter->toArray();
			$config['username'] = $token->getParam( 'screen_name' );
			$config['accessToken'] = $token;

			$twitter = new Zend_Service_Twitter( $config );

			// Verify if credentials work
			$response = $twitter->account->verifyCredentials();

			if ( !$response || !empty( $response->error ) ) {
				throw new Exception( 'Wrong credentials. Please, try to login again.' );
			}

			// Vardump user timeline ( one tweet )
			var_dump( $twitter->status->userTimeLine() );

		} catch ( Exception $e ) {

			echo $e->getMessage();
		}

		die();
	}

That’s it. Hope you found this tutorial userful.

If you want, you can download the full source-code: TwitterController.php.