diff -r 31114e40178d -r 0a5eb5aac0be iro/model/schema.py
--- a/iro/model/schema.py	Thu Mar 29 13:46:37 2012 +0200
+++ b/iro/model/schema.py	Thu Mar 29 16:27:40 2012 +0200
@@ -17,21 +17,32 @@
 Base = declarative_base()
 
 class Userright(Base):
-    """Über welche Routen darf ein Benutzer Daten verschicken und welches sind die Standardrouten (<em>default!=None</em>) für den Benuter. Geordnert werden die Standardrouten nach default."""
+    """Allowed offers for one user. Default routes are sorted by **default** value."""
     __tablename__ = 'userright'
     user_name = Column('user', String(100), ForeignKey('apiuser.name'), primary_key=True)
+    """username"""
     offer_name = Column('offer', String(100), ForeignKey('offer.name'), primary_key=True)
+    """offername"""
     default = Column(Integer)
+    """sorting defaults routes with this value"""
     offer = relationship("Offer")
+    """connected :class:`Offer` object"""
     user = relationship("User")
+    """connected :class:`User` object"""
 
     def __init__(self, offer, default=None):
+        """Constructor of Userright class.
+
+        :param `Offer` offer: a offer object
+        :param integer default: default value
+        """
+
         self.offer = offer
         self.default = default
 
     @property
     def bill(self):
