company.rs

use orm::Error;
use orm::model::{Deserialize, Field, Model, Serialize};
use orm_ext::{
    CreatedAt, Timestamps, ValidateLength, ValidatePresence, ValidateUniqueness, ValidateZipCode
};
use rand::{thread_rng, Rng};
use serde::ser::{MapVisitor, Serializer};
use values::{DateTime, Password};

orm_model! {
    table = "companies";
    fields = {
        *id: i64,
        name: String,
        email: Option<String>,
        phone: String,
        owner_admin_id: Option<i64>,
        zip_code: String,
        created_at: DateTime,
        updated_at: DateTime,
    };
    extensions = {
        ValidateLength<CompanyName, String> = ValidateLength::new(2..256),
        ValidateLength<CompanyEmail, Option<String>> = ValidateLength::new(3..256),
        ValidateLength<CompanyPhone, String> = ValidateLength::new(10..31),
        ValidatePresence<CompanyZipCode, String> = ValidatePresence::new(),
        ValidateZipCode<CompanyZipCode> = ValidateZipCode::new(),
        Timestamps<CompanyCreatedAt, CompanyUpdatedAt> = Timestamps::new(),
    };

    pub struct Company;
}

pub struct UnpackCompany;

impl Deserialize<Company> for UnpackCompany {
    fn deserialize(map: &::params::Map, admin: &mut Company) -> Result<(), Error> {
        try!(CompanyName::deserialize_permit(map, admin));
        try!(CompanyEmail::deserialize_permit(map, admin));
        try!(CompanyPhone::deserialize_permit(map, admin));
        try!(CompanyZipCode::deserialize_permit(map, admin));
        Ok(())
    }
}

pub struct PackCompany;

impl Serialize<Company> for PackCompany {
    fn serialize<S: Serializer>(serializer: &mut S, company: &Company) -> Result<(), S::Error> {
        try!(CompanyName::serialize(serializer, company));
        try!(CompanyOwnerAdminId::serialize(serializer, company));
        try!(CompanyEmail::serialize(serializer, company));
        try!(CompanyPhone::serialize(serializer, company));
        try!(CompanyZipCode::serialize(serializer, company));
        Ok(())
    }
}

orm_model! {
    table = "admins";
    fields = {
        *id: i64,
        company_id: i64,
        name: String,
        email: String,
        password: Password,
        password_reset_token: Option<String>,
        created_at: DateTime,
        updated_at: DateTime
    };
    extensions = {
        ValidateLength<AdminName, String> = ValidateLength::new(2..256),
        ValidateLength<AdminEmail, String> = ValidateLength::new(3..256),
        ValidatePresence<AdminPassword, Password> = ValidatePresence::new(),
        ValidateUniqueness<AdminEmail, String> = ValidateUniqueness::new(),
        Timestamps<AdminCreatedAt, AdminUpdatedAt> = Timestamps::new(),
    };

    pub struct Admin;
}

impl Admin {
    pub fn generate_reset_password_token(&mut self) {
        self.set_password_reset_token(Some(thread_rng().gen_ascii_chars().take(32).collect()));
    }
}

pub struct UnpackAdmin;

impl Deserialize<Admin> for UnpackAdmin {
    fn deserialize(map: &::params::Map, admin: &mut Admin) -> Result<(), Error> {
        try!(AdminName::deserialize_permit(map, admin));
        try!(AdminEmail::deserialize_permit(map, admin));
        try!(AdminPassword::deserialize_permit(map, admin));
        Ok(())
    }
}

pub struct UnpackLogin;

impl Deserialize<Admin> for UnpackLogin {
    fn deserialize(map: &::params::Map, admin: &mut Admin) -> Result<(), Error> {
        try!(AdminEmail::deserialize_require(map, admin));
        try!(AdminPassword::deserialize_require(map, admin));
        Ok(())
    }
}

pub struct PackAdmin;

impl Serialize<Admin> for PackAdmin {
    fn serialize<S: Serializer>(serializer: &mut S, admin: &Admin) -> Result<(), S::Error> {
        try!(AdminId::serialize(serializer, admin));
        try!(AdminName::serialize(serializer, admin));
        try!(AdminEmail::serialize(serializer, admin));
        Ok(())
    }
}

pub struct AdminCompanyMapVisitor<'a>(pub &'a Admin, pub &'a Company);

impl<'a> MapVisitor for AdminCompanyMapVisitor<'a> {
    fn visit<S: Serializer>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error> {
        try!(serializer.visit_map_elt("admin", self.0.serialize::<PackAdmin>()));
        try!(serializer.visit_map_elt("company", self.1.serialize::<PackCompany>()));
        Ok(None)
    }
}

orm_model! {
    table = "admin_sessions";
    fields = {
        *id: i64,
        admin_id: i64,
        key: String,
        created_at: DateTime,
    };
    extensions = {
        CreatedAt<AdminSessionCreatedAt> = CreatedAt::new(),
    };

    pub struct AdminSession;
}

impl AdminSession {
    fn after_initialize(&mut self) {
        if self.key_opt().is_none() {
            self.set_key(thread_rng().gen_ascii_chars().take(32).collect());
        }
    }
}