DevInterface Blog

How to insert more Disqus comments box in a single page

Claudio — Thu, 26 Jan 2012 19:52:17 +0000

Hello everyone!

For those not familiar Disqus is a platform that allows you to easily insert a box for comments on any website and allows users to use the their Facebook or Twitter account (but not only) to authenticate.

The limit of Disqus is that it associates any thread of comments to a unique url.
Consequently, it will expect that in every page there is only a comment box.

In most cases this limit is acceptable, but for some applications it is useful to put more comments boxes on a single page. As an example think about a blog where you want to give the opportunity to comment on each post directly from the main page which lists all the posts one under each other.

What I want to show you today is a method to overcome the limit of Disqus and easily implement a page with more comments boxes, as in the blog example.
Using an iframe and jQuery we will make the boxes also dynamically loaded.

Suppose that we have our page index.html.haml as follows and to already have a Disqus account:

1
2
3
4

- @posts.each do |post|
= show_for post do |s|
= s.attribute :title
= s.attribute :body

The idea is to create an iframe dynamically below each post and have it displayed / hidden by jQuery when you click on a link “comments”.

We start creating the page comments.html.haml that we want to load inside the iframe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#disqus_thread

%noscript
Please enable JavaScript to view the
%a{:href => "http://disqus.com/?ref_noscript"} comments powered by Disqus.

%a.dsq-brlink{:href => "http://disqus.com"}
blog comments powered by
%span.logo-disqus Disqus

:javascript
var disqus_shortname = 'devinterface-example';

