class ContactEvents(db.Model, ManyToManyBaseModel):
__tablename__ = "contacts_events"
event_id = db.Column(db.String(5), db.ForeignKey('events.id'))
contact_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
class Image(db.Model, BaseModel):
__tablename__ = "images"
name = db.Column(db.String(255))
path = db.Column(db.String(255))
contact_id = db.Column(db.String(5), db.ForeignKey('contacts.id'))
@property
def imgurl(self):
return os.path.join(STATIC_URL_PATH, "uploads", "images", self.path)
@property
def fullpath(self):
return os.path.join(IMAGES_DIR, self.path)
@property
def as_image(self):
return '<a href={imgurl}><img width="100" height="100" src="{imgurl}"></img></a>'.format(
imgurl=self.imgurl)
def __str__(self):
return self.path
class CompaniesContacts(db.Model, ManyToManyBaseModel):
__tablename__ = 'companies_contacts'
company_id = db.Column(db.String(5), db.ForeignKey('companies.id'))
contact_id = db.Column(db.String(5), db.ForeignKey('contacts.id'))
class KnowledgeBaseCategory(db.Model, BaseModel):
__tablename__ = "knowledgebase_categories"
name = db.Column(db.String(255), nullable=False, index=True)
description = db.Column(db.Text())
knowledge_bases = db.relationship("KnowledgeBase", backref="category")
class Event(db.Model, BaseModel):
__tablename__ = "events"
__mapper_args__ = {'polymorphic_identity': 'messages'}
title = db.Column(
db.String(255),
nullable=False,
index=True
)
description = db.Column(
db.Text(),
default="",
index=True
)
contact_event_status = db.Column(
db.Enum(ContactEventStatus),
default=ContactEventStatus.INVITED,
)
contacts = db.relationship(
"Contact",
secondary="contacts_events",
backref="events"
)
comments = db.relationship(
"Comment",
backref="event",
)
messages = db.relationship(
"Message",
backref="event",
)
links = db.relationship(
"Link",
backref="event",
)
tasks = db.relationship(
"Task",
backref="event",
)
event_datetime = db.Column(
db.TIMESTAMP,
default=datetime.utcnow,
onupdate=datetime.utcnow,
nullable=False,
index=True
)
def __str__(self):
return self.title
class UsersOrganizations(db.Model, ManyToManyBaseModel):
"""
Many To Many Through table
"""
__tablename__ = 'users_organizations'
user_id = db.Column(db.String(5), db.ForeignKey('users.id'))
organization_id = db.Column(db.String(5),
db.ForeignKey('organizations.id'))
class ContactsSprints(db.Model, ManyToManyBaseModel):
"""
Many To Many Through table
"""
__tablename__ = 'contacts_sprints'
contact_id = db.Column(db.String(5), db.ForeignKey('contacts.id'))
sprint_id = db.Column(db.String(5), db.ForeignKey('sprints.id'))
class ContactsProjects(db.Model, ManyToManyBaseModel):
"""
Many To Many Through Table
"""
__tablename__ = 'contacts_projects'
contact_id = db.Column(db.String(5), db.ForeignKey('contacts.id'))
project_id = db.Column(db.String(5), db.ForeignKey('projects.id'))
class CompanyTags(db.Model, ManyToManyBaseModel):
__tablename__ = "companies_tags"
tag_id = db.Column(
db.String(5),
db.ForeignKey('tags.id')
)
company_id = db.Column(
db.String(5),
db.ForeignKey("companies.id")
)
class KnowledgeBase(db.Model, BaseModel):
__tablename__ = "knowledgebases"
title = db.Column(db.String(255), nullable=False, index=True)
category_id = db.Column(db.String(5),
db.ForeignKey("knowledgebase_categories.id"))
author_id = db.Column(db.String(5), db.ForeignKey("users.id"))
content = db.Column(db.Text(), index=True)
tasks = db.relationship("Task", backref="knowledge_base")
comments = db.relationship("Comment", backref="knowledge_base")
class TaskTracking(db.Model, BaseModel):
__tablename__ = "tasktrackings"
# should be markdown.
remarks = db.Column(
db.Text()
)
time_done = db.Column(
db.Integer,
default=0
)
def __str__(self):
return "<TaskTracker %s>" % self.id
class Address(db.Model, BaseModel):
__tablename__ = "addresses"
street_number = db.Column(db.String(255), index=True)
street_name = db.Column(db.String(255), default="", index=True)
description = db.Column(db.Text(), default="", index=True)
city = db.Column(db.Text(), default="", index=True)
state = db.Column(db.Text(), default="", index=True)
zip_code = db.Column(db.String(255), index=True)
country_id = db.Column(db.String(5), db.ForeignKey('countries.id'))
contact_id = db.Column(db.String(5), db.ForeignKey('contacts.id'))
company_id = db.Column(db.String(5), db.ForeignKey('companies.id'))
deal_id = db.Column(db.String(5), db.ForeignKey('deals.id'))
@property
def formatted_address(self):
address = ''
if self.street_name:
if self.street_number:
address += '%s %s, ' % (self.street_number, self.street_name)
else:
address += '%s, ' % self.street_name
if self.state:
address += '%s, ' % self.state
if self.city:
address += '%s, ' % self.city
if self.country:
address += str(self.country.name)
if self.zip_code:
address += ' (zip code: %s)' % self.zip_code
return address
def __str__(self):
return self.formatted_address
class Organization(db.Model, BaseModel, RootModel):
__tablename__ = "organizations"
name = db.Column(db.String(255), nullable=False, index=True)
# should be markdown
description = db.Column(db.Text(), default="", index=True)
emails = db.relationship(
'Email',
backref='organization',
primaryjoin="Organization.id==Email.organization_id")
tasks = db.relationship("Task", backref="organization")
comments = db.relationship("Comment", backref="organization")
users = db.relationship(
"User",
secondary="users_organizations",
secondaryjoin="User.id==UsersOrganizations.user_id",
backref="organizations")
links = db.relationship("Link", backref="organization")
messages = db.relationship("Message", backref="organization")
owner_id = db.Column(db.String(5), db.ForeignKey('users.id'))
parent_id = db.Column(db.String(5), db.ForeignKey("organizations.id"))
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
return [e.email for e in self.emails]
def __str__(self):
return self.name
class Sprint(db.Model, BaseModel, RootModel):
__tablename__ = "sprints"
name = db.Column(db.String(255), nullable=False, index=True)
# should be markdown.
description = db.Column(db.Text(), default="", index=True)
start_date = db.Column(db.TIMESTAMP, index=True)
deadline = db.Column(db.TIMESTAMP, index=True)
contacts = db.relationship("Contact",
secondary="contacts_sprints",
backref="sprints")
tasks = db.relationship("Task", backref="sprint")
comments = db.relationship("Comment", backref="sprint")
links = db.relationship("Link", backref="sprint")
messages = db.relationship("Message", backref="sprint")
owner_id = db.Column(db.String(5), db.ForeignKey('users.id'))
project_id = db.Column(db.String(5), db.ForeignKey('projects.id'))
def notify(self, msgobj, attachments=[]):
emails = []
for c in self.contacts:
if c.emails:
emails.extend(c.emails.split(","))
if self.owner and self.owner.emails:
emails.extend(self.owner.emails.split(","))
sendemail(to=emails,
subject=msgobj.title,
body=msgobj.content,
attachments=attachments)
@property
def percentage_done(self):
pass
@property
def hours_open(self):
pass
@property
def hours_open_person_avg(self):
pass
@property
def hours_open_person_max(self):
pass
def __str__(self):
return self.name
class Subgroup(db.Model, BaseModel):
__tablename__ = "subgroups"
groupname = db.Column(db.Enum(SubgroupName),
default=SubgroupName.MEMBER,
index=True)
contacts = db.relationship("Contact",
secondary="contacts_subgroups",
backref="subgroups")
def __str__(self):
return self.groupname.name
class Project(db.Model, BaseModel, RootModel):
__tablename__ = "projects"
name = db.Column(db.String(255), nullable=False, index=True)
# should be markdown.
description = db.Column(db.Text(), default="", index=True)
start_date = db.Column(db.TIMESTAMP, index=True)
deadline = db.Column(db.TIMESTAMP, index=True)
comments = db.relationship("Comment", backref="project")
links = db.relationship("Link", backref="project")
tasks = db.relationship("Task", backref="project")
messages = db.relationship("Message", backref="project")
sprints = db.relationship("Sprint",
backref="project",
primaryjoin="Project.id==Sprint.project_id")
# alert_source_id = db.Column(
# db.String,
# db.ForeignKey("alertsources.id")
# )
contacts = db.relationship("Contact",
secondary="contacts_projects",
backref=db.backref("projects"))
promoter_id = db.Column(db.String(5), db.ForeignKey('users.id'))
guardian_id = db.Column(db.String(5), db.ForeignKey('users.id'))
def notify(self, msgobj, attachments=[]):
emails = []
for c in self.contacts:
emails.extend(c.emails.split(","))
if self.promoter and self.promoter.emails:
emails.extend(self.promoter.emails.split(","))
if self.guardian and self.guardian.emails:
emails.extend(self.guardian.emails.split(","))
if emails:
sendemail(to=emails,
subject=msgobj.title,
body=msgobj.content,
attachments=attachments)
@property
def percentage_done(self):
pass
def __str__(self):
return self.name
class Activity(db.Model, BaseModel):
__tablename__ = "activities"
type = db.Column(
db.Enum(ActivityType),
index=True,
unique=True,
)
contacts = db.relationship("Contact",
secondary="contacts_activities",
backref="activities")
def __str__(self):
return self.type.name
class Tag(db.Model, BaseModel):
"""
Model for any kind of tags
"""
__tablename__ = "tags"
tag = db.Column(db.String(), nullable=False, unique=True, index=True)
companies = db.relationship("Company",
secondary="companies_tags",
backref="tags")
def __str__(self):
return self.tag
class Company(db.Model, BaseModel, RootModel):
__tablename__ = "companies"
name = db.Column(db.String(255), nullable=False, index=True)
# should be markdown.
description = db.Column(db.Text(), default="", index=True)
vatnumber = db.Column(db.String(255), index=True)
website = db.Column(db.String(255), index=True)
emails = db.relationship('Email',
backref='company',
primaryjoin="Company.id==Email.company_id")
telephones = db.relationship('Phone',
backref='company',
primaryjoin="Company.id==Phone.company_id")
deals = db.relationship("Deal", backref="company")
messages = db.relationship("Message", backref="company")
tasks = db.relationship("Task", backref="company")
comments = db.relationship("Comment", backref="company")
contacts = db.relationship(
"Contact",
secondary="companies_contacts",
backref='companies',
)
owner_id = db.Column(db.String(5), db.ForeignKey('users.id'))
ownerbackup_id = db.Column(db.String(5), db.ForeignKey('users.id'))
links = db.relationship("Link", backref="company")
addresses = db.relationship("Address", backref="company")
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
return [e.email for e in self.emails]
def __str__(self):
return self.name
class Country(db.Model, BaseModel):
__tablename__ = "countries"
name = db.Column(db.Enum(CountriesEnum),
default=CountriesEnum.BE,
unique=True,
index=True)
contacts = db.relationship("Contact",
secondary="contacts_countries",
backref="countries")
addresses = db.relationship("Address", backref="country")
passports = db.relationship("Passport", backref="country")
def __str__(self):
return self.name.value
class Passport(db.Model, BaseModel):
__tablename__ = "passports"
passport_fullname = db.Column(db.String(255), nullable=False, index=True)
passport_number = db.Column(db.Text(), index=True, nullable=False)
issuance_date = db.Column(db.Date(),
default=datetime.date(1990, 1, 1),
nullable=False)
expiration_date = db.Column(db.Date(),
default=datetime.date(2020, 1, 1),
nullable=False)
country_id = db.Column(db.String(5), db.ForeignKey('countries.id'))
contact_id = db.Column(db.String(5), db.ForeignKey('contacts.id'))
def __str__(self):
return "Passport {}".format(self.passport_fullname)
class Contact(db.Model, BaseModel, RootModel):
__tablename__ = "contacts"
firstname = db.Column(db.String(255), nullable=False, index=True)
lastname = db.Column(db.String(255), default="", index=True)
description = db.Column(db.Text())
images = db.relationship("Image", backref="contact")
bio = db.Column(db.Text(), default="")
belief_statement = db.Column(db.Text(), default="")
gender = db.Column(db.Enum(Gender), default=Gender.MALE, index=True)
date_of_birth = db.Column(db.Date(),
default=datetime.date(1990, 1, 1),
nullable=True)
message_channels = db.Column(db.String(255), default='')
deals = db.relationship("Deal",
backref="contact",
primaryjoin="Contact.id==Deal.contact_id")
comments = db.relationship("Comment", backref="contact")
tasks = db.relationship("Task", backref="contact")
messages = db.relationship("Message", backref="contact")
links = db.relationship("Link", backref="contact")
owner_id = db.Column(db.String(5), db.ForeignKey('users.id'))
ownerbackup_id = db.Column(db.String(5), db.ForeignKey('users.id'))
parent_id = db.Column(db.String(5), db.ForeignKey('users.id'))
# Comma separated emails
emails = db.Column(db.Text(), index=True)
# Comma separated phones
telephones = db.Column(db.Text(), index=True)
tf_app = db.Column(db.Boolean())
tf_web = db.Column(db.Boolean())
referral_code = db.Column(db.String(255), )
addresses = db.relationship("Address", backref="contact")
passports = db.relationship("Passport", backref="contact")
def notify(self, msgobj=None, attachments=[]):
emails = []
if self.emails:
emails.extend(self.emails.split(","))
if self.owner and self.owner.emails:
emails.extend(self.owner.emails.split(","))
sendemail(to=emails,
subject=msgobj.title,
body=msgobj.content,
attachments=attachments)
@property
def address(self):
return "{} {} {}".format(
self.street_number or '',
'%s,' % self.street_name if self.street_name else '',
self.country).strip()
def __str__(self):
return "{} {}".format(self.firstname, self.lastname or '').strip()
class ContactCountry(db.Model, ManyToManyBaseModel):
__tablename__ = "contacts_countries"
country_id = db.Column(db.String(5), db.ForeignKey('countries.id'))
contact_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
class ContactSubgroup(db.Model, ManyToManyBaseModel):
__tablename__ = "contacts_subgroups"
subgroup_id = db.Column(db.String(5), db.ForeignKey('subgroups.id'))
contact_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
class Message(db.Model, BaseModel):
__tablename__ = "messages"
title = db.Column(
db.String(255),
nullable=False,
index=True
)
content = db.Column(
db.Text(),
nullable=False,
index=True
)
channel = db.Column(
db.String(255)
)
time_sent = db.Column(
db.TIMESTAMP
)
message_author_id = db.Column(
db.String,
db.ForeignKey("users.id")
)
author = db.relationship(
"User",
backref="createdMessages",
uselist=False,
foreign_keys=[message_author_id]
)
company_id = db.Column(
db.String,
db.ForeignKey("companies.id")
)
contact_id = db.Column(
db.String,
db.ForeignKey("contacts.id")
)
user_id = db.Column(
db.String,
db.ForeignKey("users.id")
)
deal_id = db.Column(
db.String,
db.ForeignKey("deals.id")
)
task_id = db.Column(
db.String,
db.ForeignKey("tasks.id")
)
organization_id = db.Column(
db.String,
db.ForeignKey("organizations.id")
)
project_id = db.Column(
db.String,
db.ForeignKey("projects.id")
)
sprint_id = db.Column(
db.String,
db.ForeignKey("sprints.id")
)
event_id = db.Column(
db.String,
db.ForeignKey("events.id")
)
links = db.relationship(
"Link",
backref="message"
)
state = db.Column(
db.Enum(MessageState),
default=MessageState.TOSEND,
index=True
)
parent_id = db.Column(
db.String(5),
db.ForeignKey('messages.id')
)
author_original_type = db.Column(
db.Unicode(255)
)
author_original_id = db.Column(
db.Integer,
)
author_original = generic_relationship(
author_original_type,
author_original_id
)
author_last_id = db.Column(
db.Integer,
)
author_last = generic_relationship(
author_original_type,
author_original_id
)
@property
def parent(self):
if self.parent_id:
return self.__class__.query.filter_by(id=self.parent_id).first()
replies = db.relationship(
"Message",
uselist=True,
)
# ',' separated string of emails
# Is used to force sending emails to certain destination
# If not set, `notification_emails` is used instead to calculate
# ALl email addresses
forced_destinations = db.Column(
db.String,
)
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
if self.forced_destinations:
return [d.strip() for d in self.forced_destinations.split(',') if d]
obj = None
if self.user:
obj = self.user
elif self.contact:
obj = self.contact
elif self.company:
obj = self.company
elif self.organization:
obj = self.organization
elif self.deal: # contact emails or company emails
obj = self.deal
elif self.task: # assignee + one of these if found (contact, users, deal, company, organization, event, sprint)
obj = self.task
elif self.project: # promoter + guardian + contacts + one of (tasks, sprints)
obj = self.project
elif self.event: # All contacts emails + All tasks emails
obj = self.event
elif self.sprint: # contacts + owner + tasks
obj = self.sprint
if not obj:
return []
return list(set(obj.notification_emails))
def __str__(self):
return self.title
class Contact(db.Model, BaseModel, RootModel):
__tablename__ = "contacts"
firstname = db.Column(db.String(255), nullable=False, index=True)
lastname = db.Column(db.String(255), default="", index=True)
description = db.Column(db.Text())
images = db.relationship("Image", backref="contact")
bio = db.Column(db.Text(), default="")
belief_statement = db.Column(db.Text(), default="")
gender = db.Column(db.Enum(Gender), default=Gender.MALE, index=True)
date_of_birth = db.Column(db.Date(),
default=datetime.date(1990, 1, 1),
nullable=True)
message_channels = db.Column(db.String(255), default='')
deals = db.relationship("Deal",
backref="contact",
primaryjoin="Contact.id==Deal.contact_id")
comments = db.relationship("Comment", backref="contact")
tasks = db.relationship("Task", backref="contact")
messages = db.relationship("Message", backref="contact")
links = db.relationship("Link", backref="contact")
owner_id = db.Column(db.String(5), db.ForeignKey('users.id'))
ownerbackup_id = db.Column(db.String(5), db.ForeignKey('users.id'))
parent_id = db.Column(db.String(5), db.ForeignKey('users.id'))
emails = db.relationship('Email',
backref='contact',
primaryjoin="Contact.id==Email.contact_id")
telephones = db.relationship('Phone',
backref='contact',
primaryjoin="Contact.id==Phone.contact_id")
tf_app = db.Column(db.Boolean())
tf_web = db.Column(db.Boolean())
referral_code = db.Column(db.String(255), )
addresses = db.relationship("Address", backref="contact")
passports = db.relationship("Passport", backref="contact")
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
return [e.email for e in self.emails]
@property
def address(self):
return "{} {} {}".format(
self.street_number or '',
'%s,' % self.street_name if self.street_name else '',
self.country).strip()
def __str__(self):
return "{} {}".format(self.firstname, self.lastname or '').strip()
class ContactActivity(db.Model, ManyToManyBaseModel):
__tablename__ = "contacts_activities"
activity_id = db.Column(db.String(5), db.ForeignKey('activities.id'))
contact_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
class User(db.Model, BaseModel, RootModel):
__tablename__ = "users"
username = db.Column(db.String(255),
unique=True,
nullable=True,
index=True)
firstname = db.Column(db.String(255), index=True)
lastname = db.Column(db.String(255), index=True)
# should be markdown.
description = db.Column(db.Text(), default="")
message_channels = db.Column(db.String(255), default='')
# Comma separated emails
emails = db.Column(db.Text(), index=True)
# Comma separated phones
telephones = db.Column(db.Text(), index=True)
# Tasks Linked to this user (may be someone is doing it for him) like
# create account
tasks = db.relationship("Task",
backref="user",
primaryjoin="User.id==Task.user_id")
ownsTasks = db.relationship("Task",
backref="assignee",
primaryjoin="User.id==Task.assignee_id")
comments = db.relationship("Comment",
backref="user",
primaryjoin="User.id==Comment.user_id")
messages = db.relationship("Message",
backref="user",
primaryjoin="User.id==Message.user_id")
links = db.relationship("Link",
backref="user",
primaryjoin="User.id==Link.user_id")
ownsContacts = db.relationship("Contact",
backref="owner",
primaryjoin="User.id==Contact.owner_id")
ownsAsBackupContacts = db.relationship(
"Contact",
backref="ownerbackup",
primaryjoin="User.id==Contact.ownerbackup_id")
ownsCompanies = db.relationship("Company",
backref="owner",
primaryjoin="User.id==Company.owner_id")
ownsAsBackupCompanies = db.relationship(
"Company",
backref="ownerbackup",
primaryjoin="User.id==Company.ownerbackup_id")
ownsOrganizations = db.relationship(
"Organization",
backref="owner",
primaryjoin="User.id==Organization.owner_id")
ownsSprints = db.relationship("Sprint",
backref="owner",
primaryjoin="User.id==Sprint.owner_id")
# ownsAlerts = db.relationship(
# "Alert",
# backref="owner",
# primaryjoin="User.id==Alert.owner_id"
# )
promoterProjects = db.relationship(
"Project",
backref="promoter",
primaryjoin="User.id==Project.promoter_id")
guardianProjects = db.relationship(
"Project",
backref="guardian",
primaryjoin="User.id==Project.guardian_id")
knowledge_bases = db.relationship(
"KnowledgeBase",
backref="author",
primaryjoin="User.id==KnowledgeBase.author_id")
def notify(self, msgobj=None, attachments=[]):
if self.emails:
emails = self.emails.split(",")
if emails:
sendemail(to=emails,
subject=msgobj.title,
body=msgobj.content,
attachments=attachments)
def __str__(self):
return self.username or '%s %s'.strip() % (self.firstname
or '', self.lastname or '')
__repr__ = __str__
class Message(db.Model, BaseModel):
__tablename__ = "messages"
title = db.Column(db.String(255), nullable=False, index=True)
content = db.Column(db.Text(), index=True)
channel = db.Column(db.String(255))
time_tosend = db.Column(db.TIMESTAMP)
time_sent = db.Column(db.TIMESTAMP)
message_author_id = db.Column(db.String, db.ForeignKey("users.id"))
author = db.relationship("User",
backref="createdMessages",
uselist=False,
foreign_keys=[message_author_id])
company_id = db.Column(db.String, db.ForeignKey("companies.id"))
contact_id = db.Column(db.String, db.ForeignKey("contacts.id"))
user_id = db.Column(db.String, db.ForeignKey("users.id"))
deal_id = db.Column(db.String, db.ForeignKey("deals.id"))
task_id = db.Column(db.String, db.ForeignKey("tasks.id"))
organization_id = db.Column(db.String, db.ForeignKey("organizations.id"))
project_id = db.Column(db.String, db.ForeignKey("projects.id"))
sprint_id = db.Column(db.String, db.ForeignKey("sprints.id"))
event_id = db.Column(db.String, db.ForeignKey("events.id"))
links = db.relationship("Link", backref="message")
state = db.Column(db.Enum(MessageState),
default=MessageState.TOSEND,
index=True)
def __str__(self):
return self.title
@property
def destination(self):
emails = []
if self.user:
emails.extend(self.user.emails.split(','))
if self.contact:
emails.extend(self.contact.emails.split(','))
if self.company:
emails.extend(self.company.emails.split(','))
if self.organization:
emails.extend(self.organization.emails.split(','))
return emails
@property
def destination_emails(self):
emails = self.destination
if emails:
return ",".join([x.email for x in self.destination])
return "Not destination yet."
class Link(db.Model, BaseModel):
__tablename__ = "links"
url = db.Column(
db.String(255),
nullable=False,
index=True
)
labels = db.Column(
db.Text(),
index=True
)
contact_id = db.Column(
db.String,
db.ForeignKey("contacts.id")
)
user_id = db.Column(
db.String,
db.ForeignKey("users.id")
)
deal_id = db.Column(
db.String,
db.ForeignKey("deals.id")
)
task_id = db.Column(
db.String,
db.ForeignKey("tasks.id")
)
organization_id = db.Column(
db.String,
db.ForeignKey("organizations.id")
)
project_id = db.Column(
db.String,
db.ForeignKey("projects.id")
)
sprint_id = db.Column(
db.String,
db.ForeignKey("sprints.id")
)
company_id = db.Column(
db.String,
db.ForeignKey("companies.id")
)
event_id = db.Column(
db.String,
db.ForeignKey("events.id")
)
message_id = db.Column(
db.String(),
db.ForeignKey("messages.id")
)
# alert_id = db.Column(
# db.String,
# db.ForeignKey("alerts.id")
# )
#
# alert_source_id = db.Column(
# db.String,
# db.ForeignKey("alertsources.id")
# )
comments = db.relationship(
"Comment",
backref="link"
)
def __str__(self):
return self.url
