class Racer(db.Model): __tablename__ = 'racers' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True) name = db.Column(db.String(255), nullable=False) city = db.Column(db.String(255)) state = db.Column(db.String(255)) points = db.Column(db.Integer) cars = db.relationship('Car', secondary=CarRacer, back_populates='racers') sponsors = db.relationship('Sponsor', secondary=RacerSponsor, backref='racers') laps = db.relationship('BestLap', backref='racer') created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow(), nullable=False) updated_date = db.Column(db.DateTime, nullable=True) #Picture def __init__(self, email, name, city, state, points): self.email = email self.name = name self.city = city self.state = state self.points = points self.created_date = datetime.datetime.now() def __repr__(self): return '<Racer {0}>'.format(self.name)
class Course(db.Model): __tablename__ = 'courses' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), unique=True, nullable=False) description = db.Column(db.Text(), nullable=False) subject = db.Column(db.String(255), nullable=False) start_date = db.Column(db.DateTime, nullable=False) end_date = db.Column(db.DateTime, nullable=False) active = db.Column(db.Boolean, nullable=False, default=True) teacher_id = db.Column(db.Integer, db.ForeignKey('teachers.id'), nullable=False) teacher = db.relationship('Teacher', backref='courses') students = db.relationship('Student', secondary=course_student_association_table, backref='courses') def __init__(self, name, description, subject, start_date, end_date, teacher_id): self.name = name self.description = description self.subject = subject self.start_date = start_date self.end_date = end_date self.teacher_id = teacher_id def __repr__(self): return '<Class {0}>'.format(self.name)
class Users(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) phone = db.Column(db.String(1000), nullable=False) password = db.Column(db.String(255), nullable=False) user_type = db.Column(db.String(255)) user_group = db.Column(db.String(255)) address = db.relationship('Address', lazy='dynamic', cascade='all,delete', innerjoin=True, backref=db.backref('user', lazy='joined')) sar = db.relationship('Sar', lazy='dynamic', cascade='all,delete', innerjoin=True, foreign_keys='Sar.user_id', backref=db.backref('user', lazy='joined')) sar_assignedTo = db.relationship('Sar', lazy='dynamic', cascade='all,delete', innerjoin=True, foreign_keys='Sar.assignedTo', backref=db.backref('assignedTO', lazy='joined')) creation_time = db.Column(db.DateTime, nullable=False, default=datetime.datetime.now()) modification_time = db.Column(db.DateTime, default=datetime.datetime.now()) created_by = db.Column(db.String(255)) modified_by = db.Column(db.String(255)) confirmed = db.Column(db.Boolean, nullable=False, default=False) confirmed_on = db.Column(db.DateTime, nullable=True) token = db.Column(db.String(255), nullable=True) password_reset_token = db.Column(db.String, nullable=True) organization = db.relationship("Organization", backref="users") def __init__(self, data, confirmed, confirmed_on=None, token=None,user_type=None,user_group=None): self.name = data["name"] self.email = data["email"] self.password = bcrypt.generate_password_hash( data["password"], current_app.config.get('BCRYPT_LOG_ROUNDS') ).decode('utf-8') self.user_type = user_type self.user_group = user_group self.phone = data["phone"] self.creation_time = datetime.datetime.now() # self.modification_time = data["modification_time"] self.created_by = data["created_by"] self.modified_by = data["modified_by"] self.confirmed = confirmed self.confirmed_on = confirmed_on self.token = token def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<users {0}>'.format(self.email) def to_dict(self): return {c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs}
class Itinerary(db.Model): __tablename__ = "itineraries" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) events = db.relationship("Event", secondary=itinerary_events, back_populates="itineraries") trip = db.relationship("Trip", back_populates="itineraries") trip_id = db.Column(db.Integer, db.ForeignKey("trips.id")) user_id = db.Column(db.Integer, db.ForeignKey("users.id")) user = db.relationship("User", foreign_keys=[user_id]) app_user_id = db.Column(db.Integer, db.ForeignKey("users.id")) approved_user = db.relationship("User", foreign_keys=[app_user_id]) req_user_id = db.Column(db.Integer, db.ForeignKey("users.id")) requesting_user = db.relationship("User", foreign_keys=[req_user_id]) last_edited = db.Column(db.DateTime) def __init__(self, name, trip, user): self.name = name self.trip = trip self.user = user self.last_login = datetime.datetime.now() self.approved_user = None self.requesting_user = None def update_edited(self): self.last_edited = datetime.datetime.now()
class Section(db.Model): __tablename__ = 'section' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) owner_id = db.Column(db.Integer, nullable=False) parentSectionId = db.Column(db.Integer, nullable=True) assessment_id = db.Column(db.Integer, db.ForeignKey('assessment.id'), nullable=False) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) status = db.Column(db.String(255), nullable=True) quesRelation = db.relationship('Question', backref='section', lazy=True) sectionsdpi = db.relationship('DpiAudit', backref='section', lazy=True) def __init__(self, name, owner_id, parentSectionId, assessment_id): self.name = name self.owner_id = owner_id self.parentSectionId = parentSectionId self.assessment_id = assessment_id self.created_date = datetime.datetime.now() def __repr__(self): return '<Section %r>' % (self.name) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Sar(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) assignedTo = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False) otherInfo = db.Column(db.String(255)) sarDescription = db.Column(db.String(255)) externalUser = db.Column(db.String(255)) representative = db.Column(db.String(255)) user_confirmed = db.Column(db.String(255)) rep_confirmed = db.Column(db.String(255)) priority = db.Column(db.String(255)) completionTime = db.Column(db.DateTime) #completionTime = db.Column(db.String(255)) status = db.Column(db.String(255)) ticketinfo = db.relationship('TicketInfo', lazy='dynamic', backref=db.backref('sar', lazy='joined')) ticket = db.relationship('Ticket', lazy='dynamic', cascade='all,delete', innerjoin=True, primaryjoin="Sar.id == Ticket.sar_id", backref=db.backref('sar', lazy='joined')) sar_response = db.relationship('SARResponse', lazy='dynamic', cascade='all,delete', backref=db.backref('sar', lazy='joined')) user_id = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False) creation_time = db.Column(db.DateTime, nullable=False) modification_time = db.Column(db.DateTime, default=datetime.datetime.now()) created_by = db.Column(db.String(255)) modified_by = db.Column(db.String(255)) isEscalated = db.Column(db.Boolean) assigned_user = db.relationship('Users', foreign_keys='Sar.assignedTo') created_user = db.relationship('Users', foreign_keys='Sar.user_id') def __init__(self, data, user_id=None): self.assignedTo = data['assignedTo'] self.otherInfo = data['otherInfo'] self.sarDescription = data['sarDescription'] self.externalUser = data['externalUser'] self.representative = data['representative'] self.completionTime = datetime.datetime.now() self.status = data['status'] self.creation_time = datetime.datetime.now() # self.modification_time = data["modification_time"] self.created_by = data["created_by"] self.modified_by = data["modified_by"] self.isEscalated = data['isEscalated'] self.priority = data['priority'] self.user_id = data['user_id'] def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class OrderRepairAssociation(db.Model, CRUDMixin): __tablename__ = 'order_repair_association' order_id = db.Column(db.Integer, db.ForeignKey('order.id'), primary_key=True) repair_id = db.Column(db.Integer, db.ForeignKey('repair.id'), primary_key=True) order = db.relationship("Order", back_populates="_repairs") repair = db.relationship("Repair", back_populates="orders")
class Customer(db.Model, CRUDMixin, SessionStoreMixin): __tablename__ = "customer" SESSION_KW = __tablename__ id = db.Column(db.Integer, primary_key=True, autoincrement=True) tricoma_id = db.Column(db.String, nullable=True, index=True) first_name = db.Column(db.String(255), nullable=True, unique=False, index=True) last_name = db.Column(db.String(255), nullable=True, unique=False, index=True) tricoma_username = db.Column(db.String(255), nullable=True, unique=False, index=False) street = db.Column(db.String(255), nullable=True, unique=False, index=True) zip_code = db.Column(db.String(10), nullable=True, unique=False, index=True) city = db.Column(db.String(255), nullable=True, unique=False, index=True) tel = db.Column(db.String(64), nullable=True, unique=False, index=True) email = db.Column(db.String(255), nullable=False, unique=False, index=True) registered_on = db.Column(db.DateTime, nullable=False, default=datetime.datetime.now) # Relations orders = db.relationship("Order", back_populates="customer") enquiries = db.relationship("MiscInquiry", back_populates="customer") def __repr__(self): return self.first_name + " " + self.last_name @classmethod def deserialize(cls, obj): try: customer_id = obj['customer_id'] instance = cls.query.get(customer_id) return instance except KeyError as error: raise ValueError( f"{obj} is an invalid CustomerRepairDTO") from error @classmethod def query_by_mail(cls, email: str) -> typing.Optional: return cls.query.filter(cls.email == email).first() def serialize(self) -> dict: return dict(customer_id=self.id)
class Question(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) question_type = db.Column(db.String(255)) question_label = db.Column(db.String(255)) action_status = db.Column(db.String(255)) comments = db.Column(db.String(255)) riskWeightageStatus = db.Column(db.String(255)) assignedTo = db.Column(db.String(255)) owner = db.Column(db.String(255)) actions = db.relationship('Action', backref='question', lazy=True) answer_id = db.Column(db.Integer, db.ForeignKey('answer.id')) # define relationship answer = db.relationship('Answer', backref='question')
class SARResponse(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) sarattachment = db.relationship('sar_attachment', lazy='dynamic', cascade='all,delete', backref=db.backref('sarresponse', lazy='joined')) sar_id = db.Column(db.Integer, db.ForeignKey('sar.id'), nullable=False) fromUser = db.Column(db.String(255)) toUser = db.Column(db.String(255)) responseText = db.Column(db.String(255)) user_id = db.Column(db.Integer) user_name = db.Column(db.String(255)) def __init__(self, data, sar_id=None): self.fromUser = data['fromUser'] self.toUser = data['toUser'] self.responseText = data['responseText'] # self.user_name = data['user_name'] # self.user_id = data['user_id'] self.sar_id = sar_id # def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Appointment(BaseModel, Base): """""" user_id = db.Column(db.Integer, db.ForeignKey('users.id')) date = db.Column(db.DateTime, nullable=False) notes = db.Column(db.Text, nullable=False) treatments = db.relationship('Treatment', secondary='user_symptom_treatment')
class Projects(db.Model): __tablename__ = 'projects' id = db.Column(db.Integer, primary_key=True, autoincrement=True) proj_id = db.Column(db.String(10), nullable=False) proj_name = db.Column(db.String(255), nullable=False) proj_desc = db.Column(db.String(9999), nullable=False) proj_status = db.Column(db.String(25), nullable=False) created_by = db.Column(db.Integer, nullable=False) modified_by = db.Column(db.Integer, nullable=True) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) actions = db.relationship('Assessment', backref='projects', lazy=True) def __init__(self, proj_id, proj_name, proj_desc, proj_status, created_by): self.proj_id = proj_id self.proj_name = proj_name self.proj_desc = proj_desc self.proj_status = proj_status self.created_by = created_by self.created_date = datetime.datetime.now() def __repr__(self): return '<Projects %r>' % (self.proj_name) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) projects = db.relationship('Project', backref='users', lazy=True) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.admin = admin def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<User {0}>'.format(self.email)
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(1000), nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) entries = db.relationship('Entry', backref='user', lazy='dynamic') def __init__(self, name, email, password, admin=False): self.name = name self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode() self.registered_on = datetime.datetime.now() self.admin = admin def encode_auth_token(self, user_id): """ Generates the Auth Token :return: string """ try: days, hours, seconds = app.config.get('TOKEN_EXPIRATION') payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=days, hours=hours, seconds=seconds), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode(payload, app.config.get('SECRET_KEY'), algorithm='HS256') except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Validates the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) if is_blacklisted_token: return 'Token blacklisted. Please log in again.' else: return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again.' except jwt.InvalidTokenError: return 'Invalid token. Please log in again.'
class User(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) bucketlists = db.relationship('Bucketlist', order_by='Bucketlist.id', cascade="all, delete-orphan") def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')) self.registered_on = datetime.datetime.now() self.admin = admin def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<User {0}>'.format(self.email)
class Order(db.Model): __tablename__ = "orders" class STATUS(Enum): PENDING = 'pending' COMPLETED = 'completed' CANCELLED = 'cancelled' id = db.Column(db.Integer, primary_key=True, autoincrement=True) number = db.Column(db.String(255), nullable=False, unique=True) status = db.Column(db.Enum(STATUS), nullable=False, default=STATUS.PENDING) date_created_gmt = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) modification_date_gmt = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) order_items = db.relationship("OrderItem") def get_id(self): return self.id def total(self): return sum(oi.total() for oi in self.order_items) def get_status(self): return self.status def __repr__(self): return "<Order {0}>".format(self.number)
class Hospital(db.Model): __tablename__ = "hospitals" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(100)) city = db.Column(db.String(100)) region = db.Column(db.String(100)) address = db.Column(db.String(100)) phone1 = db.Column(db.String(100)) phone2 = db.Column(db.String(100)) unit_blood_pile = db.Column(db.Integer) transfusions = db.relationship('Transfusion', backref='hospital', lazy=True) donations = db.relationship('Donation', backref='hospital', lazy=True) donors = db.relationship('Donor', backref='done_at', lazy=True) subscribers = db.relationship('Subscriber', backref='done_at', lazy=True) created_at = db.Column(db.DateTime, default=db.func.now()) updated_at = db.Column(db.DateTime, default=db.func.now()) def _asdict(self): return { c.key: getattr(self, c.key) for c in db.inspect(self).mapper.column_attrs } def _return_data(self): hosp_arr = self._asdict() hosp_arr['transfusions'] = [ tran._asdict() for tran in self.transfusions ] hosp_arr['donations'] = [don._asdict() for don in self.donations] hosp_arr['donors'] = [don._asdict() for don in self.donors] hosp_arr['subscribers'] = [sub._asdict() for sub in self.subscribers] for j in range(len(self.transfusions)): hosp_arr['transfusions'][j]['subscriber'] = self.transfusions[ j].subscriber._asdict() hosp_arr['transfusions'][j]['hospital'] = self.transfusions[ j].hospital._asdict() for j in range(len(self.donations)): hosp_arr['donations'][j]['donor'] = self.donations[ j].donor._asdict() hosp_arr['donations'][j]['hospital'] = self.donations[ j].hospital._asdict() return hosp_arr
class Genre(db.Model): __tablename__ = 'genre' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False, unique=True) artists = db.relationship('Artist', backref="genre") def __init__(self, name): self.name = name
class Relationship(db.Model): __tablename__ = "relationships" id = db.Column(db.Integer, primary_key=True, autoincrement=True) follower_id = db.Column(db.Integer, db.ForeignKey('users.id')) followed_id = db.Column(db.Integer, db.ForeignKey('users.id')) follower = db.relationship(User, primaryjoin=follower_id == User.id) followed = db.relationship(User, primaryjoin=followed_id == User.id) created_on = db.Column(db.DateTime, nullable=False) updated_on = db.Column(db.DateTime, nullable=False, default=datetime.datetime.now, onupdate=datetime.datetime.now) def __init__(self, follower_id, followed_id): self.follower_id = follower_id self.followed_id = followed_id self.created_on = datetime.datetime.now()
class CartItem(db.Model): __tablename__ = 'cart_items' # Constants ADD = 'add' SUBTRACT = 'subtract' REMOVE = 'remove' ACTIONS = (ADD, SUBTRACT, REMOVE) id = db.Column(db.Integer, primary_key=True, autoincrement=True) quantity = db.Column(db.Integer, default=1) price = db.Column(db.Numeric(asdecimal=True, precision=10, scale=2), nullable=False) cart_id = db.Column(db.Integer, db.ForeignKey('carts.id'), nullable=True) cart = db.relationship('Cart', backref=backref("cart_items", lazy='joined', cascade="all, delete-orphan"), lazy=True) product_id = db.Column(db.Integer, db.ForeignKey('products.id'), nullable=True) product = db.relationship('Product', backref="cartitem", uselist=False, lazy='joined')
class Question(db.Model): __tablename__ = 'question' id = db.Column(db.Integer, primary_key=True, autoincrement=True) question_type = db.Column(db.String(255), nullable=False) question_label = db.Column(db.String(255), nullable=False) section_id = db.Column(db.Integer, db.ForeignKey('section.id'), nullable=True) action_status = db.Column(db.String(255), nullable=True) owner_id = db.Column(db.Integer, nullable=False) isAnswered = db.Column(db.Boolean, nullable=False) comments = db.Column(db.String(255), nullable=True) risk_weightage_status = db.Column(db.String(255), nullable=True) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) answer = db.relationship('Answer', uselist=False, backref="question") actionss = db.relationship('ActionNote', backref='question', lazy=True) DpiAuditQ = db.relationship('DpiAudit', backref='question', lazy=True) attachment = db.relationship('Attachments', backref='question', lazy=True) def __init__(self, question_type, question_label, section_id, action_status, owner_id, isAnswered, comments, risk_weightage_status): self.question_type = question_type self.question_label = question_label self.section_id = section_id self.action_status = action_status self.owner_id = owner_id self.isAnswered = isAnswered self.comments = comments self.risk_weightage_status = risk_weightage_status self.created_date = datetime.datetime.now() def __repr__(self): return '<Question %r>' % (self.question_type) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Action(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) section_id = db.Column(db.Integer) owner_id = db.Column(db.Integer) question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False) additional_info = db.relationship('AdditionalInformation', backref='action', lazy=True)
class User_Symptom(BaseModel, Base): """""" __tablename__ = 'user_symptom' user_id = db.Column(db.Integer, db.ForeignKey('users.id')) symptom_id = db.Column(db.Integer, db.ForeignKey('symptom.id')) start_date = db.Column(db.DateTime, nullable=False) end_date = db.Column(db.DateTime, nullable=False) notes = db.Column(db.Text, nullable=True) treatments = db.relationship('Treatment', secondary='user_symptom_treatment')
class Shop(BaseModel): """ Shops """ __tablename__ = 'shop' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(128), unique=True) # Relations orders = db.relationship("Order", back_populates="shop") def __repr__(self): return self.name
class OrderItem(db.Model): __tablename__ = "order_items" id = db.Column(db.Integer, primary_key=True, autoincrement=True) product_id = db.Column(db.Integer, db.ForeignKey('products.id')) quantity = db.Column(db.Integer, nullable=False) order_id = db.Column(db.Integer, db.ForeignKey('orders.id')) product = db.relationship("Product") def total(self): return self.product.price * self.quantity
class User(BaseModel, Base): __tablename__ = 'users' email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) street_address = db.Column(db.String(64), nullable=True) city = db.Column(db.String(64), nullable=True) state = db.Column(db.String(2), nullable=True) zip_code = db.Column(db.Integer, nullable=True) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) symptoms = db.relationship('Symptom', secondary='user_symptom') appointments = db.relationship('Appointment', backref='users', lazy='dynamic') def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.registered_on = datetime.datetime.now() self.admin = admin def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<User {0}>'.format(self.email)
class MiscInquiry(BaseModel): __tablename__ = "misc_enquiry" id = db.Column(db.Integer, primary_key=True, autoincrement=True) description = db.Column(db.Text, nullable=False) # Relation customer_id = db.Column(db.Integer, db.ForeignKey('customer.id'), nullable=False) customer = db.relationship("Customer", back_populates="enquiries") def __repr__(self) -> str: return self.customer.name
class Ticket(db.Model): # an email field and a password field uid = db.Column(db.Integer, primary_key=True, autoincrement=True) type = db.Column(db.String(120)) time = db.Column(BIGINT) changetime = db.Column(BIGINT) component = db.Column(db.String(100)) severity = db.Column(db.String(120)) priority = db.Column(db.String(120)) owner = db.Column(db.String(120)) reporter = db.Column(db.String(120)) cc = db.Column(db.String(120)) version = db.Column(db.String(120)) milestone = db.Column(db.String(120)) status = db.Column(db.String(120)) resolution = db.Column(db.String(120)) summary = db.Column(db.String(120)) description = db.Column(db.String(120)) keywords = db.Column(db.String(120)) product = db.Column(db.String(120)) id = db.Column(db.Integer) sar_id = db.Column(db.Integer, db.ForeignKey('sar.id')) created_time = db.Column(db.DateTime, default=datetime.datetime.now()) modified_time = db.Column(db.DateTime, default=None) ticketinfo2 = db.relationship('TicketInfo', lazy='dynamic', backref=db.backref('tickets', lazy='joined')) #ticket_id = db.Column(db.Integer, db.ForeignKey('ticket.uid'), nullable=False) def __init__(self, data, id, sar_id=None): self.type = data["type"] # self.updated_on = data["updated_on"] self.component = data["component"] self.severity = data["severity"] self.priority = data["priority"] self.owner = data["owner"] self.reporter = data["reporter"] self.cc = data["cc"] self.version = data["version"] self.milestone = data["milestone"] self.status = data["status"] self.resolution = data["resolution"] self.summary = data["summary"] self.description = data["description"] self.keywords = data["keywords"] self.product = data["product"] # self.modified_time = data["modified_time"] self.id = id self.sar_id = sar_id def to_dict(self): return {c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs}
class Event(db.Model): __tablename__ = 'events' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) start_date = db.Column(db.Date, nullable=False) end_date = db.Column(db.Date, nullable=False) tracks = db.relationship('Track', secondary=TrackEvent, backref='events') laps = db.relationship('BestLap', backref='event') created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow(), nullable=False) updated_date = db.Column(db.DateTime, nullable=True) def __init__(self, name, start_date, end_date): self.name = name self.start_date = start_date self.end_date = end_date self.created_date = datetime.datetime.now() def __repr__(self): return '<Event {0}>'.format(self.name)
class Trip(db.Model): __tablename__ = "trips" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) location = db.Column(db.String(255), nullable=False) # we should add date constraitns: start_date < end_date start_date = db.Column(db.Date, nullable=False) end_date = db.Column(db.Date, nullable=False) users = db.relationship("User", secondary=users_trips, back_populates="trips") itineraries = db.relationship("Itinerary", back_populates="trip") def __init__(self, name, location, start_date, end_date, user): self.name = name self.location = location self.start_date = start_date self.end_date = end_date self.users.append(user) def __repr__(self): return '<Trip {0}'.format(self.name)