Adherent

Gem destiné à gérer les adhérents d’une association.

Les fonctionnalités actuelles du gem sont les suivantes :

Gestion des adhérents et de leurs coordonnées
gestion des adhésions pour chacun des adhérents
gestion des paiements effectués par les adhérents

A terme, le gem sera en mesure d’être intégré à l’application FaitesLesComptes qui est un logiciel de comptabilité. Mais il peut évidemment être utilisé pour tout autre programme qui gère des adhérents.

La notion d’adhérent est assez extensible; Le modèle utilisé s’appelle d’ailleurs Member (membre). Ce pourrait être des abonnés à une revue, des ayants droits d’un comité d’entreprise,…

Version

La version 0.2.x a été adaptée pour Rails 4.0 et bootstrap 3. Si vous utilisez Rails 3, prenez la dernière version 0.1, soit 0.1.10

Evolutions futures

Ce projet est en cours de développement.

N’hésitez pas à nous faire part de vos demandes éventuelles. Et surtout revenez voir régulièrement quelles fonctionnalités auraient été ajoutées

Nous devons également améliorer la couverture du gem par les tests.

Installation

Modifier le gemfile de votre application pour y ajouter gem ‘adherent’
puis bundle install
Le gem rattache les membres à un organism. Il faut donc avoir une table des organismes. Le plus simple étant de faire
```
rails g scaffold organism title:string
```
dans votre application principale
Copier les migrations du gem vers votre application avec la commande
```
rake adherent:install:migrations
```
Puis créer les tables avec
```
rake db:migrate
```
Il est nécessaire que le gem ait accès à l’organisme recherché lors d’un accès à ses tables. Il faut donc avoir une méthode qui instancie l’organisme dans votre ApplicationController. Par exemple
```
before_filter @organism = Organism.find(session[:organism] if session[:organism]
```
Ceci focntionne car le ApplicationController du gem hérite du ApplicationController de l’application principale dans laquelle il est utilisé.
dans le controller Organism, ajouter skip_before_filter :find_organism
Toujours dans le controller Organism, et dans la méthode show ajouter la ligne

session[:organism] = @organism.id 
Dès lors la session est initialisée et mise à jour

dès qu’on affiche un organisme. D’autres moyens sont évidemment possibles

Dans le modèle Organism de votre application, il faut rajouter la ligne
```
has_many :members, class_name:'Adherent::Member'
```
Monter le gem dans les routes en ajoutant la ligne
```
mount Adherent::Engine, at: "/adherent"
```

profitez en pour définir le root de votre application par exempe root to:‘organisms#index’ sans oublier d’effacer le fichier public/index.html

Alternative

Si vous utilisez ce gem pour une seule association, il n'est pas utile d'avoir un scaffold complet
Vous pouvez vous contenter d'un model Organism 
     rails g model Organism title:string
     rake db:migrate
Puis créer un organisme 
    Organism.create(title:'le nom de l association')
Mettre en place la variable d'instance pour alors se faire par 
   before_filter sont alors inutiles.
Les étapes 7 et 8 deviennent alors inutile.

Vérification du bon fonctionnement

Lancer le serveur par la commande rails s et aller sur localhost:3000 Vous devriez voir la page organism#index avec la mise en forme par défaut du scaffold de rails.

Créer un premier organisme, ce qui l’affichera, déclanchant l’action show qui initie session

Dès lors vous pouvez accéder aux fonctionnalités du gem par l’adresse localhost:3000/adherent

Utilisation

Il pourra être utile de faire un lien vers ce module dans la vue ‘Organism#show’ en rajoutant

link_to 'Adherent', adherent.members_path

Dans l’autre sens, lorsque vous êtes sur la liste des membres (des adhérents), un lien vers l’application principale est disponible

Le gem a été développé pour son utilisation avec un logiciel de comptabilité (github.com/comptasso/FaitesLesComptes).

La solution adoptée pour faire le lien entre l’application principale et le gem est l’utilisation d’un observer (note : une autre solution devra être trouvée pour Rails 4 qui a supprimé cette approche).

Nous montrons l’approche pour l’observation d’un payment mais vous pourriez vouloir observer autre chose (un nouveau membre, un renouvellement d’adhésion,…). Le principe sera la même.

Dans le dossier models de l’application principale, créer un dossier adherent puis un fichier payment_observer.rb

module Adherent
  class PaymentObserver < ::ActiveRecord::Observer

    def after_create(payment)
      # introduire ici ce que vous voulez enclencher lorsqu'un paiement est enregistré
    end
  end
end

Vous pouvez bien utiliser d’autre callbacks comme after_save, after_update. Voir la documentation de Rails sur les Observer

Dans le fichier config/application.rb de votre application, il faut activer l’observer. Décommenter la ligne config.active_record.observers = … et modifier là comme suit:

# Activate observers that should always be running.
config.active_record.observers = 'Adherent::PaymentObserver'

De nombreux autres utilisations sont possibles, par exemple l’envoi de mails aux adhérents ou l’édition de statistiques sur le renouvellement des adhésions. A vous alors de créer les controllers et vues faisant appel aux données des tables du gem Adherent.

Les modèles doivent être préfixés : Adherent::Member, Adherent::Adhesion, Adherent::Coord,…

Les tables elles mêmes sont “adherent_members”, “adherent_adhesions”,…

Des partials adherent_header et adherent_footer ont été mis en place dans le layout. On peut soit les masquer par un style, soit les surcharger dans l’application principale pour mieux intégrer les vues Adherent dans l’application principale.

License

Ce projet est sous sous licence MIT.