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 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 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 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 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 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 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 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 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 Link(db.Model, BaseModel):
__tablename__ = "links"
url = db.Column(db.String(255), nullable=False, index=True)
filename = db.Column(db.String())
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.filename or self.url
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 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 Comment(db.Model, BaseModel):
__tablename__ = "comments"
# should be markdown.
content = db.Column(
db.Text(),
index=True
)
company_id = db.Column(
db.String(5),
db.ForeignKey("companies.id")
)
contact_id = db.Column(
db.String(5),
db.ForeignKey("contacts.id")
)
user_id = db.Column(
db.String(5),
db.ForeignKey("users.id")
)
deal_id = db.Column(
db.String(5),
db.ForeignKey("deals.id")
)
task_id = db.Column(
db.String(5),
db.ForeignKey("tasks.id")
)
organization_id = db.Column(
db.String(5),
db.ForeignKey("organizations.id")
)
project_id = db.Column(
db.String(5),
db.ForeignKey("projects.id")
)
sprint_id = db.Column(
db.String(5),
db.ForeignKey("sprints.id")
)
link_id = db.Column(
db.String(5),
db.ForeignKey("links.id")
)
event_id = db.Column(
db.String,
db.ForeignKey("events.id")
)
# alert_id = db.Column(
# db.String,
# db.ForeignKey("alerts.id")
# )
#
# alert_source_id = db.Column(
# db.String,
# db.ForeignKey("alertsources.id")
# )
knowledge_base_id = db.Column(
db.String,
db.ForeignKey("knowledgebases.id")
)
def __str__(self):
return self.content
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 Deal(db.Model, BaseModel, RootModel):
__tablename__ = "deals"
name = db.Column(
db.String(255),
nullable=False,
index=True,
)
# should be markdown.
description = db.Column(
db.Text(),
default="",
)
value = db.Column(db.Float(), default=0.0, index=True, nullable=False)
currency_id = db.Column(
db.String(5),
db.ForeignKey("currencies.id"),
nullable=False,
)
deal_type = db.Column(db.Enum(DealType),
default=DealType.HOSTER,
index=True,
nullable=False)
migrated = db.Column(db.Boolean())
deal_state = db.Column(db.Enum(DealState),
default=DealState.NEW,
index=True,
nullable=False)
closed_at = db.Column(db.TIMESTAMP, nullable=True)
company_id = db.Column(db.String(5), db.ForeignKey("companies.id"))
contact_id = db.Column(db.String(5),
db.ForeignKey("contacts.id"),
index=True)
referrer1_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
referrer1 = db.relationship("Contact",
backref="referrer1_deals",
foreign_keys=[referrer1_id])
owner_id = db.Column(
db.String(5),
db.ForeignKey("users.id"),
nullable=False,
index=True,
)
tasks = db.relationship("Task", backref="deal")
comments = db.relationship("Comment", backref="deal")
messages = db.relationship("Message", backref="deal")
links = db.relationship("Link", backref="deal")
is_paid = db.Column(db.Boolean(), index=True)
referral_code = db.Column(db.String(255), index=True)
shipping_address = db.relationship("Address", backref="deal")
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
if self.contact:
return self.contact.notification_emails
elif self.company:
return self.company.notification_emails
return []
@property
def to_usd(self):
return round(
Decimal(self.value) * Decimal(self.currency.value_usd),
2) if self.value else Decimal(0.0)
@property
def value_usd(self):
return '%s' % str(self.to_usd)
def __str__(self):
return self.name
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
)
# Comma separated emails
emails = db.Column(
db.Text(),
index=True
)
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")
)
def notify(self, msgobj, attachments=[]):
emails = []
if self.emails:
emails.extend(self.emails.split(","))
for obj in [self.users]:
if obj is not None:
emails.extend(obj.emails.split(","))
if emails:
sendemail(to=emails, subject=msgobj.title,
body=msgobj.content, attachments=attachments)
def __str__(self):
return self.name
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 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 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'))
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
emails = []
if self.contacts:
for contact in self.contacts:
if contact.notification_emails:
emails.extend(contact.notification_emails)
if self.owner:
if self.owner.notification_emails:
emails.extend(self.owner.notification_emails)
if self.tasks:
for task in self.tasks:
if task.notification_emails:
emails.extend(task.notification_emails)
return list(set(emails))
@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 Deal(db.Model, BaseModel, RootModel):
__tablename__ = "deals"
name = db.Column(db.String(255), nullable=False, index=True)
# should be markdown.
description = db.Column(
db.Text(),
default="",
)
value = db.Column(db.Float(), default=0.0, index=True, nullable=False)
currency_id = db.Column(
db.String(5),
db.ForeignKey("currencies.id"),
nullable=False,
)
deal_type = db.Column(db.Enum(DealType),
default=DealType.HOSTER,
index=True,
nullable=False)
deal_state = db.Column(db.Enum(DealState),
default=DealState.NEW,
index=True,
nullable=False)
closed_at = db.Column(db.TIMESTAMP, nullable=True)
company_id = db.Column(db.String(5), db.ForeignKey("companies.id"))
contact_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
referrer1_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
referrer2_id = db.Column(db.String(5), db.ForeignKey("contacts.id"))
referrer1 = db.relationship("Contact",
backref="referrer1_deals",
foreign_keys=[referrer1_id])
referrer2 = db.relationship("Contact",
backref="referrer2_deals",
foreign_keys=[referrer2_id])
tasks = db.relationship("Task", backref="deal")
comments = db.relationship("Comment", backref="deal")
messages = db.relationship("Message", backref="deal")
links = db.relationship("Link", backref="deal")
is_paid = db.Column(db.Boolean(), index=True)
referral_code = db.Column(db.String(255), index=True)
shipping_address = db.relationship("Address", backref="deal")
def notify(self, msgobj, attachments=[]):
emails = []
for obj in [self.contact, self.company]:
if obj and obj.emails:
emails.extend(obj.emails.split(","))
sendemail(to=emails,
subject=msgobj.title,
body=msgobj.content,
attachments=attachments)
@property
def value_usd(self):
return '%s' % str(
round(Decimal(self.value) *
Decimal(self.currency.value_usd), 2)) if self.value else 0.0
def __str__(self):
return self.name
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 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
)
# Comma separated emails
emails = db.Column(
db.Text(),
index=True
)
# Comma separated phones
telephones = db.Column(
db.Text(),
index=True
)
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"
)
def __str__(self):
return self.name
def notify(self, msgobj=None, attachments=[]):
emails = []
if self.emails:
emails = self.emails.split(",")
if self.contacts:
for c in self.contacts:
emails.extend(c.emails.split(","))
if self.owner:
emails.extend(self.owner.emails.split(","))
if emails:
sendemail(to=emails, subject=msgobj.title,
body=msgobj.content, attachments=attachments)
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 Task(db.Model, BaseModel):
__tablename__ = "tasks"
title = db.Column(
db.String(255),
nullable=False,
index=True
)
description = db.Column(
db.Text(),
default="",
index=True
)
type = db.Column(
db.Enum(TaskType),
default=TaskType.TASK,
index=True
)
priority = db.Column(
db.Enum(TaskPriority),
default=TaskPriority.MINOR,
index=True
)
state = db.Column(
db.Enum(TaskState),
default=TaskState.NEW,
index=True
)
assignee_id = db.Column(
db.String,
db.ForeignKey("users.id")
)
deadline = db.Column(
db.TIMESTAMP,
nullable=True,
index=True
)
eta = db.Column(
db.TIMESTAMP,
nullable=True,
index=True
)
# in hours
time_estimate = db.Column(
db.Integer,
default=0
)
time_done = db.Column(
db.Integer,
default=0
)
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")
)
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")
)
# alert_id = db.Column(
# db.String,
# db.ForeignKey("alerts.id")
# )
#
# alert_source_id = db.Column(
# db.String,
# db.ForeignKey("alertsources.id")
# )
event_id = db.Column(
db.String,
db.ForeignKey("events.id")
)
knowledge_base_id = db.Column(
db.String,
db.ForeignKey("knowledgebases.id")
)
comments = db.relationship(
"Comment",
backref="task"
)
messages = db.relationship(
"Message",
backref="task"
)
links = db.relationship(
"Link",
backref="task"
)
@property
def percent_completed(self):
done = 0.0
for stat in self.tasks:
done += stat.time_done
if not done:
return done
if not self.time_todo:
return 100
return (done / self.time_todo) * 100
@property
def notification_emails(self):
"""
:return: list of all emails to send notifications to
:rtype: list
"""
emails = []
if self.assignee:
if self.assignee.notification_emails:
emails.extend(self.assignee.notification_emails)
if self.contact:
if self.contact.notification_emails:
emails.extend(self.contact.notification_emails)
elif self.user:
if self.user.notification_emails:
emails.extend(self.user.notification_emails)
elif self.deal:
if self.deal.notification_emails:
emails.extend(self.deal.notification_emails)
elif self.company:
if self.company.notification_emails:
emails.extend(self.company.notification_emails)
elif self.organization:
if self.organization.notification_emails:
emails.extend(self.organization.notification_emails)
elif self.event:
if self.event.notification_emails:
emails.extend(self.event.notification_emails)
elif self.sprint:
if self.sprint.notification_emails:
emails.extend(self.sprint.notification_emails)
return list(set(emails))
def __str__(self):
return self.title
