I found lots of discussions about that, however none of them were enough for me. Some of the discussions:

• http://bugs.developers.facebook.com/show_bug.cgi?id=8184
• http://bugs.developers.facebook.com/show_bug.cgi?id=8691

And now… my solution:

Log in to Facebook, create new app, create fan page.

Now you are ready.

Add app to your fan page.

Go to http://www.facebook.com/apps/application.php?id=ID_OF_YOUR_APP.

Find link ‘Add to my Page’ on the left, click on it. Find your page on the list and click on ‘Add to page’ next to this page.

Set application type

Go to http://www.facebook.com/developers/editapp.php?app_id=ID_OF_YOUR_APP.

Choose ‘Web’ next to ‘Application type’ and click on ‘Save Changes’ button.

Add permissions to your app

Prepare special link:

http://www.facebook.com/connect/prompt_permissions.php?api_key=YOUR_API_KEY&v=1.0&next=http://www.facebook.com/connect/login_success.html?xxRESULTTOKENxx&display=page&ext_perm=publish_stream,offline_access&enable_profile_selector=1&profile_selector_ids=ID_OF_YOUR_PAGE

replace YOUR_API_KEY for an API KEY of your application and ID_OF_YOUR_PAGE for an id of your page

Run this URL in your web browser. Click on ‘Allow’.

You should see a message: ‘Success’.

Check everything

Go to http://developers.facebook.com/tools.php?app_id=335851346097 and check your permissions.

Choose your application, change ‘Response Format’ to JSON, choose method ‘users.hasAppPermission’, fill publish_stream in ext_perm and id of your page in uid.

You should see result: 1.

That means that everything is ok.

Write a code

Right now I will show how to create script in python (with PyFacebook), but the code is really similar to that from other programming languages.

def add_to_fb();
	import facebook
	fb = facebook.Facebook('YOUR_API_KEY', 'YOUR_SECRET_KEY')
	fb.auth.createToken()
	fb.login(popup=False)

	#print 'offline access...'
	#b.request_extended_permission('offline_access')
	#print 'publish stream...'
	#fb.request_extended_permission('publish_stream')

	print 'get session...'
	fb.auth.getSession()

	print 'add...'

	try:
		id_of_message = fb.stream.publish(message='my test message', uid=ID_OF_YOUR_PAGE)
	except Exception, e:
		error_code = None
		try:
			error_code = e.code
		except AttributeError:
			pass

		if error_code:
			print  "Facebook returned an error - sorry! %s %s" % (str(e.code), repr(e))
		else:
			print  "Facebook returned an error - sorry (no error code)! %s" % (repr(e))
	else:
		print id_of_message

And that’s all. Try to use it.

Sometimes it’s necessary to use request_extended_permission() (if we want to add privileges to our user), so you can uncomment these two lines.

Lots of hours… but at last – success.

Everything is because I forgot about one parameter… so what I need to do right now, is to add parameter ‘cascade’ to my model.

Model with new parameter could looks like:

(...)
tags = relation('BlogTag2Entry', backref='blogentry', order_by='BlogTag2Entry.id_blog_tag', cascade="all")
(...)

and that’s all. Easy, right?

More about this parameter could be found in SQLAlchemy documentation.

Ok, so let’s code something…

We need to have one external library in our environment. It’s boto (Python interface to Amazon Web Services).

Now, create new file (let’s call it ‘download_files_from_s3.py’) and add there:

from boto.s3 import Connection
import StringIO
import getopt, sys

