Join us at elektro:camp(<<2013.11>>) on 1+2 November 2013 at the StayOkay on the island Texel in the Netherlands!
Elektro:Camp is a participative workshop on Smart Metering, Smart Home, Smart Grid and Smart Ideas, in a
BarCamp style. (This is the 7th meeting of the open
source metering community.)
This time it is an all in arrangement, including sleeping accommodation in a hostel. For all the details,
travel information and costs see ektro-camp.de.
So you’re an independent Ruby developer with all the benefits you can think of.
With a lot of freedom. You work from home, you choose your own assignments, no
adjustment to a corporate culture, no managers to deal with etc.
But what about the downsides? No feedback on your work (from which you can learn), not a
lot of interaction with other programmers, not easy to consult a colleague on technical or other matters
and sometimes the workload is too much or too little.
So that leads me to the question: is there a form of working together without losing the valued benefits
of an independent developer. Somehow it must be possible to work together on a commercial basis as
individual developers more or less the same way we contribute to an Open Source project.
Living in a community (on an island) where we have a lot of benefit of existing co-operatives (for transport
by ferry and the delivery of energy), I of course thought of a
formal co-operative as an organization form for working as an collective.
Benefits:
Acquisition as a collective.
More flexible in workload. No more running or standing still. A more even distribution of the
workload.
Higher occupation on average.
Share knowledge and practical experience.
Learn by working together on the same project.
More change to do what you do best (specialties).
More change to make some money as a part time ruby developer.
The co-op will also offer the customer more continuity. A customer will value the lower dependence on a
single developer or a small company.
Release early, release often:
With this proposal I like to research the possibility of working together in a formal co-operative. Of
course I don’t have all the answers (yet), but I’m hoping that we can together answer a lot of
them.
Let me know what you think. I made a first draft of a proposal on Github with the
following subjects:
Definitions
Objectives
Rights
Responsibilities
Obligations
Financials
Board
Workflow
Examples
I like to invite you to join this discussion and make your contribution
by forking and submitting your patches!
Combine your work with nature on Texel. Balance your work and personal life! This is the
change to do your regular work and to combine it with a holiday feeling.
Go out for a few days or a week with your partner/husband/wife (and/or your kids). During the day you can
use a work spot with Internet access and enjoy the beauty of the Island.
In return it would be nice to do a pair
programming session (if you do Ruby and/or Ruby on Rails). Contact me via frank-at-dovadi.com or 06-49416406 if
you’re interested.
iDEAL is a set of standards developed to facilitate online payments through the online banking
applications that most Dutch banks provide.
If a consumer already has online banking with ABNAMRO, Fortis, ING/Postbank, Rabobank, or SNS Bank, they can make payments using iDEAL in a way that they are already familiar
with.
In order to use iDEAL you will need to get an iDEAL merchant account from your bank. Every bank offers
âcomplete paymentâ services, which can obfuscate the right choice. The payment product that
you will want to get, in order to use this gateway class, is a bare bones iDEAL account.
Messages to, and from, the acquirer, are all signed in order to prove their authenticity. This means that
you will have to have a certificate to sign your messages going to the acquirer and you will need
to have the certificate of the acquirer to verify its signed messages.
The latter can be downloaded from your acquirer after registration. The former, however, can be a
certificate signed by a CA authority or a self-signed certificate.
To create a self-signed certificate follow these steps:
Substitute _the_passphrase__ with your own passphrase.
With the ING bank you upload your private certificate with your iDEAL
Dashboard. Be aware that there are two dashboards, one dashboard for the test environment and
one dashboard for the production
environment!
You can run the tests from this gem with (inside the active_merchant_ideal directory):
1
raketest
Run the remote tests
Create .active_merchant directory in your own home directory
Copy test/fixtures.yml to the .active_merchant directory
Fill in your own merchant id, passphrase and the correct locations to your private key and
certificates.
For running the seven prescribed remote test transactions (ING bank) which are needed to activate the iDEAL account use
1
raketest:remote
Example (Rails)
First configure the gateway
Put the following code in, for instance, an initializer:
12345678
IdealGateway.live_url='https://ideal.secure-ing.com:443/ideal/iDeal'IdealGateway.merchant_id='00123456789'IdealGateway.passphrase='the_private_key_passphrase'# CERTIFICATE_ROOT points to a directory where the key and certificates are locatedIdealGateway.private_key_file=File.join(CERTIFICATE_ROOT,'private_key.pem')IdealGateway.private_certificate_file=File.join(CERTIFICATE_ROOT,'private_certificate.cer')IdealGateway.ideal_certificate_file=File.join(CERTIFICATE_ROOT,'ideal.cer')
View
Give the consumer a list of available issuer options:
classPurchasesController<ActionController::Basedefcreate# â?¬10.00 in cents.purchase=@user.purchases.build(:price=>1000)# We want an id for the URL.purchase.save(false)purchase_options={:issuer_id=>params[:purchase][:issuer_id],:order_id=>purchase.id,:return_url=>purchase_url(purchase),:description=>'A Dutch windmill'}# Save the purchase instance so that the consumer# can return to its resource url to finish the transaction.purchase.update_attributes!(purchase_options)gateway=ActiveMerchant::Billing::IdealGateway.newtransaction_response=gateway.setup_purchase(purchase.price,purchase_options)iftransaction_response.success?# Store the transaction_id that the acquirer# has created to identify the transaction.purchase.update_attributes!(:transaction_id=>transaction_response.transaction_id)# Redirect the consumer to the issuerâ??s payment page.redirect_totransaction_response.service_urlendendend
After the consumer is done with the payment she will be redirected to the :return_url.
It’s now your responsibility as merchant to check if the payment has been made:
1234567891011
classPurchasesController<ActionController::Basedefshowgateway=ActiveMerchant::Billing::IdealGateway.newtransaction_status=gateway.capture(@purchase.transaction_id)iftransaction_status.success?@purchase.update_attributes!(:paid=>true)flash[:notice]="Congratulations, you are now the proud owner of a Dutch windmill!"endendend
History
In 2006 an iDEAL payment library was written in Ruby for a web shop build in Rails for selling mobile
phone credits. It was basically a translation of the PHP example given by the
iDEAL organization (see iDEAL Advanced Integration Manual PHP). Is was released
as the ideal-on-rails plugin.
In 2007 this code was refactored as a patch for the ActiveMerchant library, this was mainly done by Fingertips for a client project. This patch was never accepted due to
the fact it was too different (and maybe too obscure) from the ‘normal’ credit card gateways.
In 2009 Fingertips forked the ActiveMerchant library and added an iDEAL gateway (presumable based on the
first ActiveMerchant patch) to a new ideal branch.
In 2010 this code was extracted and converted into a separate gem, so it can be more easily used in
combination with the latest version of ActiveMerchant. This library is just an extraction, nothing more
and nothing less. There are no fundamental changes between the code from the ideal branch and the code of
this gem.
My first little gem has_attributes_from for merging
attributes from one ActiveRecord Class to another individual STI subclass.
So why, do we want to do that, you might ask? Well, I was working on a rails project where clients take
care of the administration (planning and billing) for child daycare centres. In this project I have all
kinds of people objects, like a child, a contactperson, a father, mother, caretaker etc. etc. So, the
ideal casus for a Single Table Inheritance implementation. So I implemented a ‘classic’ Person
Class as follows:
However, I like to add certain extra attributes to a Child, like for example its nickname and information
about its allergies. So I introduce another class which I call ChildDetail. Of course I can add these
attributes to the people table as well, but in this project I had several more fields to add and some
other attributes for a father., which would lead to a lot of columns for only two subclasses (of the five
in total).
123456
create_table:child_details,:force=>truedo|t|t.string:nicknamet.string:vaccinationt.string:allergyt.integer:child_id#belongs_to relationship with Childend
This is not really the way I want it, I like to ask directly for the nickname of a child without going
through a child_detail. So to solve this ‘problem’ I wrote the has_attributes_from gem. Add
the following line to your environment.rb file
With has_attributes_from the
attributes from ChidDetail are merged with Child. A child object acts as one single object and I can even
do validation on nickname directly (or the other attributes from ChildDetail).
123456789101112
child=Child.first=>#<Child id: 2, firstname: "William", lastname: "Oxener", type: "Child", social_security_number: "123456789", gender: "m", date_of_birth: "2005-12-02 00:00:00">putschild.nickname=>"Bill"child.update_attributes(:nickname=>nil)=>falsechild.errors.full_messages=>["Nickname must be present"]child.nickname="Daam"=>"Daam"child.save=>true
I think this is much nicer, besides it was fun to make and a good exercise to put some Ruby meta
programming into practice.