(function() {
var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
dsq.src = 'http://' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();

function disqus_config() {
this.callbacks.onReady = [function() {
var frameHeight = $(document).height();
$('iframe.comment_frame', top.document).attr("height", frameHeight)
}];
this.callbacks.onNewComment = [function() {
var frameHeight = $(document).height();
$('iframe.comment_frame', top.document).attr("height", frameHeight)
}];
}

On this page, we insert the html and javascript provided by Disqus and we set the variable disqus_shortname.
Then, using the disqus_config function we set two callbacks for Disqus so that after the complete loading or aftere a new comment is inserted, the iframe that contains this page be appropriately resized
NOTE: resizing iframe “container” is only possible because the two page “index” and “comments” are on the same domain. If not, in fact, access to the parent of an iframe would be impossible for the security policy of browsers.

Now that we have created our comments page, we have only to add the iframe dynamically to the index page.
To make things more “cool” we use the count of comments for each post as the link that will open/close the comments box.

Now we return to the index page and modify it as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

- @posts.each do |post|
= show_for post do |s|
= s.attribute :title
= s.attribute :body
/ disqus comments
= link_to "", "/#{post.slug}/comments#disqus_thread", :class=> "dq_comment", :id => post.id
.comment_box{:id => "comment_#{post.id}"}

:javascript
var disqus_shortname = 'devinterface-example';

(function () {
var s = document.createElement('script'); s.async = true;
s.type = 'text/javascript';
s.src = 'http://' + disqus_shortname + '.disqus.com/count.js';
(document.getElementsByTagName('HEAD')[0] || document.getElementsByTagName('BODY')[0]).appendChild(s);
}());

$(document).ready(function(){
$(".dq_comment").click(function(e){
e.preventDefault();

var id = $(this).attr("id");
var href = $(this).attr("href");
var src = href.substring(0,href.length-14); // Remove #disqus_thread

if ($("#comment_"+id).is(':visible'))
$("#comment_"+id).html('');
else
$("#comment_"+id).append('+src+'" class="comment_frame">');

$("#comment_"+id).toggle('slow');
})
});

As you can see we have added the link with the unique url of the post and the tag # disqus_thread to activate the counter of the comments, as explained in the documentation.
Finally, using the jQuery function we intercepted the click on the link in such a way to dynamically create an iframe below the post with the url of our comments.html.haml page.
Obviously the comments page’s url have to be appropriately defined in our routes file.

Now you just need to open your browser and see your posts, each with its comments box dynamically loaded by clicking on the counter link.

NOTE: If you try these scripts on localhost, remember to add to the two Disqus javascript:

1	var disqus_developer = 1;

just below disqus_shortname.

Share on:

Tips: Multiple pagination with will_paginate

Claudio — Thu, 11 Aug 2011 13:07:10 +0000

Will Paginate is a great and widely used gem for pagination in Ruby on Rails.

Sometimes you need to paginate multiple list on the same page.

This tip show you how to put a list of paginated products and a list of of paginated services on the same page with will_paginate.
The key point is to use a custom param param_name in the view and also in the controller

The view code is something like this:

1
2
3
4
5
6
7

# ...
# products list here
<%= will_paginate @products, :param_name => 'products_page', :prev_label => t('helpers.labels.previous'), :next_label => t('helpers.labels.next') %>

# services list here
<%= will_paginate @services, :param_name => 'services_page', :prev_label => t('helpers.labels.previous'), :next_label => t('helpers.labels.next') %>
# ...

And this is the code in the controller

1
2
3
4
5
6

# ...
def index
@products = current_company.products.paginate(:page => params[:products_page], :per_page => 10)
@services = current_company.products.paginate(:page => params[:services_page], :per_page => 10)
end
# ...

Share on:

Two step signup with Devise

Claudio — Wed, 11 May 2011 20:28:04 +0000

On my Ruby on Rails projects I usually use the Devise gem for user authentication.

In the last application I need to customize Devise so that users can register providing email address only. I will ask for a password only at the confirmation step.
After some tests, I come with this solutions.

1. First I need to overwrite the ConfirmationsController, so in the routes.rb I set devise to use my custom controller (my model is called Account).
I also need to define a custom controller for registrations so I can customize the registration view:

1
2
3

devise_for :accounts, :controllers => {:confirmations => "confirmations", :registrations => "registrations"} do
put "confirm_account", :to => "confirmations#confirm_account"
end

As you can see I’ve also added a custom method, confirm_account that I will use in the fourth step, as you will see soon.

2. Now I need to skip the devise built in password validation.
To achieve this I wrote a custom initializer called devise_customization.rb in /config/initalizers/ like this:

1
2
3
4
5
6
7
8
9
10
11

module Devise
module Models
module Validatable

def password_required?
false
end

end
end
end

So I have overwritten the default devise validatable module skipping the password validation.

3.The next step is to customize views.
Given I’m using a custom ConfirmationsController and RegistrationsController I have copied the default confirmations views under /views/confirmations/ and the default registrations views under /views/registrations/ and changed them according to my two step registration.

The /registrations/new view is something like this (I’m using haml)

1
2
3
4
5
6
7
8
9
10

= form_for(resource, :as => resource_name, :url => account_registration_path(@account)) do |f|
= devise_error_messages!
%p
= f.label :email
= f.email_field :email
%p.clearfix
= f.submit 'Signup'
= link_to 'Home', root_url
%br/
= render :partial => 'devise/shared/links'

Here I’ve just remove the password and password_confirmation fields.

The /confirmations/show view is something like this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

= form_for(resource, :url => confirm_account_path) do |f|
= devise_error_messages!
%p
= f.label :email
= @account.email
= f.hidden_field :confirmation_token
%p
= f.label :password
%br/
= f.password_field :password
%p
= f.label :password_confirmation
%br/
= f.password_field :password_confirmation
%p.clearfix
= f.submit 'Confirm Account'
= link_to 'Home', root_url
%br/
= render :partial => 'devise/shared/links'

4. Ok, once I’ve setup the views I have to write the new confirmation method in my ConfirmationsController. I can leave unchanged the RegistrationsController.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class ConfirmationsController < Devise::ConfirmationsController
def show
@account = Account.find_by_confirmation_token(params[:confirmation_token])
if !@account.present?
render_with_scope :new
end
end

def confirm_account
@account = Account.find(params[:account][:confirmation_token])
if @account.update_attributes(params[:account]) and @account.password_match?
@account = Account.confirm_by_token(@account.confirmation_token)
set_flash_message :notice, :confirmed
sign_in_and_redirect("account", @account)
else
render :action => "show"
end
end

end

The show method simply find the account to confirm by the devise token and render the show view.
The key point is the confirm_account method where I find the account, update attributes and if password_match? return true I confirm the account calling the standard devise method confirm_by_token

5. The last thing to do is to define the password_match? method inside the Account model.

1
2
3
4
5
6
7
8
9
10

class Account < ActiveRecord::Base
...

def password_match?
self.errors[:password] << 'password not match' if password != password_confirmation
self.errors[:password] << 'you must provide a password' if password.blank?
password == password_confirmation and !password.blank?
end

end

That’s all!
Now you can star your rails server and signup in your application providing a password only at the confirmation step.

Share on:

We area launching Gruppi Emergenti

DevInterface — Fri, 15 Apr 2011 12:56:41 +0000

It’s coming the time for publish online Gruppi Emergenti, the new music portal that offers a showcase for the bands, performers and live music venues in Italy.

The website is completely free, and allows you to create a page for your band or for your club and to publish your own live music events.

Through a localized search you can find all the upcoming events (live, concerts and so on) for a given period and in a given area.
Google Maps integration also allows you to visually locate events and live clubs.

Registered users can receive every week a list of scheduled events for their favorite groups or locals with a personalized newsletter.

Gruppi Emergenti has also a notice-board for people who is searching instruments, musicians and courses.

It is also integrated with major social networks so users can publish the events created on the site directly on the profiles and pages of Facebook and Twitter.

The official launch is scheduled for Wednesday, April 20.

All users already registered during the presentation of the site lasted from March 1 to April 15 will receive their credentials to access by e-mail address immediately after the publication.

In addition, from all registered users, we extracted four winners of two months of free advertising on the portal.

You can see the list of winners in the picture below.

The winners will be contacted by email in the next hours with all the details for the publication of advertisement.

Share on:

Random Posts

Prevent registration of reserved login

Claudio — Tue, 05 Apr 2011 08:34:47 +0000

Every time you create a web application where users can register, it is good to exclude some login or username so that they can not be used.
A classic example is the login “admin”.
I believe that no one wishes that in its application will be a registered user with the username “admin” then can contact other users by pretending to be the true administrator.
The same will be valid for others logins like “root”.

It is therefore necessary to define a list of reserved names.
Fortunately, developing with Ruby on Rails is very easy to implement this functionality by using the validates_exclusion_of validator up to version 2.3.8 of Rails

1
2
3
4
5

class User < ActiveRecord::Base
validates_exclusion_of :login,
:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved"
end

or by using validates with the :exclusion parameter if you’re developing with Rails 3.x

1
2
3
4
5

class User < ActiveRecord::Base
validates :login,
:exclusion => {:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved" }
end

In this way, anyone trying to create an account with login “admin” gets an error message indicating that the name is reserved.
It should however be borne in mind that “validates_exclusion_of” and also “validates: exclusion” methods are case sensitive.
This means that, with this first implementation, a user who tries to register as “Admin” will succeed.

To overcome this problem the easiest thing to do is add a before_filter to convert the login entered by user in all lowercase letters before validates it.
Here is the complete solution for Rails 2.3.x:

1
2
3
4
5
6
7
8
9

class User < ActiveRecord::Base

before_validation { |u| u.login.downcase! }

validates_exclusion_of :login,
:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved"

end

and the equivalent solution for Rails 3:

1
2
3
4
5
6
7
8
9

class User < ActiveRecord::Base

before_validation { |u| u.login.downcase! }

validates :login,
:exclusion => {:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved" }

end

This method has the disadvantage of converting all login lowercase not allowing user to register two “equal” but with different case logins.
This is a solution that can be acceptable in many cases.
However, if you need to preserve the case-sensitive login as entered by users, you can always implement a custom validation method:

1
2
3
4
5
6
7
8
9

class User < ActiveRecord::Base
validate :excluded_login

def excluded_login
%w( admin root administrator superuser ).each do |reserved_login|
user.errors.add(:login, "is reserved") if user.login.downcase == reserved_login
end

end

Have you ever implemented a solution like this? Do you know a better way to achieve it?

Share on:

A new layout easier and more spacious

DevInterface — Tue, 22 Mar 2011 12:56:09 +0000

In the last days we have spent a bit of our time to do a full redesign of our website and our blog.

The result is what you are looking while reading this article.

Specifically, the innovations we introduced in both the theme of the blog and the web site are:

Wider layout splitted into two columns also for the website
Blog contents with more space, which is very useful when showing code snippets
A wide and straight header that shows the key points of each page
A wider footer with all our references and the latest posts from Twitter (on the site, even the latest blog post)
A slider both on the homepage of the blog and the web site that visually sums up (at least in part) what we do
The “portfolio” page completely redesigned
The “about us” page with a more dynamic look

From a technical standpoint the site has been rewritten using Ruby on Rails 3.0.5 and jQuery while the blog engine is always the well proven Wordpress.

Do you like the new design? We are waiting for your comments!

Share on:

How to send email asynchronously using Devise and Rails3

Stefano — Fri, 04 Mar 2011 14:47:16 +0000

Hello everyone.

I’d show a workaround to send email asynchronously using Devise and Rails3.

Suppose we have already up and running our application with Devise and delayed_job correctly installed.

A first attempt was to add in config/initializers the following file (devise_async.rb):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#devise_async.rb
module Devise
module Models
module Confirmable
handle_asynchronously :send_confirmation_instructions
end

module Recoverable
handle_asynchronously :send_reset_password_instructions
end

module Lockable
handle_asynchronously :send_unlock_instructions
end
end
end

This workaround has worked in part: the send method has been properly enqueued in the database, but when delayed_job tries to fire the job, the following error is raised:

1 2	User#send_confirmation_instructions_without_delay failed with NoMethodError: undefined method 'send_confirmation_instructions_without_delay' for # - 1 failed attempts [Worker(host:stefano-desktop pid:13153)]

As you can see, the job is trying to call the wrong send method: send_confirmation_instructions_without_delay.

At this point, I’ve implemented an even more dirty hack, overriding Devise’s methods using the syntax specified by intridea to send emails in the background:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#devise_async.rb
module Devise
module Models
module Confirmable
# Send confirmation instructions by email
def send_confirmation_instructions
generate_confirmation_token! if self.confirmation_token.nil?
::Devise.mailer.delay.confirmation_instructions(self)
end
end

module Recoverable
# Resets reset password token and send reset password instructions by email
def send_reset_password_instructions
generate_reset_password_token!
::Devise.mailer.delay.reset_password_instructions(self)
end
end

module Lockable
# Send unlock instructions by email
def send_unlock_instructions
::Devise.mailer.delay.unlock_instructions(self)
end
end
end
end

This solution, however, is too tied to the implementation of Devise and is therefore not a good one (besides being really really dirty).

The latest idea, which represents the solution I’ve used is implemented as follows: use the alias_method in this way:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#devise_async.rb
module Devise
module Models
module Confirmable
alias_method :send_confirmation_instructions_without_delay, :send_confirmation_instructions
handle_asynchronously :send_confirmation_instructions
end

module Recoverable
alias_method :send_reset_password_instructions_without_delay, :send_reset_password_instructions
handle_asynchronously :send_reset_password_instructions
end

module Lockable
alias_method :send_unlock_instructions_without_delay, :send_unlock_instructions
handle_asynchronously :send_unlock_instructions
end
end
end

This latest hack works a treat; is not the best but let you send mail with Devise asynchronously.

If you have any better solutions, do not hesitate to share.

Share on:

How to implement two dropdowns dependent on each other using Django and jQuery

Stefano — Fri, 25 Feb 2011 15:40:46 +0000

Hello everyone.

With today’s article I want to show how to implement two dropdowns dependent on each other using Django and jQuery.

Suppose we have a 1-N relationship between car brands and car models: we want to show the list of brands in the first dropdown; then once you have selected a brand, the second dropdown will show a list of filtered models for that brand.

Suppose we have our models defined as follows:

1
2
3
4
5
6
7
8
9

#models.py
class VehicleBrand(models.Model):
description = models.CharField(max_length=100)
code = models.SlugField(primary_key=True)

class VehicleModel(models.Model):
description = models.CharField(max_length=100)
code = models.SlugField(primary_key=True)
brand = models.ForeignKey(VehicleBrand)

Let’s write a templatetag that will be included in our templates:

1
2
3
4
5
6
7
8
9
10
11

#templatetags.py
from models import VehicleBrand

from django import template

register = template.Library()

@register.inclusion_tag("brand_model_select.html")
def brand_model_select():
brand_list = VehicleBrand.objects.all()
return {'brand_list' : brand_list}

As you can see, the templatetag requires a support html template, defined as follow:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

<form action="" method="get" accept-charset="utf-8">
<select name="brand" id="brand">
<option value="Z">Select a brand</option>
{% for brand in brand_list %}
<option value="{{ brand.code}}">{{ brand.description }}</option>
{% endfor %}
</select>
<select name="model" id="model" disabled="true">
<option>Select a model</option>
</select>
</form>
<script>
$(document).ready(
function() {
$("select#brand").change(function() {
if ($(this).val() == 'Z') {
$("select#model").html("<option>Select a model</option>");
$("select#model").attr('disabled', true);
}
else {
var url = "/brand/" + $(this).val() + "/all_json_models";
var brand = $(this).val();
$.getJSON(url, function(models) {
var options = '<option value="Z">Select a model</option>';
for (var i = 0; i < models.length; i++) {
options += 'i].pk + '">' + models[i].fields['description'] + '</option>';
}
$("select#model").html(options);
$("select#model option:first").attr('selected', 'selected');
$("select#model").attr('disabled', false);
});
}
});

$("select#model").change(function(vent) {
if ($(this).val() == -1) {
return;
}
myAwesomeFunctionToCallWhenAModelIsSelected();
});
});
}

</script>

Please note that once a brand is selected, the following url will be invoked via Ajax request:
/brand/”selected_brand_code”/all_json_models

then we need to define a view to handle this request:

1
2
3
4
5
6

#views.py
def all_json_models(request, brand):
current_brand = VehicleBrand.objects.get(code=brand)
models = VehicleModel.objects.all().filter(brand=current_brand)
json_models = serializers.serialize("json", models)
return HttpResponse(json_models, mimetype="application/javascript")

and in urls.py:

1
2
3

#urls.py
...
(r'^brand/(?P[-\w]+)/all_json_models/$', 'all_json_models'),

Finally, the javascript method myAwesomeFunctionToCallWhenAModelIsSelected() will be invoked when a model will be selected.

Share on:

Ruby Enumerables: Operation on hashes

Claudio — Tue, 15 Feb 2011 10:42:48 +0000

In my last post I talked about Ruby’s hash.
Today I will resume and complete the argument by describing some of the things you can do to manipulate the hash values.

1. How to iterate over Hash elements

The Ruby Hash class provides three different iterators: each, each_key, each_value.
There is actually a fourth iterator, each_pair but it is only an alias of each.

As you can expect the each iterator works as follows:

1
2
3
4
5
6

{"company" => "DevInterface", "activity" => "Web Agency"}.each do |key, val|
p key, ": ", val
end
# Will print
"company: DevInterface"
"activity: Web Agency"

The other two operators, respectively, allow to iterate only on the keys or only on the values of the hash.

1
2
3
4
5
6
7
8
9
10
11
12
13

{"name" => "Claudio", "role" => "Web Developer"}.each_key do |key|
p key
end
# Will print
"name"
"role"

{"name" => "Claudio", "role" => "Web Developer"}.each_value do |val|
p val
end
# Will print
"Claudio"
"Web Developer"

2. How to invert the values with the keys

An operation that can be in some cases very useful it’s the inversion of values with keys.
The classic example is the phone book.

Suppose we have an hash that contains the telephone book as follows

1	phone_numbers = {"DevInterface" => "339-045-2223836", "John" => "555-6677", "Stefano" => "335-12345678"}

and we want to know who owns the number “555-6677″.
We can iterate over all the hash to find the searched value and then return the key. But what if the hash contains 1000 elements instead of 3?

The alternative is to reverse the hash so numbers become the keys and names become values.

The Hash class provides the invert method for this purpose:

1 2	inverted_phone_numbers = phone_numbers.invert inverted_phone_numbers["555-6677"] # Will return "John"

Before using the invert method, however, it’s fundamental keep in mind that the hash keys are unique, but the values can be duplicated.
Consequently, when reversing a hash any duplicate values will be converted into a unique key, with consequent data loss .
In fact, it’s not predictable which of the values will be kept and which will instead be discarded.

Using the example of the phone book if we had:

1	phone_numbers = {"DevInterface" => "339-045-2223836", "John" => "555-6677", "Mary" => "555-6677", "Stefano" => "335-12345678"}

and then perform the same operation as before

1 2	inverted_phone_numbers = phone_numbers.invert inverted_phone_numbers["555-6677"] # Will return "John" or "Mary"

we can not know for sure if it will return “John” or “Mary”.

3. How to convert a hash into an array

You can convert a hash into an array using the method to_a.
The result is an array where the even elements are the keys and the odd elements are the values.

1 2	my_hash = {"a" => 1, "b" => 2, "c" => 3} my_hash.to_a # ["a", 1, "b", 2, "c", 3]

But sometimes it is more convenient to have two separate array for keys and values. It ‘can get you in the following way:

1 2	my_hash.keys.to_a # ["a", "b", "c"] my_hash.values.to_a # [1, 2, 3]

Finally, using the values_at method, the hash can be extracted in an array selectively: you can select which elements to extract by passing keys to the method.

1	my_hash.values_at("a", "c") # [1, 3]

Ruby also allows the reverse conversion, create a hash from an array:

1 2	my_array = [1, 2, 3, 4, 5, 6] my_hash = Hash[*my_array] # {1 => 2, 3 => 4, 5 => 6}

Obviously, this conversion is only possible if the array has an even number of elements.

4. How to sort an Hash

A hash, as seen in previous posts, is an un-ordered structure.
However, in some cases it may be needed to order the values. There is therefore a sort method. But the result of this sorting is an array.
This is because Ruby, to order a hash converts it into an array of arrays and then sorts it.

1 2	beatles = {"Jonn" => "Lennon", "Ringo" => "Starr", "Paul" => "McCartney", "George" => "Harrison"} beatles.sort # [["George", "Harrison"], ["Jonn", "Lennon"], ["Paul", "McCartney"], ["Ringo", "Starr"]]

5. How to merge two hashes

The last topic I want to discuss today is how to merge two hashes.

Suppose we want to make an unlikely merging of two historical groups, the Beatles and the Rolling Stones:

1
2
3

beatles = {"Jonn" => "Lennon", "Ringo" => "Starr", "Paul" => "McCartney", "George" => "Harrison"}
rolling_stones = {"Mick" => "Jagger", "Keith" => "Richards", "Ronnie" => "Wood", "Charlie" => "Watts"}
rolling_beatles = beatles.merge(rolling_stones)

The result is a third hash composed as follows:

1
2
3

p rolling_beatles
# {"Jonn" => "Lennon", "Ringo" => "Starr", "Paul" => "McCartney", "George" => "Harrison",
"Mick" => "Jagger", "Keith" => "Richards", "Ronnie" => "Wood", "Charlie" => "Watts"}

In the case of duplicate keys, however, the merge only keeps the key of the second hash:

1 2	a = {"a" => 1, "b" => 2, "c" => 3} b = {"a" => 5, "d" => 7, "e" => 9}

c = a.merge(b) # {“a” => 5, “b” => 2, “c” => 3, “d” => 7, “e” => 9}

Alternatively, you can pass to the merge method a block of code to handle conflicts on the keys:

1
2
3
4
5

a = {"a" => 1, "b" => 2, "c" => 3}
b = {"a" => 5, "d" => 7, "e" => 9}

c = a.merge(b) {|key, old_val, new_val| old_val < new_val ? old_val : new_val}
# {"a" => 1, "b" => 2, "c" => 3, "d" => 7, "e" => 9}

As you can see the result of this merge is different from the above depending on the condition specified in the code block.

Share on:

How to create a custom feed in Django using the Syndication Feed Framework

Stefano — Mon, 31 Jan 2011 14:28:23 +0000

Hello everyone.

In this article I will show you how to create a custom feed in Django, using the Django Syndication Feed Framework 1.2 or higher.

I’ve had to create an XML with some more tags for each item in the feed.
In particular, in addition to the usual tags present in an RSS feed, I’ve added the

and

tags.

Reading the official documentation of the framework, it is recommended to create a custom feed generator, but the process is not very clear.

Let’s see step by step how to fix everything.

First we create a custom feed generator.

This generator must create the same XML that would produce the framework’s default generator and for each item in the list it will add the new tags.

1
2
3
4
5

class CustomFeedGenerator(Rss201rev2Feed):
def add_item_elements(self, handler, item):
super(CustomFeedGenerator, self).add_item_elements(handler, item)
handler.addQuickElement(u"image", item['image'])
handler.addQuickElement(u"short_description", item['short_description'])

We see that the generator calls the method add_item_elements(handler, item) of its superclass and then adds new XML tags for each item.
Note that the values that will be inserted in the image and short_description tags must be present in the item dictionary passed as argument.

So let’s create our CustomFeed class that inherits from Feed class and see how to tell it to use the CustomFeedGenerator and how to insert the new values in the item dictionary.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class CustomFeed(Feed):

feed_type = CustomFeedGenerator

def title(self, obj):
return u"My amazing feed"

def description(self, obj):
return u"My feed description"

def link(self, obj):
return "http://%s" % obj.get_absolute_url()

def item_extra_kwargs(self, obj):
"""
Returns an extra keyword arguments dictionary that is used with
the `add_item` call of the feed generator.
Add the 'content' field of the 'Entry' item, to be used by the custom feed generator.
"""
return { 'image': obj.get_picture().get_medium_url() if obj.get_picture() else "",
'short_description' : obj.get_preview(),}

CustomFeed is very similar to the various feeds that we are accustomed. The only difference is represented by the statement of the type of feed

feed_type = CustomFeedGenerator

and by the method

item_extra_kwargs

able to append any new values in the item dictionary, obtaining the desired result.

Share on:

DevInterface Blog

How to insert more Disqus comments box in a single page

Related Post

Tips: Multiple pagination with will_paginate

Related Post

Two step signup with Devise

Related Post

We area launching Gruppi Emergenti

Random Posts

Prevent registration of reserved login

Related Post

A new layout easier and more spacious

Related Post

How to send email asynchronously using Devise and Rails3

Related Post

How to implement two dropdowns dependent on each other using Django and jQuery

Related Post

Ruby Enumerables: Operation on hashes

Related Post

How to create a custom feed in Django using the Syndication Feed Framework

Related Post