class Downloader():

    base_dir = None
    bucket_name = None
    aws_access_key_id = 'YOUR_AWS_ACCESS_KEY_ID'
    aws_secret_access_key = 'YOUR_SECRET_ACCESS_KEY'

    def start_downloading(self):

        try:
            opts, args = getopt.getopt(sys.argv[1:], "b:u:", ["help"])
        except getopt.GetoptError, err:
            print "No way! We don't have an option like this one!"
            print str(err)
            sys.exit(2)

        self.base_dir = None
        for o, b in opts:
            if o == "-b":
                self.base_dir = b
                print "I have base_dir"
                print "It's: " + str(self.base_dir)
            if o == "-u":
                self.bucket_name = b
                print "I have bucket_name"
                print "It's: " + str(self.bucket_name)
            elif o in ("-h", "--help"):
                print "No way! We don't have an option like this one!"
                sys.exit()

        if not self.base_dir:
            print "I need base_dir!"
            sys.exit()

        if not self.bucket_name:
            print "I need bucket_name!"
            sys.exit()

        # connect with Amazon S3
        s3_connection = Connection(aws_access_key_id=self.aws_access_key_id,
                                   aws_secret_access_key=self.aws_secret_access_key)
        bucket = s3_connection.get_bucket(self.bucket_name)

        print 'Start fetching keys...'

        keys = []
        rs = bucket.get_all_keys()

        for each in rs:
            keys.append(each)

        print 'Loop nr. 1'
        print str(len(rs)) + ' keys in current loop'

        inc = 2
        while True:
            last = keys[len(keys)-1]

            rs = bucket.get_all_keys(marker=last.key)

            print 'Loop nr. ' + str(inc)
            print str(len(rs)) + ' keys in current loop'

            if len(rs) < 1:
                break
            for each in rs:
                keys.append(each)

            inc += 1

        print 'I have all keys'
        print 'Start downloading...'
        print 'We have ' + str(len(keys)) + ' files to download.'

        inc = 0
        for each in keys:
            orig_image_key = bucket.get_key(each)
            orig_im_temp = StringIO.StringIO(orig_image_key.get_contents_as_string())

            f = open('%s%s' % (self.base_dir, each.name), 'w')
            f.write(orig_im_temp.getvalue())
            f.close()

            inc += 1

            print 'File ' + str(inc) + ' is on local disk'

        print 'All finished.'

def main():
    downloader = Downloader()
    downloader.start_downloading()

if __name__ == '__main__':
    main()

Ok, script is ready.

We need to run it by:

python download_files_from_s3.py -b our_base_dir -u our_bucket_name

where our_base_dir is a path where we want to put downloaded files and our_bucket_name is a name of our bucket on AWS S3.

It won’t be a long advice.

Everything what I need to do is to create new file (let’s call it eclipse_run.sh) and add there something like:

export GDK_NATIVE_WINDOWS=true
PATH_TO_YOUR_ECLIPSE_RUN_FILE

So on my computer it will be:

export GDK_NATIVE_WINDOWS=true
/home/karol/Pulpit/eclipse/eclipse

We should have an ability to run it, so we have to do:

sudo chmod +x eclipse_run.sh

The end.

Now everything what I need to do is to start eclipse via that file.

What is Feedburner? It’s a great tool for managing RSS feeds.

Why I may want to have number of subscribers? Because we may want to show that number on our website.

We will use Feedburner’s API. What you should read is: Past Basic Feed Awareness Data

I will use XMLObject class to parse XMLs, because I simply like it.

Ok, let’s code…

Open your *.py file (it could be main/views.py) and add there one new method:

def getFeedburner(request):
    from datetime import datetime as datetime2now
	today = datetime2now.now().date()
	actTime = datetime2now.now().timetz()
	actTime = str(actTime)
	actTime = actTime[:8]
	oneDay = datetime.timedelta(days=1)
	twoDays = datetime.timedelta(days=2)
	yesterday = today - oneDay
	twodaysago = today - twoDays

	from develway.main.xmlobject import XMLFile

	url = 'https://feedburner.google.com/api/awareness/1.0/GetFeedData?uri=URI_OF_MY_WEBSITE&dates=' + str(twodaysago) + ',' + str(yesterday)

	f = urllib.urlopen(url)
	xml = f.read()

	xml = XMLFile(raw=xml)
	entries = xml.root.feed.entry

	circulation_yesterday = None
	circulation_twodaysago = None
	for each_entry in entries:
		if each_entry._get('date') == str(yesterday):
			circulation_yesterday = each_entry._get('circulation')
		elif each_entry._get('date') == str(twodaysago):
			circulation_twodaysago = each_entry._get('circulation')

	if circulation_yesterday:
		value = circulation_yesterday
	elif circulation_twodaysago:
		value = circulation_twodaysago

	return HttpResponse(str(value))

That’s all. Now add new view to your urls.py:

    (...)
    (r'^get-feedburner/$', 'YOUR_PROJECT.main.views.getFeedburner'),

and test it by going to the URL: http://your_domain/get-feedburner/

Everything should work fine.

What you have to know: UFW is not the firewall. UFW just configures your iptables

And that’s what I was looking for.

First… check what you have installed on your server and which ports are opened. Do it by ‘ps -aux’ and ‘nmap’. Consider which ports you would like to have opened and which ones should be closed.

Next… install UFW:

sudo apt-get install ufw

and disable all ports:

sudo ufw default deny

Next… configure your firewall.

I would like to have one port opened (80) and one port opened just for my IP (22). So I need to do:

sudo ufw allow to any port 80
sudo ufw allow from MY_IP_ADDRESS to any port 22

