The idea is to learn a new technology per month. It can a framework, a programming language or a concept. It doesn’t matter. The main idea is to keep open-minded about it without thinking that you could be doing the same task with your preferred language in way less time.

This already gave some nice results like learning Ruby On Rails which became my (current) web framework of choice.

At the beginning of 2014 I decided (again!) that I would do this, but with a small difference, I will post an article at the end of the month showing my impressions of the technology: what I liked, what I disliked, what I might use for some of my projects etc.

The first post should be out in a few days. I’m looking forward to post 12 articles about this in 2014.

You can import your DNS records by uploading a BIND zone file, unfortunately you might be using another server like PowerDNS.

One way that I found out is to use AXFR.

1) Enable AXFR in PowerDNS

Search for the following line in PowerDNS configuration:

disable-axfr=yes

Change it to:

disable-axfr=no

And restart PowerDNS.

Note that AXFR exposes all DNS records in all domains at your server. You might want to turn it off after the transfer is done.

2) Use dig to do a AXFR request and export everything

dig  +short axfr yourdomain.com > zonefile.txt

This will dump all records on a file called zonefile.txt.

3) Add your domain to Cloudflare and upload zonefile.txt

Just after adding your domain to Cloudflare, at the second step, you have the option to upload a zone file. Simply upload the file that was generated and, although it’s not a BIND zone file, it will work perfectly and all records should be imported.

It’s a service that promises to improve your focus while working by using the right music ( more info at their FAQ ).

It’s a bit earlier for any permanent conclusions but just after the first section I started to get some productivity boosts at the point that I could work on a task for 4 hours without a single distraction. Not even a quick look at Twitter or Hacker News!

They offer several genre options. The strange thing is that what I have been listening a lot is the Up Tempo with High energy level, usually something that I wouldn’t listen for entertainment since it’s not a genre that i appreciate.

I will post again after some weeks of testing. Let’s see if I can keep my productivity high.

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
&#91;/ruby&#93;

After:

&#91;ruby&#93;
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.rake:

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.

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 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.