class Segment(db.Model):
__tablename__ = 'segment'
# Fields
segment_id = db.Column(db.Integer, primary_key = True)
created_at = db.Column(db.DateTime, nullable = False, server_default = func.now())
coordinate_origin = db.Column(db.Float)
coordinate_end = db.Column(db.Float)
# Methods
def __init__(self, segment_id, coordinate_origin, coordinate_end):
self.segment_id = segment_id
self.coordinate_origin = coordinate_origin
self.coordinate_end = coordinate_end
def __repr__(self):
return json.dumps(self.as_dict(), sort_keys = True, separators = (',', ':'))
def as_dict(self):
return {
"segment_id": self.segment_id,
"coordinate_origin": self.coordinate_origin,
"coordinate_end": self.coordinate_end,
"created_at": self.created_at.isoformat()
}
class Conveyancer(db.Model):
__tablename__ = 'conveyancer'
# Fields
conveyancer_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
x500_name = db.Column(db.String, unique=True, nullable=False)
company_name = db.Column(db.String, nullable=False)
# Methods
def __init__(self, x500_name_string, company_name):
self.x500_name = str(X500Name.from_string(x500_name_string))
self.company_name = company_name
def __repr__(self):
return json.dumps(self.as_dict(),
sort_keys=True,
separators=(',', ':'))
def as_dict(self):
return {
"conveyancer_id": self.conveyancer_id,
"x500": X500Name.from_string(self.x500_name).as_dict(),
"x500_string": str(X500Name.from_string(self.x500_name)),
"company_name": self.company_name
}
class PriceHistory(db.Model):
__tablename__ = 'price_history'
# Fields
title_number = db.Column(db.String,
db.ForeignKey('title.title_number'),
primary_key=True)
date = db.Column(db.DateTime,
nullable=False,
server_default=func.now(),
primary_key=True)
price_amount = db.Column(db.Integer, nullable=False)
price_currency = db.Column(db.String, nullable=False)
# Relationships
title = db.relationship("Title", back_populates="price_history")
# Methods
def __init__(self, title_number, price_amount, price_currency, date):
self.title_number = title_number.upper()
self.price_amount = price_amount
self.price_currency = price_currency
if date:
self.date = date
else:
self.date = datetime.utcnow()
def __repr__(self):
return json.dumps(self.as_dict(),
sort_keys=True,
separators=(',', ':'))
def as_dict(self):
return {
"amount": self.price_amount,
"currency_code": self.price_currency,
"date_iso": self.date.isoformat(),
"date": int(self.date.strftime('%s'))
}
class Charge(db.Model):
"""Class representation of a Charge."""
__tablename__ = 'charge'
# Fields
charge_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
charge_date = db.Column(db.DateTime,
nullable=False,
server_default=func.now())
charge_lender = db.Column(db.String, nullable=False)
charge_amount = db.Column(db.Float, nullable=False)
charge_currency_type = db.Column(db.String, nullable=False)
title_number = db.Column(db.String, db.ForeignKey('title.title_number'))
# restriction_id = db.Column(db.String, db.ForeignKey('restriction.restriction_id'), nullable=True)
# Relationships
title = db.relationship("Title", back_populates="charges")
restriction = db.relationship("Restriction",
back_populates="charge",
uselist=False)
# Methods
def __init__(self, charge_date, charge_lender, charge_amount,
charge_currency_type, title_number):
self.charge_date = datetime.now(
) # charge_date # TODO(parse to datetime)
if isinstance(charge_lender, dict):
self.charge_lender = str(X500Name.from_dict(charge_lender))
else:
self.charge_lender = str(X500Name.from_string(charge_lender))
self.charge_amount = float(charge_amount)
self.charge_currency_type = charge_currency_type.upper()
self.title_number = title_number
@staticmethod
def from_dict(dict_obj, title_number):
date = dict_obj['date']
if 'lender_string' in dict_obj:
lender = str(X500Name.from_string(dict_obj['lender_string']))
else:
lender = str(X500Name.from_dict(dict_obj['lender']))
amount = dict_obj['amount']
amount_currency_code = dict_obj.get('amount_currency_code')
return Charge(date, lender, amount, amount_currency_code, title_number)
def __repr__(self):
return json.dumps(self.as_dict(),
sort_keys=True,
separators=(',', ':'))
def as_dict(self):
return {
"date": self.charge_date.isoformat(),
"lender": X500Name.from_string(self.charge_lender).as_dict(),
"lender_string": str(X500Name.from_string(self.charge_lender)),
"amount": self.charge_amount,
"amount_currency_code": self.charge_currency_type
}
class Owner(db.Model):
__tablename__ = 'owner'
# Fields
identity = db.Column(db.String, primary_key=True)
forename = db.Column(db.String, nullable=False)
surname = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False, unique=True, index=True)
phone = db.Column(db.String, nullable=False)
owner_type = db.Column(db.String, nullable=False)
address_id = db.Column(db.Integer,
db.ForeignKey('address.address_id'),
nullable=False)
# Relationships
address = db.relationship("Address",
backref=db.backref('owner', lazy='dynamic'),
foreign_keys='Owner.address_id',
uselist=False)
# Methods
def __init__(self, identity, forename, surname, email, phone, owner_type,
address):
self.identity = identity
self.forename = forename
self.surname = surname
self.email = email.lower()
self.phone = phone
self.owner_type = owner_type
self.address = address
def __repr__(self):
return json.dumps(self.as_dict(),
sort_keys=True,
separators=(',', ':'))
def as_dict(self):
return {
"identity": self.identity,
"first_name": self.forename,
"last_name": self.surname,
"email_address": self.email,
"phone_number": self.phone,
"type": self.owner_type,
"address": self.address.as_dict()
}
class Address(db.Model):
__tablename__ = 'address'
# Fields
address_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
house_name_or_number = db.Column(db.String, nullable=False)
street_name = db.Column(db.String, nullable=False)
city = db.Column(db.String, nullable=False)
county = db.Column(db.String, nullable=False)
country = db.Column(db.String, nullable=False)
postcode = db.Column(db.String, nullable=False)
segment_id = db.Column(db.Integer, db.ForeignKey('segment.segment_id'), nullable=False)
# Relationships
segment = db.relationship("Segment", backref=db.backref("address", lazy='dynamic'),
foreign_keys='Address.segment_id', uselist=False)
# Methods
def __init__(self, house_name_number, street_name, city, county, country, postcode, segment):
self.house_name_or_number = house_name_number
self.street_name = street_name
self.city = city
self.county = county
self.country = country
self.postcode = postcode
self.segment = segment
def __repr__(self):
return json.dumps(self.as_dict(), sort_keys=True, separators=(',', ':'))
def as_dict(self):
return {
"house_name_number": self.house_name_or_number,
"street": self.street_name,
"town_city": self.city,
"county": self.county,
"country": self.country,
"postcode": self.postcode,
"segment": self.segment.as_dict()
}
class Address(db.Model):
__tablename__ = 'address'
# Fields
address_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
house_name_or_number = db.Column(db.String, nullable=False)
street_name = db.Column(db.String, nullable=False)
city = db.Column(db.String, nullable=False)
county = db.Column(db.String, nullable=False)
country = db.Column(db.String, nullable=False)
postcode = db.Column(db.String, nullable=False)
# Methods
def __init__(self, house_name_number, street_name, city, county, country,
postcode):
self.house_name_or_number = house_name_number
self.street_name = street_name
self.city = city
self.county = county
self.country = country
self.postcode = postcode
def __repr__(self):
return json.dumps(self.as_dict(),
sort_keys=True,
separators=(',', ':'))
def as_dict(self):
return {
"house_name_number": self.house_name_or_number,
"street": self.street_name,
"town_city": self.city,
"county": self.county,
"country": self.country,
"postcode": self.postcode
}
class Title(db.Model):
__tablename__ = 'title'
# Fields
title_number = db.Column(db.String, primary_key=True)
created_at = db.Column(db.DateTime, nullable=False, server_default=func.now())
updated_at = db.Column(db.DateTime, nullable=True)
lock = db.Column(db.DateTime, nullable=True)
owner_identity = db.Column(db.Integer, db.ForeignKey('owner.identity'), nullable=False)
address_id = db.Column(db.Integer,
db.ForeignKey('address.address_id', ondelete="CASCADE", onupdate="CASCADE"),
nullable=False)
# Relationships
owner = db.relationship("Owner", backref=db.backref('title', lazy='dynamic'),
foreign_keys='Title.owner_identity', uselist=False)
address = db.relationship("Address", backref=db.backref('title', lazy='dynamic'),
foreign_keys='Title.address_id', uselist=False, cascade="all")
# Methods
def __init__(self, title_number, owner, address):
self.title_number = title_number.upper()
self.created_at = datetime.utcnow()
self.owner = owner
self.address = address
def __repr__(self):
return json.dumps(self.as_dict(), sort_keys=True, separators=(',', ':'))
def as_dict(self):
return {
"title_number": self.title_number,
"owner": self.owner.as_dict(),
"address": self.address.as_dict(),
"created_at": self.created_at.isoformat(),
"updated_at": self.updated_at.isoformat() if self.updated_at else self.updated_at,
"locked_at": self.lock.isoformat() if self.lock else self.lock
}
class Title(db.Model):
__tablename__ = 'title'
# Fields
title_number = db.Column(db.String, primary_key=True)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=func.now())
updated_at = db.Column(db.DateTime, nullable=True)
lock = db.Column(db.DateTime, nullable=True)
owner_identity = db.Column(db.Integer,
db.ForeignKey('owner.identity'),
nullable=False)
address_id = db.Column(db.Integer,
db.ForeignKey('address.address_id',
ondelete="CASCADE",
onupdate="CASCADE"),
nullable=False)
# Relationships
owner = db.relationship("Owner",
backref=db.backref('title', lazy='dynamic'),
foreign_keys='Title.owner_identity',
uselist=False,
cascade="save-update")
address = db.relationship("Address",
backref=db.backref('title', lazy='dynamic'),
foreign_keys='Title.address_id',
uselist=False,
cascade="save-update")
price_history = db.relationship("PriceHistory",
back_populates="title",
cascade="all, delete-orphan")
restrictions = db.relationship("Restriction",
back_populates="title",
cascade="all, delete-orphan")
charges = db.relationship("Charge",
back_populates="title",
cascade="all, delete-orphan")
# Methods
def __init__(self, title_number, owner, address):
self.title_number = title_number.upper()
self.created_at = datetime.utcnow()
self.owner = owner
self.address = address
def __repr__(self):
return json.dumps(self.as_dict(),
sort_keys=True,
separators=(',', ':'))
def as_dict(self):
restrictions_dict = [r.as_dict() for r in self.restrictions]
charges_dict = []
for charge in self.charges:
if charge.restriction is None:
charges_dict.append(charge.as_dict())
restriction_consenting_parties_dict = []
for restriction in self.restrictions:
restriction_consenting_parties_dict.append(
X500Name.from_string(restriction.consenting_party).as_dict())
price_history_dict = [r.as_dict() for r in self.price_history]
return {
"title_number":
self.title_number,
"owner":
self.owner.as_dict(),
"address":
self.address.as_dict(),
"restrictions":
restrictions_dict,
"charges":
charges_dict,
"restriction_consenting_parties":
restriction_consenting_parties_dict,
"price_history":
price_history_dict,
"created_at":
self.created_at.isoformat(),
"updated_at":
self.updated_at.isoformat()
if self.updated_at else self.updated_at,
"locked_at":
self.lock.isoformat() if self.lock else self.lock
}
class Restriction(db.Model):
"""Class representation of a Restriction."""
__tablename__ = 'restriction'
# Fields
restriction_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
restriction_code = db.Column(db.String, nullable=False)
restriction_type = db.Column(db.String, nullable=False)
restriction_text = db.Column(db.String, nullable=False)
consenting_party = db.Column(db.String, nullable=False)
restriction_date = db.Column(db.DateTime,
nullable=False,
server_default=func.now())
title_number = db.Column(db.String, db.ForeignKey('title.title_number'))
charge_id = db.Column(db.Integer,
db.ForeignKey('charge.charge_id',
ondelete="CASCADE",
onupdate="CASCADE"),
nullable=True)
# Relationships
title = db.relationship("Title", back_populates="restrictions")
charge = db.relationship("Charge",
back_populates="restriction",
uselist=False)
# Methods
def __init__(self, date, restriction_code, restriction_type,
restriction_text, consenting_party, title_number):
self.restriction_code = restriction_code.upper()
self.restriction_type = restriction_type.upper()
self.restriction_text = restriction_text
if isinstance(consenting_party, dict):
self.consenting_party = str(X500Name.from_dict(consenting_party))
else:
self.consenting_party = str(X500Name.from_string(consenting_party))
self.restriction_date = datetime.now(
) # date, # TODO(parse to datetime)
self.title_number = title_number
@staticmethod
def from_dict(dict_obj, title_number):
r_code = dict_obj['restriction_id']
r_type = dict_obj['restriction_type']
r_text = dict_obj['restriction_text']
r_date = dict_obj['date']
if 'consenting_party_string' in dict_obj:
consenting_party = str(
X500Name.from_string(dict_obj['consenting_party_string']))
else:
consenting_party = str(
X500Name.from_dict(dict_obj['consenting_party']))
restriction = Restriction(r_date, r_code, r_type, r_text,
consenting_party, title_number)
if 'charge' in dict_obj and dict_obj['charge']:
restriction.charge = Charge.from_dict(dict_obj['charge'],
title_number)
return restriction
def __repr__(self):
return json.dumps(self.as_dict(),
sort_keys=True,
separators=(',', ':'))
def as_dict(self):
return {
"restriction_id":
self.restriction_code,
"restriction_type":
self.restriction_type,
"restriction_text":
self.restriction_text,
"consenting_party":
X500Name.from_string(self.consenting_party).as_dict(),
"consenting_party_string":
str(X500Name.from_string(self.consenting_party)),
"date":
self.restriction_date.isoformat(),
"charge":
self.charge.as_dict() if self.charge else None
}