and that’s all.

Now turn on the firewall:

sudo ufw enable

and check everything:

sudo ufw status

More commands and informations related to UFW:
http://ubuntuforums.org/showthread.php?t=823741

Everything via twitter API.

We will use only one method from this API, so we need to read “Twitter REST API Method: followers ids” section in this documentation. You can find this section here.

Let’s fun.

We will download amount of followers of @develway. That’s an account of a website for IT specialists and programmers.

Open *.py file (for example main/views.py) and add there a new method:

def downloadTwitterFollowers(request):
	import urllib2, urllib
    from django.utils import simplejson

	request = urllib2.Request('http://twitter.com/followers/ids.json?screen_name=develway&cursor=-1')
	response = urllib2.urlopen(request)

	ids = response.read()
	ids = simplejson.loads(ids)

	followers = len(ids['ids'])

	return HttpResponse('Amount of followers: ' + str(followers))

Now add new view to your urls.py…

Open the urls.py file and add there something like:

(r'^download-twitter-followers/$', 'ourProject.main.views.downloadTwitterFollowers'),

Save it and try to run http://yourdomain.com/download-twitter-followers/ in your web browser.

Easy, isn’t it?

Everybody knows what is twitter, so I won’t describe it here. I just want to give you a link to official documantation of twitter’s API: http://apiwiki.twitter.com/Twitter-API-Documentation.

We will use only one method from this API, so we need to read “Twitter REST API Method: statuses/update” section in this documentation. You can find this section here.

I prefer JSON format, than XML in communication with any API.

So, let’s fun.

Open *.py file with your model and change “save()” method:

def save(self):
    if not self.id:
        import urllib2, urllib

        twitter_status = self.title + ' http://our_domain_name/' + str(self.slug)

        request = urllib2.Request('http://twitter.com/statuses/update.json')
        request.headers['Authorization'] = 'Basic %s' % ( base64.b64encode('TWITTER_USERNAME:TWITTER_PASSWORD'),)
        request.data = urllib.urlencode({'status': twitter_status})
        response = urllib2.urlopen(request)

and that’s all.

After you will add new item to this model – message with title of an item (self.title) and link to this item (self.slug) will be added to your account on twitter.com.

Easy, isnt’t it?

Btw. Yes. I know that base64 is not as safe, as oAuth. However this way is much faster to implement.

First of all… full documentation of blip.pl API is available here: http://blip.pl/api-0.02.html

It’s in Polish, however if you want to integrate your app with this service you propably know Polish (if not – notice, that it works as a standard REST + JSON compilation, so it shouldn’t be a problem to implement this functionality even for someone, who doesn’t Polish).

Ok, stop talking, start coding…

Open *.py file with your model and change “save()” method:

def save(self):
    if not self.id:
        if self.blip_message:
	        import httplib, base64
	        from django.utils import simplejson

  	        http_url = 'http://api.blip.pl/updates'
                API_HEADERS = {
	            'Content-Type' : 'application/json',
	            'X-Blip-api' : '0.02',
	            'User-Agent' : 'Karol Zielinski blip API',
	            'Authorization' : 'Basic %s' % (base64.b64encode('BLIP.PL_USERNAME:BLIP.PL_PASSWORD'))
	        }

	        update = {}
	        update['body'] = self.blip_message

	        post_params = simplejson.dumps(update)

	        connection = httplib.HTTPConnection('api.blip.pl')
	        connection.request('POST', http_url, headers=API_HEADERS, body=post_params)

	        response = connection.getresponse()
	        headers = response.getheaders()
	        status = response.status
	        resp_data = response.read()

and that’s all.

After you will add new item to this model – message from attribute blip_message will be added to your account on blip.pl.

Easy, isnt’t it?

Answer is really simple: by checking primary key.

From django’s documentation:

Specifically, when you call save(), Django follows this algorithm:

• If the object’s primary key attribute is set to a value that evaluates to True (i.e., a value other than None or the empty string), Django executes a SELECT query to determine whether a record with the given primary key already exists.
• If the record with the given primary key does already exist, Django executes an UPDATE query.
• If the object’s primary key attribute is not set, or if it’s set but a record doesn’t exist, Django executes an INSERT.

So… we just need to check primary key.

My save() method looks like:

def save(self):
    if not self.id:
        # what I want to do if it's INSERT statement
    else:
        # what I want to do if it's UPDATE statement

    super(MyObject, self).save()

Notice: “super(MyObject, self).save()” has to be called after checking is it INSERT or UPDATE.