class FATask(db.Document):
wav_url = db.StringField(required=False, dafault='')
wav_tmp_path = db.StringField(required=False, dafault='/tmp/tmppath')
request_srt_content = db.StringField(required=False, dafault='')
result_srt_content = db.StringField(required=False, dafault='')
steps = db.EmbeddedDocumentListField(TaskStep)
timestamp = db.LongField(required=False, default=time.time)
segment = db.BooleanField(required=False, dafault=False)
meta = {
'collection': 'fa_task',
'index_background': True,
'indexes': ['timestamp'],
'strict': False
}
def add_step(self, step_obj):
self.steps.append(step_obj)
return self.save()
def to_dict(self):
json_obj = dict(
self.to_mongo(fields=[
'wav_url', 'request_srt_content', 'result_srt_content',
'steps', 'timestamp', 'segment'
]))
json_obj.pop('_id', '')
json_obj['steps'] = []
for step in self.steps:
json_obj['steps'].append(step.to_dict())
json_obj['task_id'] = str(self.pk)
return json_obj
class Product(db.Document):
slug = db.StringField(required=True)
name = db.StringField(required=True)
price = db.DecimalField(required=False)
photo = db.StringField(required=False)
quantity_type = db.StringField(required=False) # list or range
quantity_value = db.StringField(
required=False) # pp,p,m,g or 1,9,1 <- (start, finish, step)
@property
def quantity_list(self):
quant_list = []
if self.quantity_type == "list":
quant_list = self.quantity_value.split(",")
if self.quantity_type == "range":
range_vals = self.quantity_value.split(",")
quant_list = range(int(range_vals[0]), int(range_vals[1]),
int(range_vals[2]))
return quant_list
def __eq__(self, other):
return self.slug == other.slug
def __unicode__(self):
return self.name
class Project(db.Document):
project = db.StringField(verbose_name="Project",
max_length=255,
unique=True,
required=True)
description = db.StringField(verbose_name="Description")
dateofcreation = db.DateTimeField(default=datetime.datetime.now)
url = db.StringField(max_length=255, unique=True, required=True)
tasks = db.ListField(db.EmbeddedDocumentField('Task'))
@property
def completed(self):
projectDetails = Project.objects().get(url=self.url)
count = 0
for i in projectDetails.tasks:
if i.completed == True:
count += 1
return count
@property
def remaining(self):
projectDetails = Project.objects().get(url=self.url)
count = 0
for i in projectDetails.tasks:
if i.completed == False:
count += 1
return count
class User(UserMixin, db.Document):
meta = {"collection": "users"}
id = db.StringField(default=lambda: str(uuid.uuid4()), primary_key=True)
active = db.BooleanField(default=True)
# User authentication information
email = db.EmailField()
password = db.StringField()
# User information
username = db.StringField(default="")
# User image
image = db.StringField(default="default.jpg")
# Relationships
posts = db.ListField(db.StringField(), default=[])
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config["SECRET_KEY"], expires_sec)
return s.dumps({"user_id": self.id}).decode("utf-8")
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config["SECRET_KEY"])
try:
user_id = s.loads(token)["user_id"]
except:
return None
return User.objects.get(id=user_id)
class RecipeSearch(Document):
username = StringField()
timestamp = db.ComplexDateTimeField()
displayLink = db.StringField()
link = db.URLField()
htmlTitle = db.StringField()
title = db.StringField()
class NMTTask(db.Document):
request_srt_content = db.StringField(required=False, dafault='')
result_srt_content = db.StringField(required=False, dafault='')
steps = db.EmbeddedDocumentListField(TaskStep)
timestamp = db.LongField(required=False, default=time.time)
lang = db.StringField(required=False, dafault='en')
meta = {
'collection': 'nmt_task',
'index_background': True,
'indexes': ['timestamp'],
'strict': False
}
def add_step(self, step_obj):
self.steps.append(step_obj)
return self.save()
def to_dict(self):
json_obj = dict(
self.to_mongo(fields=[
'request_srt_content', 'result_srt_content', 'steps',
'timestamp', 'lang'
]))
json_obj.pop('_id', '')
json_obj['steps'] = []
for step in self.steps:
json_obj['steps'].append(step.to_dict())
json_obj['task_id'] = str(self.pk)
return json_obj
class FeedbackContent(db.EmbeddedDocument):
type = db.StringField(required=True)
ageFeedback = db.StringField(required=True)
ageCorrectness = db.BooleanField(required=True)
genderFeedback = db.StringField(required=True)
genderCorrectness = db.BooleanField(required=True)
emotionFeedback = db.StringField(required=True)
emotionCorrectness = db.BooleanField(required=True)
class Store(db.Document):
store_name = db.StringField(required=True, unique=True)
Phone_number = db.StringField(required=True)
tagline = db.StringField(required=True)
shop_address = db.StringField(required=True)
email = db.StringField(unique=True)
created = db.DateTimeField(default=datetime.datetime.utcnow)
def __str__(self):
return "<Store: {}>".format(self.store_name)
class Complaint(db.Document):
user_ref_id = db.ReferenceField(user.User, required=True)
message = db.StringField(required=True)
store_ref_code = db.ReferenceField(user_store.UserStore, required=True)
status = db.StringField(default="open")
timestamp = db.DateTimeField(default=datetime.datetime.utcnow)
def __repr__(self):
return "<Complaint: from: {}; opened: {}>".format(
self.store_ref_code, self.timestamp)
class Task(db.EmbeddedDocument):
title = db.StringField(verbose_name="Title",
max_length=255,
unique=True,
required=True)
details = db.StringField(verbose_name="Details")
setdate = db.DateTimeField(default=datetime.datetime.now)
lastdate = db.DateTimeField(verbose_name="Last Date")
completed = db.BooleanField(default=False)
url = db.StringField(max_length=255, unique=True)
class Question(db.Document):
slug = db.StringField(required=True)
question = db.StringField(required=True)
answers = db.ListField(EmbeddedDocumentField(Answer))
def __eq__(self, other):
return self.slug == other.slug
def __unicode__(self):
return self.question
class Transaction(db.Document):
"""
A class used to represent the transaction model
...
Attributes
----------
customer_ref_id : reference
a reference field to the customer
amount : float
the transaction amount
interest : float
the interest applied to the amount
total_amount: float
the total_amount
description : str
the description of the transaction
transaction_name: str
the name of transaction
user_ref_id: reference
user reference ID
store_ref_id: reference
store reference ID
Methods
-------
pre_save(cls, sender, transaction, *kw)
handles time attribute(updated_at) ONLY when transaction is modified
"""
customer_ref_id = db.ReferenceField(customer.Customer,
required=True,
dbref=True)
amount = db.FloatField(required=True)
interest = db.FloatField(required=True)
total_amount = db.FloatField(required=True)
description = db.StringField(required=True)
transaction_name = db.StringField(required=True)
transaction_role = db.StringField(required=True)
user_ref_id = db.ReferenceField(user.User, dbref=True, required=True)
#store_ref_id = db.ReferenceField(user_store.Store, dbref=True, required=True)
store_ref_id = db.ReferenceField(store.Store, dbref=True, required=True)
created_at = db.DateTimeField(default=datetime.datetime.utcnow)
updated_at = db.DateTimeField(default=datetime.datetime.utcnow)
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.updated_at = datetime.datetime.utcnow()
def __str__(self):
return "<Transaction Details: {}-{} by {} at {}>".format(
self.transaction_name, self.transaction_role, self.user_ref_id,
self.created_at)
class Post(db.Document):
id = db.StringField(default=lambda: str(uuid.uuid4()), primary_key=True)
title = db.StringField(max_length=255, required=True)
slug = db.StringField(max_length=255, required=True, unique=True)
date_posted = db.DateTimeField(default=datetime.datetime.now,
required=True)
content = db.StringField(required=True)
author = db.ReferenceField(User, required=True)
meta = {
"allow_inheritance": False,
"indexes": ["-date_posted", "slug", "title"],
"ordering": ["-date_posted"],
"collection": "posts",
}
class TaskStep(db.EmbeddedDocument):
number = db.IntField(required=False, default=0)
comment = db.StringField(required=False, default='')
timestamp = db.LongField(required=False, default=time.time)
def to_dict(self):
return dict(self.to_mongo(fields=['number', 'comment', 'timestamp']))
class User(db.Document):
facebook_id = db.StringField(required=True)
email = db.StringField(required=True)
name = db.StringField(required=True)
tipo = db.StringField(required=False) # musico, fa, produtor, etc
city = db.StringField(required=False)
@property
def photo(self):
url = 'http://graph.facebook.com/%s/picture'
return url % self.facebook_id
def __eq__(self, other):
return self.facebook_id == other.facebook_id
def __unicode__(self):
return self.name
class DebtReminder:
ts_ref_id = db.ReferenceField(transaction.Transaction,
dbref=True,
required=True)
message = db.StringField(required=True)
status = db.StringField(required=True)
expected_pay_date = db.DateTimeField(default=datetime.datetime.utcnow)
updated_at = db.DateTimeField(default=datetime.datetime.utcnow)
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.updated_at = datetime.datetime.utcnow()
def __str__(self):
return "<Debt Reminder: {}; {} at {}>".format(self.ts_ref_id,
self.message,
self.expected_pay_date)
class User(db.Document):
''' The data model'''
handle = db.StringField(required=True)
def as_dict(self):
return {
'id': json.loads(dumps(getattr(self, 'pk')))['$oid'],
'handle': getattr(self, 'handle')
}
class Answer(db.EmbeddedDocument):
answer = db.StringField(required=True)
user = db.ReferenceField(User, required=True, dbref=False)
def __eq__(self, other):
return self.answer == other.answer and self.user == other.user
def __unicode__(self):
return self.answer
class Newsletter(db.Document):
option = db.BooleanField(required=True) # Sim ou Nao
tipo = db.StringField(required=True) # Shows Locais, Meus Shows, etc..
user = db.ReferenceField(User, required=True, dbref=False)
def __eq__(self, other):
return self.user == other.user and self.option == other.option and self.tipo == other.tipo
def __unicode__(self):
return u"%s - %s - %s" % (self.user, self.tipo,
u"Sim" if self.option else u"Não")
class Show(db.Document):
slug = db.StringField(required=True)
title = db.StringField(required=True)
artists_slug = db.ListField(StringField())
attendance_count = db.IntField(min_value=0, required=False, default=0)
cover_image = db.StringField(required=False)
description = db.StringField(required=False)
datetime_usa = db.StringField(required=False)
location = db.ReferenceField(Location, required=False, dbref=False)
website = db.StringField(required=False)
artists_list = None
@property
def artists(self):
if not self.artists_list is None:
return self.artists_list
return Band.objects.filter(slug__in=self.artists_slug)
@property
def datetime(self):
return datetime.strftime(
datetime.strptime(self.datetime_usa[:19], "%Y-%m-%d %H:%M:%S"),
'%d/%m')
def __eq__(self, other):
return self.slug == other.slug
def __unicode__(self):
return self.title
class Location(db.Document):
name = db.StringField(required=True)
slug = db.StringField(required=True)
city = db.StringField(required=True)
street = db.StringField(required=False)
postalcode = db.StringField(required=False)
website = db.StringField(required=False)
phonenumber = db.StringField(required=False)
image = db.StringField(required=False)
def __eq__(self, other):
return self.slug == other.slug
def __unicode__(self):
return self.name
class Customer(db.Document):
"""
A class used to represent the customer model
...
Attributes
----------
store_ref_id: reference
store reference ID
name : str
the name of the customer
phone_number: str
the phone number of the customer
created_at: datetime str
time when customer is created
updated_at: datetime str
time when customer is modified
Methods
-------
pre_save(cls, sender, customer, *kw)
handles time attribute(updated_at) ONLY when customer detail is modified
"""
store_ref_id = db.ReferenceField(store.Store, dbref=True, required=True)
name = db.StringField(required=True)
phone_number = db.StringField(required=True)
created_at = db.DateTimeField(default=datetime.datetime.utcnow)
updated_at = db.DateTimeField(default=datetime.datetime.utcnow)
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.updated_at = datetime.datetime.utcnow()
def __str__(self):
return "<Customer: {}; {} at {}>".format(self.name, self.store_ref_id, self.created_at)
class User(db.Document):
phone_number = db.StringField(required=True, unique=True)
first_name = db.StringField(required=True)
last_name = db.StringField(required=True)
email = db.StringField(required=True, unique=True)
is_active = db.BooleanField(default=False)
password = db.StringField(required=True)
api_token = db.StringField()
user_role = db.StringField(default="store_admin")
reg_date = db.DateTimeField(default=datetime.datetime.utcnow)
def __str__(self):
return "<User: {}>".format(self.first_name)
class Band(db.Document):
slug = db.StringField(required=True)
name = db.StringField(required=True)
aliases = db.ListField(StringField(required=True))
users = db.ListField(ReferenceField(User, dbref=False))
shows = db.ListField(ReferenceField(Show, dbref=False))
musicians = db.ListField(ReferenceField(User, dbref=False))
products = db.ListField(ReferenceField(Product, dbref=False))
photo_url = db.StringField(required=False)
tags_list = db.ListField(StringField())
similares_slug = db.ListField(StringField())
history_content = db.StringField(required=False)
@property
def similares(self):
if len(self.similares_slug) == 0:
self.update_data()
return Band.objects.filter(slug__in=self.similares_slug)
@property
def tags(self):
if len(self.tags_list) == 0:
self.update_data()
return self.tags_list
@property
def photo(self):
if not self.photo_url:
self.update_data()
return self.photo_url
@property
def history(self):
if not self.history_content:
self.update_data()
read_more_on_position = self.history_content.find("Read more")
if read_more_on_position == -1:
return self.history_content.strip()
return self.history_content[:read_more_on_position].strip()
def update_data(self):
lastfm_module = get_lastfm_module()
controller = get_controllers_module()
band_data = lastfm_module.get_band_data(band=self)
self.photo_url = band_data["image"][3]['#text']
if type(band_data["tags"]) is dict:
tags = band_data["tags"]["tag"]
if not type(tags) is list:
tags = [tags]
self.tags_list = [tag["name"] for tag in tags]
if type(band_data["similar"]) is dict:
similares = band_data["similar"]["artist"]
if not type(similares) is list:
similares = [similares]
for similar_band in similares:
band = controller.get_or_create_band(
{"name": similar_band["name"]})
self.similares_slug.append(band.slug)
self.history_content = re.sub('<[^>]*>', '',
band_data["bio"]["content"])
self.save()
def timeline_as_dict(self):
return {
"headline":
unicode(self.name),
"type":
"default",
"text":
u"<p>%s</p>" % self.history,
"asset": {
"media": self.photo
},
"date": [{
"startDate":
"%s" % str(datetime.now().date()).replace("-", ","),
"headline":
"Contribua",
"text":
u"<p>Clique no botão acima escrito 'Contribua com a timeline' e escreva os acontecimentos que você mais gosta sobre a banda.</p>",
"tag":
u"%s, Contribua" % self.name,
"classname":
"contribua",
"asset": {
"media": self.photo
}
}]
}
def __eq__(self, other):
return self.slug == other.slug
def __unicode__(self):
return self.name
class User(UserMixin, db.Document):
meta = {'collection': 'user'}
email = db.StringField(max_length=30)
username = db.StringField(max_length=30)
password = db.StringField()
social_id = db.StringField()
class Role(db.Document):
_id = db.StringField(default="store_admin")
name = db.StringField(required=True)
def __str__(self):
return "<Role: {} {}>".format(self.name, self._id)
class BandQuestion(db.Document):
email = db.StringField(required=True)
question = db.StringField(required=True)
band_slug = db.StringField(required=True)
