class Color(db.Model):
"""
An object respresenting an items color.
:param id: the database key
:param name: the name of the color
"""
__tablename__ = 'colors'
id: str = db.Column(db.Integer, primary_key=True)
name: str = db.Column(db.String, nullable=False)
def __init__(self, name: str):
"""
Initialize a color object.
All colors are to have "title" capitalization.
(This Is An Example Of Title Capitalization)
:param name: the name of the color
:type name: str
"""
self.name = name.lower().strip().title()
def __lt__(self, other):
return self.name < other.name
class Note(db.Model):
"""
A note for a Car
:param created_date: when the note was created
:type created_date: datetime
:param text: the body of the note
:type text: str
:param car_id: the id of the car that the note's to be added to
:type car_id: int
"""
__tablename__ = 'notes'
id: int = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime,
default=datetime.datetime.now,
index=True)
text: str = db.Column(db.String, unique=True, nullable=False)
car_id: int = db.Column(db.Integer, db.ForeignKey('cars.id'))
def __init__(self, text: str):
"""Initiates a Note object with a text body"""
self.text = text
def __lt__(self, other):
return str(self) < str(other)
def __repr__(self):
return f'{self.text}'
class TravelDay(db.Model):
__tablename__ = 'travel_days'
# TODO: needs work
id: int = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_date = db.Column(db.DateTime, default=datetime.now, index=True)
travel_id: int = db.Column(db.Integer, db.ForeignKey('travels.id'))
date = db.Column(db.Date, nullable=False)
starting_point_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
starting_point = db.relationship('Location',
foreign_keys=[starting_point_id])
ending_point_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
ending_point = db.relationship('Location', foreign_keys=[ending_point_id])
route = db.Column(db.String, index=True)
mode = db.Column(db.String, index=True)
def __init__(self, date: str, starting_point: str, ending_point: str,
route: str, mode: str):
self.date = datetime.strptime(date, '%Y-%m-%d')
self.starting_point_id = location_services.get_id_from_name(
starting_point)
self.ending_point_id = location_services.get_id_from_name(ending_point)
self.route = route
self.mode = mode
def __lt__(self, other):
return self.date < other.date
def __repr__(self):
return f'{str(self.date)} {self.starting_point} {self.ending_point} {self.route} {self.mode}'
class TravelFile(db.Model):
__tablename__ = 'travel_files'
id: str = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.now)
name: str = db.Column(db.String, unique=True, nullable=False, index=True)
travel_id: int = db.Column(db.Integer, db.ForeignKey('travels.id'))
def __init__(self, name: str):
self.name = name
def __lt__(self, other):
return self.name < other.name
def __repr__(self):
return self.name
class Location(db.Model):
'''
An object representing a named location.
Since some geographic locations have multiple names, or are
sufficiently close to be all but geographically
indistinguishable, multiple Locations may refer to the same
geogrphic location. Aliasses are used to track and account
for this.
:param name: the name of the location
:type name: str
:param latitude: the latitude of the location
:type name: float
:param longitude: the longitude of the location
:type name: float
:param kind: what the location is: lake, river, peak,
trailhead, campground, etc.
:type kind: KindEnum
:param note: Any notes deemed relevant for the location.
:type note: str
:param is_in_park: whether or not the location is in the park
True for yes, False for no
:type is_in_park: bool
:param aliases: other Locations that go by the same name
:type aliases: int
'''
__tablename__ = 'locations'
id = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
name: str = db.Column(db.String, index=True, unique=True, nullable=False)
latitude: float = db.Column(db.Float)
longitude: float = db.Column(db.Float)
kind: enum.Enum = db.Column(db.Enum(KindEnum))
is_in_park: bool = db.Column(db.Boolean)
aliases: int = db.relationship('Location', secondary=location_association_table,
primaryjoin=id == location_association_table.c.location_1_id,
secondaryjoin=id == location_association_table.c.location_1_id,
)
note: str = db.Column(db.String)
def __init__(self, name: str, latitude: float = None, longitude: float = None,
kind: KindEnum = None, note: str = None, is_in_park: bool = None):
self.name = name
self.latitude = latitude
self.longitude = longitude
self.kind = kind
self.is_in_park = is_in_park
self.note = note
def __lt__(self, other):
return self.name < other.name
def __repr__(self):
return f'{self.name}: {self.latitude}, {self.longitude}'
class User(db.Model):
__tablename__ = 'users'
# TODO: lots (db. and __init__)
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_date = db.Column(db.DateTime,
default=datetime.datetime.now,
index=True)
name = db.Column(db.String, nullable=False, unique=True)
email = db.Column(db.String, unique=True)
department_id: int = db.Column(db.String, db.ForeignKey('departments.id'))
department: Department = db.relationship('Department',
foreign_keys=[department_id])
travels = db.relationship('TravelUserUnit', backref='traveler')
home_number = db.Column(db.String)
work_number = db.Column(db.String)
cell_number = db.Column(db.String)
active: bool = db.Column(db.Boolean, nullable=False)
def __init__(self,
name: str,
email: str,
work_number: str = None,
home_number: str = None,
cell_number: str = None,
department: str = None,
active: bool = None):
self.name = name
self.email = email
self.work_number = work_number
self.home_number = home_number
self.cell_number = cell_number
self.active = active
department_id = department_services.get_id_from_name(department)
self.department_id = department_id
def __lt__(self, other):
return self.name < other.name
def __eq__(self, other):
return self.name == other.name and \
self.email == other.email and \
self.work_number == self.work_number and \
self.home_number == self.home_number and \
self.cell_number == self.cell_number and \
self.department == self.department
class Car(db.Model):
__tablename__ = 'cars'
id: int = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime,
default=datetime.datetime.now,
index=True)
plate: str = db.Column(db.String, unique=True, nullable=False)
make: str = db.Column(db.String)
model: str = db.Column(db.String)
color_id: int = db.Column(db.String, db.ForeignKey('colors.id'))
color = db.relationship('Color', foreign_keys=[color_id])
location: str = db.Column(db.String)
active: bool = db.Column(db.Boolean)
department_id: int = db.Column(db.String, db.ForeignKey('departments.id'))
department = db.relationship('Department', foreign_keys=[department_id])
notes = db.relationship('Note', backref='car')
def __init__(self,
plate: str,
make: str = None,
model: str = None,
color: str = None,
location: str = None,
active: bool = None,
department: Department = None):
self.plate = plate
self.make = make
self.model = model
color = color_services.add_if_not_present(color)
self.color_id = color_services.get_id_from_name(color)
self.location = location
self.active = active
self.department_id = department_services.get_id_from_name(
department) if department else None
def __lt__(self, other):
return str(self) < str(other)
def __repr__(self):
return f'{self.plate} {self.make} {self.model} {self.color.name} {self.location}'
@property
def name(self):
return str(self)
class Department(db.Model):
"""
An object representing a component of an orginization's structure.
Typically used to represent which portion of an orginizaiton
that an employee works for or a piece of equipment belongs to.
:param id: the database key
:type id: int
:param created_date: the date on which the Department is added
to the database
:type created_date: datetime
:param name: the name of the department
:type name: str
"""
__tablename__ = 'departments'
id: int = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.now)
name: str = db.Column(db.String, unique=True, nullable=False)
def __init__(self, name: str):
"""
Initializes a Department object
:param name: the name of the department
:type name: str
"""
self.name = name
def __lt__(self, other):
return self.name < other.name
def __repr__(self):
return f'{self.name}'
class Travel(db.Model):
__tablename__ = 'travels'
id = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
index=True)
start_date: datetime = db.Column(db.Date, index=True)
entry_point_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
entry_point: Location = db.relationship('Location',
foreign_keys=[entry_point_id])
end_date: datetime = db.Column(db.Date, index=True)
exit_point_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
exit_point: Location = db.relationship('Location',
foreign_keys=[exit_point_id])
tracked = db.Column(db.Boolean, index=False)
plb = db.Column(db.String, index=False)
trip_leader_id = db.Column(db.Integer, db.ForeignKey('users.id'))
trip_leader = db.relationship('User', foreign_keys=[trip_leader_id])
travelers = db.relationship('TravelUserUnit', backref='travel')
travel_days: TravelDay = db.relationship('TravelDay', backref='travel')
car_id: int = db.Column(db.Integer, db.ForeignKey('cars.id'))
car: Car = db.relationship('Car', foreign_keys=[car_id])
car_location: str = db.Column(db.String)
bivy_gear = db.Column(db.Boolean)
compass = db.Column(db.Boolean)
first_aid_kit = db.Column(db.Boolean)
flagging = db.Column(db.Boolean)
flare = db.Column(db.Boolean)
flashlight = db.Column(db.Boolean)
gps = db.Column(db.Boolean)
head_lamp = db.Column(db.Boolean)
helmet = db.Column(db.Boolean)
ice_axe = db.Column(db.Boolean)
map = db.Column(db.Boolean)
matches = db.Column(db.Boolean)
probe_pole = db.Column(db.Boolean)
radio = db.Column(db.Boolean)
rope = db.Column(db.Boolean)
shovel = db.Column(db.Boolean)
signal_mirror = db.Column(db.Boolean)
space_blanket = db.Column(db.Boolean)
spare_battery = db.Column(db.Boolean)
tent = db.Column(db.Boolean)
whistle = db.Column(db.Boolean)
days_of_food = db.Column(db.Float)
weapon = db.Column(db.String)
radio_monitor_time = db.Column(db.String)
off_trail_travel = db.Column(db.Boolean)
cell_number = db.Column(db.String)
satellite_number = db.Column(db.String)
contacts: User = db.relationship('User',
secondary=contact_association_table)
files: User = db.relationship('TravelFile', backref='travel')
gar_avg = db.Column(db.Float)
mitigated_gar = db.Column(db.Float)
gar_mitigations = db.Column(db.String)
notes = db.Column(db.String)
def __init__(
self,
start_date: datetime,
entry_point_id: int,
end_date: datetime,
exit_point_id: int,
tracked: bool,
plb: str,
trip_leader_id: int,
car_id: int,
car_location: str,
bivy_gear: bool,
compass: bool,
first_aid_kit: bool,
flagging: bool,
flare: bool,
flashlight: bool,
gps: bool,
head_lamp: bool,
helmet: bool,
ice_axe: bool,
map: bool,
matches: bool,
probe_pole: bool,
radio: bool,
rope: bool,
shovel: bool,
signal_mirror: bool,
space_blanket: bool,
spare_battery: bool,
tent: bool,
whistle: bool,
days_of_food: float,
weapon: str,
radio_monitor_time: str,
off_trail_travel: bool,
cell_number: str,
satellite_number: str,
gar_avg: float,
mitigated_gar: int,
gar_mitigations: str,
notes: str,
):
self.start_date = start_date
self.entry_point_id = entry_point_id
self.end_date = end_date
self.exit_point_id = exit_point_id
self.tracked = tracked
self.plb = plb
self.trip_leader_id = trip_leader_id
self.car_id = car_id
self.car_location = car_location
self.bivy_gear = bivy_gear
self.compass = compass
self.first_aid_kit = first_aid_kit
self.flagging = flagging
self.flare = flare
self.flashlight = flashlight
self.gps = gps
self.head_lamp = head_lamp
self.helmet = helmet
self.ice_axe = ice_axe
self.map = map
self.matches = matches
self.probe_pole = probe_pole
self.radio = radio
self.rope = rope
self.shovel = shovel
self.signal_mirror = signal_mirror
self.space_blanket = space_blanket
self.spare_battery = spare_battery
self.tent = tent
self.whistle = whistle
self.days_of_food = days_of_food
self.weapon = weapon
self.radio_monitor_time = radio_monitor_time
self.off_trail_travel = off_trail_travel
self.cell_number = cell_number
self.satellite_number = satellite_number
self.gar_avg = float(gar_avg)
self.mitigated_gar = float(mitigated_gar)
self.gar_mitigations = gar_mitigations
self.notes = notes
def __repr__(self):
return f'{self.start_date} - {self.entry_point}, {self.entry_point} - {self.exit_point}'
import datetime
from travel_plan import db
from travel_plan.car.cars import Car
from travel_plan.location.locations import Location
from travel_plan.travel.travel_days import TravelDay
from travel_plan.user.users import User
contact_association_table = db.Table(
'travel_contact_association', db.metadata,
db.Column('travels_id',
db.Integer,
db.ForeignKey('travels.id'),
primary_key=True),
db.Column('contacts_id',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True))
class Travel(db.Model):
__tablename__ = 'travels'
id = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
index=True)
start_date: datetime = db.Column(db.Date, index=True)
entry_point_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
entry_point: Location = db.relationship('Location',
class TravelUserUnit(db.Model):
__tablename__ = 'travel_user_units'
id = db.Column(db.Integer, primary_key=True)
created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow, index=True)
travel_id: int = db.Column(db.Integer, db.ForeignKey('travels.id'))
user_id: int = db.Column(db.Integer, db.ForeignKey('users.id'))
user: User = db.relationship('User', foreign_keys=[user_id])
call_sign: str = db.Column(db.String)
pack_color_id: int = db.Column(db.Integer, db.ForeignKey('colors.id'))
pack_color = db.relationship('Color', foreign_keys=[pack_color_id])
tent_color_id: int = db.Column(db.Integer, db.ForeignKey('colors.id'))
tent_color = db.relationship('Color', foreign_keys=[tent_color_id])
fly_color_id: int = db.Column(db.Integer, db.ForeignKey('colors.id'))
fly_color = db.relationship('Color', foreign_keys=[fly_color_id])
supervision: int = db.Column(db.Integer)
planning: int = db.Column(db.Integer)
contingency: int = db.Column(db.Integer)
comms: int = db.Column(db.Integer)
team_selection: int = db.Column(db.Integer)
fitness: int = db.Column(db.Integer)
env: int = db.Column(db.Integer)
complexity: int = db.Column(db.Integer)
total: int = db.Column(db.Integer)
def __init__(self, traveler_name: str, call_sign: str,
pack_color: str, tent_color: str, fly_color: str,
supervision: int, planning: int, contingency: int, comms: int,
team_selection: int, fitness: int, env: int, complexity: int,
total: int):
self.traveler = user_services.get_user_from_name(traveler_name)
if not self.traveler:
self.traveler = user_services.create_user(traveler_name, active=False)
self.call_sign = call_sign
if pack_color:
pack_color = color_services.add_if_not_present(pack_color)
self.pack_color_id = color_services.get_id_from_name(pack_color)
if tent_color:
tent_color = color_services.add_if_not_present(tent_color)
self.tent_color_id = color_services.get_id_from_name(tent_color)
if fly_color:
fly_color = color_services.add_if_not_present(fly_color)
self.fly_color_id = color_services.get_id_from_name(fly_color)
self.supervision = supervision
self.planning = planning
self.contingency = contingency
self.comms = comms
self.team_selection = team_selection
self.fitness = fitness
self.env = env
self.complexity = complexity
self.total = total
@property
def total_gar_score(self):
return (self.supervision + self.planning + self.contingency + self.comms
+ self.team_selection + self.fitness + self.env + self.complexity)
class KindEnum(enum.Enum):
Peak = 1
Valley = 2
River = 3
Lake = 4
Ridge = 5
Trail_Head = 6
Meadow = 7
Other = 8
Campground = 9
Basin = 10
Area = 11
location_association_table = sa.Table('location_alias_association', db.Model.metadata,
db.Column('location_1_id', db.Integer, db.ForeignKey('locations.id'),
primary_key=True),
db.Column('location_2_id', db.Integer, db.ForeignKey('locations.id'),
primary_key=True)
)
class Location(db.Model):
'''
An object representing a named location.
Since some geographic locations have multiple names, or are
sufficiently close to be all but geographically
indistinguishable, multiple Locations may refer to the same
geogrphic location. Aliasses are used to track and account
for this.
