"""
Code to demonstrate serialization/deserialization
from xmltrampnode to SA ORM.

Shows example for both serialization and deserialization.
"""

import os
import xmltramp
from sqlalchemy import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import mapper, relation, create_session, scoped_session
from sqlalchemy.orm import sessionmaker

DB = 'xmltramp.sqlite'

#For testing we always delete the DB :)
try:
    os.remove(DB)
except OSError, e:
    pass

metadata = MetaData()

class User(object):

    def __str__(self):
        return self.username

user_table = Table('user', metadata,
        Column('id', Integer, primary_key=True),
        Column('username', CHAR(length=25)),
        Column('address_id', Integer, ForeignKey('address.id')))

class Address(object):

    def __str__(self):
        return self.address

address_table = Table('address', metadata,
        Column('id', Integer, primary_key=True),
        Column('address', CHAR(length=25)))

mapper(User, user_table,
        properties={
            'address':relation(Address, uselist=False, lazy=False),
            })
mapper(Address, address_table)

engine = create_engine('sqlite:///%s' % DB, echo=False)
metadata.bind = engine
Session = sessionmaker()
metadata.create_all(engine)

print("DB created")

#XML to be tested.
xml = """
<xml>
  <user>
    <data>
        <id>1</id>
        <username>Ritesh</username>
        <address_id>1</address_id>
    </data>
    <address>
        <id>1</id>
        <address>12330 Stowe Drive</address>
    </address>
  </user>
</xml>
"""

def deserialize(orm, xmltrampnode):
    """
    Simple method that reads all attributes
    from a xmltramp node and assigns its value
    to orm property.

    :returns: The original ORM.

    >>> user = User()
    >>> deserialize(user, doc.user)
    """
    for column in orm.c:
        setattr(orm, column.name, 
                str(getattr(xmltrampnode, column.name)))
    return orm

def serialize(orm, xmltrampnode):
    """
    Simple method that reads an ORM
    and serializes all the column as element
    node to the node object passed
    """
    for column in orm.c:
        xmltrampnode[column.name] = str(getattr(orm, column.name))

    return orm

session = Session(bind=engine)

session.begin()

doc = xmltramp.parse(xml)

user = deserialize(User(), doc.user.data)
user.address = deserialize(Address(), doc.user.address)

#Bunch of unittest.
assert user.id == str(doc.user.data.id)
assert user.username == str(doc.user.data.username)
assert user.address_id == str(doc.user.data.address_id)

session.save_or_update(user)

session.commit()

#Unittest to make sure that the ORM
#was actually saved.
user = session.query(User).one()

assert str(user) == str(doc.user.data.username)
assert str(user.address) == str(doc.user.address.address)

#Test serialization.
output_xml = """
<xml>
  <user>
    <data>
    </data>
    <address>
    </address>
  </user>
</xml>
"""

output = xmltramp.parse(output_xml)
user = serialize(user, output.user.data)
address = serialize(user.address, output.user.address)

assert output.__repr__(True) == doc.__repr__(True)

print("Everything seems to be successful...")