-        '''getting a list of unbilled messages grouped by Job.info'''
+        """returns a list of unbilled messages grouped by Job.info"""
         query = [ func.count(Message.id).label('anz'),      # anz of messages
                   func.sum(Message.price).label("price"),   # price of the messages
                   Job.info.label('info'),                   # info tag
@@ -45,88 +56,177 @@
         return object_session(self).query(*query).filter(and_(*filters)).group_by(Job.info)
 
 class Offer(Base):
-    """Alle Routen über die SMS, Faxe und Mails verschickt werden könnnen. <em>provider</em>, <em>typ</em> und <em>route</em> werden verwendet, um die entsprechenden Zugangsdaten laden zu können."""
+    """All possible Offers over a Message can be sended. **provider**, **typ** and **route** are used to get the data form configuration file."""
     __tablename__ = "offer"
     name = Column(String(100), primary_key=True)
+    """name of the offer"""
     provider = Column(String(100))
+    """provider name"""
     route = Column(String(100))
+    """route of the provider"""
     typ = Column(String(100))
+    """typ of message"""
+    
+    def __init__(self, **kwargs):
+        Base.__init__(self,**kwargs)
   
     @classmethod
     def get(cls, session, provider, route, typ):
+        """returns a Offer object."""
         return session.query(cls).filter(and_(cls.provider==provider, cls.route==route, cls.typ==typ)).first()
 
     @classmethod
     def routes(cls, session, typ):
+        """returns a query object of all possible offers.
+        
+        :param string typ: get all offers that support this typ
+        """
         return session.query(cls).filter_by(typ=typ)
 
     @classmethod
     def typs(cls, session):
+        """returns a list of all possible types.
+        """
         return session.query(cls.typ).distinct()
 
     @classmethod
     def providers(cls, session, typ):
+        """returns a list of all possible providers.
+        
+        :param string typ: get all providers that support this typ
+        """
         return session.query(cls.provider).filter_by(typ=typ).distinct()
 
 class Message(Base):
-    """Wenn ein Vorgang von Iro Kosten erzeugt hat wird eine neue Zeile eingefügt. Solange nicht bezahlt wurde ist <em>isBilled=0</em>."""
+    """A message that has created costs.
+    
+    **isBilled** is False since the bill is paid.
+    """
     __tablename__ = "message"
     id = Column(Integer, Sequence('message_id_seq'), primary_key=True)
+    """primary key of the message"""
+
     recipient = Column(String(100))
+    """string representation of the recipient"""
+    
     isBilled = Column(Boolean)
+    """is bill paid?"""
+
     date = Column(DateTime)
+    """date of sending the message"""
+
     price = Column(Numeric(8,4))
+    """price of sending the message"""
+
     count = Column(Integer)
+    """Count of sended messages"""
     exID = Column(String(100))
+    """external API id """
+
     job_id = Column("job", String(40), ForeignKey('job.id'))
+    """id of the connected job"""
     job = relationship("Job", backref=backref('messages'))
+    """connected :class:`Job` object"""
+    
     offer_id = Column("offer",String(100), ForeignKey('offer.name'))
+    """sended message over this offer woth ithe offer.name"""
+
     offer = relationship("Offer", backref=backref('messages'))
+    """connected :class:`Offer` object"""
+    
+    def __init__(self, **kwargs):
+        Base.__init__(self,**kwargs)
 
 
 class Job(Base):
-    """Ein kompletter Auftrag, der an Iro zum verschicken übergeben wird. Status zeigt den generellen Status des Auftrages an (<em>init</em>, <em>started</em>, <em>sending</em>, <em>sended</em> oder <em>error</em>). <em>info</em> wird verwendet um dem Benutzer eine Möglickeit zu geben verschiede Auftragsgruppen zu erstellen."""
+    """A complete Job.
+
+    - **status** show the status of the job (``init``, ``started``, ``sending``, ``sended`` or ``error``). 
+    - **info** is used to make it possible to create diffrent billing groups for user.
+    """
     __tablename__ = "job"
     id = Column(Integer, Sequence('job_id_seq'), primary_key=True)
+    """job id"""
     info = Column(String(100))
+    """job info, for billing porpuse"""
     status = Column(Enum("init","started","sending","sended","error"))
+    """status of a job"""
     user_id = Column("user", String(100), ForeignKey('apiuser.name'))
+    """connected user id"""
+
     user = relationship("User", backref=backref('jobs'))
+    """connected :class:`User` object"""
+    
+    def __init__(self, **kwargs):
+        """
+        .. automethod:: __repr__
+        """
+        Base.__init__(self,**kwargs)
 
     @property
     def extend(self):
+        """returns the connected :class:`iro.model.job.ExJob`"""
         return job.exJobs[self.id]
 
 
     def __repr__(self):
+        """string representation of the Job class.
+
+        :return: ``<Job('id' ,'info', 'status', 'user_id')>``
+        """
         try:
-            return "<Job('%s','%s','%s','%s')>"%(self.id,self.info, self.status, self.user_id)
+            return "<Job('%s' ,'%s', '%s', '%s')>"%(self.id,self.info, self.status, self.user_id)
         except DetachedInstanceError:
             return Base.__repr__(self)
 
     @classmethod
     def get(cls, session, id):
+        """returns a job object from a given id"""
         return session.query(cls).filter_by(id=id).first()
 
 class User(Base):
-    """Die Benutzerdatenbank von Iro. <em>ng_kunde</em> ist der verknüpfte netzguerilla.net Benutzer, der die Rechnung zahlt."""
+    """One user in iro"""
     __tablename__ = "apiuser"
+    
     name = Column(String(100), primary_key=True)
+    """Username"""
+    
     ng_kunde = Column(Integer)
+    """Connection to the netzguerilla userdatabase"""
+
     apikey = Column(String(50),unique=True)
+    """apikey only [0-9a-f]"""
+    
     rights = relationship('Userright')
+    """all allowed offers to send with."""
+
     def __init__(self, name, apikey):
+        """Constructor of User class.
+
+        :param string name: username
+        :param string apikey: apikey for the user
+
+        .. automethod:: __repr__
+        """
         self.name=name
         self.apikey=apikey
 
     def __repr__(self):
+        """string representation of the user class.
+
+        :return: ``<User('name', 'apikey')>``
+        """
         try:
             return "<User('%s','%s')>"%(self.name,self.apikey)
         except DetachedInstanceError:
             return Base.__repr__(self)
     
     def routes(self, typ, default = False):
-        '''returns a query object to get all possible routes for a given typ'''
+        """returns a query object to get all possible routes for a given typ
+
+        :param string typ: the typ
+        :param boolean default: use only default routes
+        """
         filters=[User.name == self.name,
                 Offer.typ == typ, 
                 ]
@@ -135,7 +235,11 @@
         return object_session(self).query(Userright.offer_name).join(Offer,User).filter(and_(*filters)).order_by(Userright.default)
    
     def providers(self, typ, default = False):
-        '''return a query object for all possible providers for a given typ'''
+        """return a query object for all possible providers for a given typ
+
+        :param string typ: the typ
+        :param boolean default: use only default routes
+        """
         filters=[User.name == self.name,
                 Offer.typ == typ, 
                 ]
@@ -144,8 +248,14 @@
         return object_session(self).query(Offer.provider).join(Userright,User).filter(and_(*filters))
 
     def has_right(self, typ, offer_name = None, provider = None, route = None):
-        '''returns offer_name, if the user is allowed to use offer otherwise None
-           ->raise sqlalchemy.orm.exc.MultipleResultsFound if not a single offer match'''
+        """if a user has the right to use a offer, provider e. al. (arguments are and connected).
+        
+        :param string typ: the typ
+        :param string offer_name: offer name
+        :param string provider: provider name
+        :param string route: a route name
+        :return: offer_name or  None (not allwoed)
+        :raises: :class:`sqlalchemy.orm.exc.MultipleResultsFound` if not a single offer match"""
         filters=[User.name == self.name,
                 Offer.typ == typ, 
                 ]
@@ -159,6 +269,12 @@
         return object_session(self).query(Userright.offer_name).join(Offer,User).filter(and_(*filters)).scalar()
 
     def job(self, id):
+        """returns a job object.
+
+        :param integer id: id of a Job
+        :return: :class:`Job`
+        :raises: :exc:`iro.error.JobNotFound`
+        """
         job = object_session(self).query(Job).join(User).filter(and_(User.name == self.name, Job.id==id)).first()
         if job is None:
             raise JobNotFound()