# file: dto.py

"""
Data Transfer Objects
"""

__all__ = ['User', 'Profile', 'create_user', 'create_profile', 'NAMESPACE']

# AMF Namespace used for data transfer object crossing over into the
# Flex/ActionScript world.
NAMESPACE = 'org.iplant.usermanagement.model.dto'

class User(object):
    """Models user values and is mapped as a data transfer object."""

    def __init__(self, username=None, email=None, password=None, profile=None,
                 salt=None):
        """Create an instance of the user data transfer object."""
        self.username = username
        self.email = email
        self.password = password
        self.profile = profile
        self.salt = salt

    def __eq__(self, other):
        """Define equality for users objects."""
        return self.username == other.username

    def __ne__(self, other):
        """Define inequality for user objects."""
        return not self.__eq__(other)


class Profile(object):
    """Models user profile information and is mapped as a data transfer
    object."""

    def __init__(self, first_name=None, last_name=None, institution=None):
        """Create an instance of the user profile data transfer object."""
        self.first_name = first_name
        self.last_name = last_name
        self.institution = institution


def create_user(user):
    """Create a User data transfer object from a User domain object.

    ``user``: if the argument is a data transfer object, this will function as
    a copy-constructor or clone method."""
    return User(user.username, user.email, user.password,
                create_profile(user.profile), user.salt)

def create_profile(profile):
    """Create a Profile data transfer object from a Profile domain object.

    ``profile``: if the argument is a data transfer object, this will function
    as a copy-constructor or clone method."""
    if profile is not None:
        return Profile(profile.first_name, profile.last_name,
                       profile.institution)
    else:
        return None

# file: mappers.py

"""
Define mappings from Domain Objects to Relational Database tables
"""

import pyamf
from pyamf import amf3
from sqlalchemy import orm
from usermgmt import domain, dto, tables

__all__ = ['setup', 'register_classes']

def setup():
    """Perform mapping setup for all domain objects to database tables"""
    orm.mapper(domain.User, tables.users, properties={
                'profile': orm.relation(domain.Profile,
                                        remote_side=[tables.profiles.c.id])})
    orm.mapper(domain.Profile, tables.profiles)

def register_classes():
    """Register data transfer objects to be used with messaging via PyAMF."""
    # set this so returned objects and arrays are bindable
    amf3.user_proxies_default = True
    # register domain objects that will be used with PyAMF
    pyamf.register_class(dto.Profile, '%s.Profile' % dto.NAMESPACE)
    pyamf.register_class(dto.User, '%s.User' % dto.NAMESPACE)