class BesoinFinancier(db.Document):
commande = db.StringField()
fournisseur = db.StringField()
montant = db.FloatField()
avance = db.FloatField()
paye = db.FloatField()
date_echeance = db.DateTimeField()
projet_id = db.ReferenceField(Projet)
attente = db.BooleanField(default=True)
rejet = db.BooleanField(default=False)
parent = db.ReferenceField('self')
last_child = db.BooleanField(default=False)
updated = db.ListField(db.EmbeddedDocumentField(Update_Besoin))
def child(self):
childs = BesoinFinancier.objects(parent=self.id)
return childs
def lasted_child(self):
last = BesoinFinancier.objects(Q(parent=self.id)
& Q(last_child=True)).first()
return last
def notified(self):
data = []
for notifie in self.updated:
if notifie.notified:
data.append(notifie)
return data
class User(db.Document):
email = db.EmailField(required=True, unique=True)
alias = db.StringField(required=True, unique=True)
password = db.StringField(min_length=8, required=True)
emailVerified = db.BooleanField(default=False)
lastLogin = db.DateTimeField()
allowTracking = db.BooleanField(default=False)
isMod = db.BooleanField(default=False)
class Subject(db.EmbeddedDocument):
name = db.StringField(max_length=128, required=True)
birthdate = db.DateTimeField()
birth_place_known = db.BooleanField(default=False)
birth_year_known = db.BooleanField(default=False)
birth_time_known = db.BooleanField(default=False)
birth_date_known = db.BooleanField(default=True)
def get_natal_chart(self):
return astro.get_natal_chart(self.birthdate,
year_known=self.birth_year_known)
class User(BaseDocument):
username = db.StringField(verbose_name=u'login',
max_length=30,
required=True,
unique=True)
name = db.StringField(verbose_name=u'nome', max_length=100)
email = db.EmailField(verbose_name=u'e-mail',
max_length=100,
required=True,
unique=True)
pw_hash = db.StringField(verbose_name=u'senha',
max_length=100,
required=True)
is_active = db.BooleanField(verbose_name=u'ativo',
default=True,
required=True)
is_superuser = db.BooleanField(verbose_name=u'super usuário',
default=False,
required=True)
last_login = db.DateTimeField(verbose_name=u'último login', required=False)
meta = {'indexes': ['username', 'email']}
def __unicode__(self):
return self.username
def __init__(self, *args, **kwargs):
password = kwargs.pop('password', None)
super(User, self).__init__(*args, **kwargs)
if password:
self.set_password(password)
def set_password(self, password):
self.pw_hash = generate_password_hash(
password,
method=current_app.config['PROJECT_PASSWORD_HASH_METHOD'])
def check_password(self, password):
return check_password_hash(self.pw_hash, password)
def refresh_last_login(self):
self.last_login = datetime.now()
self.save()
class ActionRule(db.Document):
"""
Rule to control Actions based on labels
"""
name = db.StringField(required=True, unique=True)
condition_typ = db.StringField(choices=rule_types)
conditions = db.ListField(db.EmbeddedDocumentField(ActionCondition))
outcome = db.ListField(db.EmbeddedDocumentField(ActionOutcome))
last_match = db.BooleanField(default=False)
enabled = db.BooleanField()
meta = {
'strict': False,
}
class TestCase(db.Document):
"""Single case of a TestResult."""
name = db.StringField(min_length=1, required=True)
detail = db.StringField(required=True)
error = db.BooleanField(default=False, required=True)
passed = db.BooleanField(default=False, required=True)
def to_dict(self, **kwargs):
return {
"name": self.name,
"detail": self.detail,
"error": self.error,
"passed": self.passed
}
class User(db.Document): #create object for Mongo
username=db.StringField(db_field="u", required = True, unique = True) #dbfield name in Mongo: single letter to save space
password=db.StringField(db_field="p", required = True)
email=db.EmailField(db_field="e", required = True, unique = True)
first_name=db.StringField(db_field="fn", max_length=50)
last_name=db.StringField(db_field="ln", max_length=50)
created=db.IntField(db_field="c", default=now())
bio=db.StringField(db_field="b", max_length=200)
email_confirmed=db.BooleanField(db_field="ec", default=False)
change_configuration=db.DictField(db_field="cc")
profile_image = db.StringField(db_field="i", default=None)
@classmethod #for pre_save
def pre_save(cls, sender, document, **kwargs): #always called before database save
document.username = document.username.lower()
document.email = document.email.lower()
def profile_imgsrc(self, size):
if self.profile_image:
if AWS_BUCKET:
return os.path.join(AWS_CONTENT_URL, AWS_BUCKET, 'user', '%s.%s.%s.png' % (self.id, self.profile_image, size))
else:
return url_for('static', filename=os.path.join(STATIC_IMAGE_URL, 'user', '%s.%s.%s.png' % (self.id, self.profile_image, size)))
else:
return url_for('static', filename=os.path.join(STATIC_IMAGE_URL, 'user', 'no-profile.%s.png' % (size)))
meta = {
'indexes': ['username', 'email', '-created'] #create indices to sort the data
}
class User(db.Document):
user_id = db.IntField(unique=True)
first_name = db.StringField(max_length=20)
last_name = db.StringField(max_length=20)
email = db.EmailField(max_length=30, unique=True)
birthday = db.DateField()
gender = db.StringField()
address = db.StringField()
suburb = db.StringField()
postcode = db.IntField(length=4)
description = db.StringField(max_length = 200)
password = db.StringField(max_length=20)
available = db.BooleanField(default=True)
token = db.StringField()
contacts = db.ListField(Contact)
# profile_pic =
def set_password(self, password):
self.password = generate_password_hash(password)
def get_password(self, password):
return check_password_hash(self.password, password)
def assign_token(self, id):
secret = 'YUWA'
token = str(jwt.encode({'id': id}, secret, algorithm='HS256'))
self.token = token
db.Users.update(
{"_id": id},
{$set: {"token": token}}
)
return token
def invalidate_token(self, token):
self.token = ""
class User(db.Document):
username = db.StringField(db_field="u", required=True, unique=True)
password = db.StringField(db_field="p", required=True)
email = db.EmailField(db_field="e", required=True, unique=True)
first_name = db.StringField(db_field="fn", max_length=50)
last_name = db.StringField(db_field="ln", max_length=50)
created = db.IntField(db_field="c", default=now())
bio = db.StringField(db_field="b", max_length=160)
email_confirmed = db.BooleanField(db_field="ecf", default=False)
change_configuration = db.DictField(db_field="cc")
profile_image = db.StringField(db_field="i", default=None)
# Make username and email all lowercase
# This method is called before object is written to the database
@classmethod
# Do any manipulations you need to do within pre_save
def pre_save(cls, sender, document, **kwargs):
document.username = document.username.lower()
document.email = document.email.lower()
def profile_imgsrc(self, size):
# return os.path.join(IMAGE_URL, "user", "%s.%s.%s.png" % (self.id,
# self.profile_image, size))
return os.path.join(
IMAGE_URL, "user",
"{0}.{1}.{2}.png".format(self.id, self.profile_image, size))
# Add indexes
meta = {
"indexes": ["username", "email", "-created"]
# -created means sort order reversed to get most recent members
}
class User(db.Document):
# db_field='u' the first character of the field name => saves space in large
# databases
username = db.StringField(db_field='u', required=True, unique=True)
password = db.StringField(db_field='p', required=True)
email = db.StringField(db_field='e', required=True, unique=True)
first_name = db.StringField(db_field='fn', max_length=50)
last_name = db.StringField(db_field='ln', max_length=50)
# create a time stamp(NB NOT a date because a time stampe cn give more
# information). Use a helper function
created = db.IntField(db_field='c', default=now())
bio = db.StringField(db_field='b', max_length=160)
# Confirm email. Usually after registration the email of the account is verified
email_confirmed = db.BooleanField(db_field='ecf', default=False)
# A dictionary object in json format that will store the old and new email
# when the email is changing. In a transition phase
change_configuration = db.DictField(db_field='cc')
# Add the indexes by using the meta properties of the class. Give a string
# of the indexes. The minus created means that the sort order is reversed
meta = {
'indexes':['username', 'email', '-created']
}
# The @classmethod will be called prior to the save to the database
# so can make any adjustments here ie change fields to lower case
# pre_save is a mongo method
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.username = document.username.lower()
document.email = document.email.lower()
class Roles(db.Document):
titre = db.StringField()
description = db.StringField()
valeur = db.StringField()
action = db.IntField()
active = db.BooleanField(default=True)
parent = db.ReferenceField("self")
class Pet(db.Document):
external_id = db.StringField(db_field="ei")
name = db.StringField(db_field="n")
species = db.StringField(db_field="s")
breed = db.StringField(db_field="b")
age = db.IntField(db_field="a")
store = db.ReferenceField(Store, db_field="st")
price = db.DecimalField(db_field="p", precision=2, rounding='ROUND_HALF_UP')
sold = db.BooleanField(db_field="sl", default=False)
received_date = db.DateTimeField(db_field="rd")
sold_date = db.DateTimeField(db_field="sd")
live = db.BooleanField(db_field="l", default=True)
meta = {
'indexes': [('external_id', 'live'), ('species', 'live'), ('store', 'live')]
}
class User(db.Document):
user_id = db.IntField( unique=True )
first_name = db.StringField( max_length=20 )
last_name = db.StringField( max_length=20 )
email = db.StringField( max_length=30, unique=True )
password = db.StringField( max_length=20)
available = db.BooleanField( default=True )
def set_password(self, password):
self.password = generate_password_hash(password)
def get_password(self, password):
return check_password_hash(self.password, password)
#class Family(db.Document):
# class Course(db.Document):
# courseID = db.StringField( max_length=10, unique=True )
# title = db.StringField( max_length=100 )
# description = db.StringField( max_length=255 )
# credits = db.IntField()
# term = db.StringField( max_length=25 )
# class Enrollment(db.Document):
# user_id = db.IntField()
# courseID = db.StringField( max_length=10 )
class Message(db.Document):
from_user = db.ReferenceField(User, db_field="fu", reverse_delete_rule=CASCADE)
to_user = db.ReferenceField(User, db_field="tu", default=None, reverse_delete_rule=CASCADE)
text = db.StringField(db_field="t", max_length=1024)
live = db.BooleanField(db_field="l", default=True)
create_date = db.LongField(db_field="c", default=now())
parent = db.ObjectIdField(db_field="p", default=None)
images = db.ListField(db_field="ii")
message_type = db.IntField(db_field="mt", default=POST, choices=MESSAGE_TYPE)
@property
def text_linkified(self):
return linkify(self.text)
@property
def human_timestamp(self):
return ms_stamp_humanize(self.create_date)
@property
def comments(self):
return Message.objects.filter(parent=self.id, message_type=COMMENT).order_by('create_date')
@property
def likes(self):
return Message.objects.filter(parent=self.id, message_type=LIKE).order_by('-create_date')
def post_imgsrc(self, image_ts, size):
if AWS_BUCKET:
return os.path.join(AWS_CONTENT_URL, AWS_BUCKET, 'posts', '%s.%s.%s.png' % (self.id, image_ts, size))
else:
return url_for('static', filename=os.path.join(STATIC_IMAGE_URL, 'posts', '%s.%s.%s.png' % (self.id, image_ts, size)))
meta = {
'indexes': [('from_user', 'to_user', '-create_date', 'message_type', 'live')]
}
class User(db.Document, UserMixin):
email = db.StringField(required=True)
username = db.StringField(required=True)
confirmed = db.BooleanField(required=True, default=False)
password_hash = db.StringField(required=True, max_length=128)
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config["SECRET_KEY"], expiration)
return s.dumps({"confirm": self.email})
def confirm(self, token):
s = Serializer(current_app.config["SECRET_KEY"])
try:
data = s.loads(token)
except:
return False
if data.get("confirm") != self.email:
return False
self.confirmed = True
self.save()
return True
class User(BaseDocument):
name = db.StringField(verbose_name=u'name', max_length=100)
email = db.EmailField(verbose_name=u'email',
max_length=100,
required=True,
unique=True)
pw_hash = db.StringField(verbose_name=u'Password Hash',
max_length=100,
required=True)
is_superuser = db.BooleanField(verbose_name=u'Is Superuser', default=False)
meta = {'indexes': ['email']}
def __unicode__(self):
return self.name
def __init__(self, *args, **kwargs):
password = kwargs.pop('password', None)
super(User, self).__init__(*args, **kwargs)
if password:
self.set_password(password)
def set_password(self, password):
self.pw_hash = generate_password_hash(
password,
method=current_app.config['PROJECT_PASSWORD_HASH_METHOD'])
def check_password(self, password):
return check_password_hash(self.pw_hash, password)
class HostParams(db.EmbeddedDocument):
"""
Custom Params
"""
name = db.StringField()
value = db.StringField()
trigger = db.BooleanField()
class User(db.Document):
username = db.StringField(db_field="u", required=True, unique=True)
password = db.StringField(db_field="p", required=True)
email = db.EmailField(db_field="e", required=True, unique=True)
first_name = db.StringField(db_field="fn", max_length=50)
last_name = db.StringField(db_field="ln", max_length=50)
created = db.IntField(db_field="c", default=now())
bio = db.StringField(db_field="b", max_length=160)
email_confirmed = db.BooleanField(db_field="ecf", default=False)
change_configuration = db.DictField(db_field="cc")
profile_image = db.StringField(db_field="i", default=None)
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.username = document.username.lower()
document.email = document.email.lower()
def profile_imgsrc(self, size):
if self.profile_image:
if AWS_BUCKET:
return os.path.join(AWS_CONTENT_URL, AWS_BUCKET, 'user',
'%s.%s.%s.png' % (self.id, self.profile_image, size))
else:
return url_for('static', filename=os.path.join(STATIC_IMAGE_URL, 'user',
'%s.%s.%s.png' % (self.id, self.profile_image, size)))
else:
return url_for('static', filename=os.path.join(STATIC_IMAGE_URL, 'user', 'no-profile.%s.png' % (size)))
meta = {
'indexes': ['username', 'email', '-created']
}
class Email(db.EmbeddedDocument):
email_id = db.StringField(primary_key=True)
email = db.StringField()
is_primary = db.BooleanField(db_field="is_primary", default=False)
created_at = db.DateTimeField(default=datetime.now())
updated_at = db.DateTimeField()
deleted_at = db.DateTimeField()
class LabelRule(db.Document):
"""
Rule to filter Labels
"""
name = db.StringField(required=True, unique=True)
conditions = db.ListField(db.EmbeddedDocumentField(LabelCondition))
outcome = db.ListField(db.StringField(choices=label_outcome_types))
enabled = db.BooleanField()
class HostRule(db.Document):
"""
Host Rule to add custom Parameters for importers or exporters
"""
name = db.StringField(required=True, unique=True)
conditions = db.ListField(db.EmbeddedDocumentField(HostCondition))
params = db.ListField(db.EmbeddedDocumentField(HostParams))
enabled = db.BooleanField()
class Profil(db.Document):
name = db.StringField()
description = db.StringField()
active = db.BooleanField()
def count_role(self):
profil_role_exist = ProfilRole.objects(id=self.id)
return len(profil_role_exist)
class Urls_to_crawl(db.Document):
url = db.StringField(max_length=500, unique=True, required=True)
channel_id = channel_id = db.IntField()
title = db.StringField(max_length=200)
topic_id = db.IntField()
published_date = db.DateTimeField(default=datetime.now)
description = db.StringField(max_length=500)
visited = db.BooleanField(default=False)
page_depth = db.IntField(required=True)
class Customer(db.Document):
name = db.StringField()
email = db.StringField()
facebook = db.StringField()
phone = db.StringField()
current = db.BooleanField()
created_by = db.ReferenceField(User)
created_at = db.DateTimeField()
modified_at = db.DateTimeField()
class Trumptweet(db.Document):
source = db.StringField(max_length=50)
id_str = db.StringField(max_length=50)
text = db.StringField(max_length=280)
created_at = db.StringField(max_length=50)
retweet_count = db.IntField(max_length=50)
in_reply_to_user_id_str = db.StringField(max_length=50)
favorite_count = db.IntField(max_length=50)
is_retweet = db.BooleanField(max_length=50)
class Submission(db.Document):
"""A student's submission."""
created_at = db.DateTimeField(
default=datetime.datetime.utcnow, required=True)
test_results = db.ListField(
db.ReferenceField('TestResult', reverse_delete_rule=db.PULL))
processed = db.BooleanField(default=False, required=True)
submitter = db.ReferenceField('Student', required=True,
reverse_delete_rule=db.CASCADE)
project = db.ReferenceField('Project', required=True)
code = db.FileField(required=True)
compile_status = db.BooleanField(default=False, required=True)
compiler_out = db.StringField()
started_processing_at = db.DateTimeField()
finished_processing_at = db.DateTimeField()
meta = {
"indexes": [
{
"fields": ['submitter']
},
{
"fields": ['project']
}
]
}
def reset(self):
"""
Resets status as if never processed.
Note: Saves document.
"""
self.processed = False
self.compile_status = False
self.compiler_out = None
self.started_processing_at = None
self.finished_processing_at = None
for result in list(self.test_results):
for case in list(result.cases):
case.delete()
result.delete()
self.test_results = []
self.save()
class Event(db.Document):
name = db.StringField(required=True)
place = db.StringField(required=True)
location = db.PointField(required=True)
start_datetime = db.DateTimeField(required=True)
end_datetime = db.DateTimeField(required=True)
event_photo = db.StringField()
description = db.StringField(min_length=50, required=True)
host = db.ObjectIdField(required=True)
cancel = db.BooleanField(default=False)
attendees = db.ListField(db.ReferenceField(User))
class Store(db.Document):
external_id = db.StringField(db_field="ei")
neighborhood = db.StringField(db_field="n")
name = db.StringField(db_field="na")
street_address = db.StringField(db_field="sa")
city = db.StringField(db_field="c")
state = db.StringField(db_field="st")
zip = db.StringField(db_field="z")
phone = db.StringField(db_field="p")
store_id = db.StringField(db_field="si")
live = db.BooleanField(db_field="l", default=True)
meta = {'indexes': [('external_id', 'live')]}
class Booking(db.Document):
customers = db.ListField(
db.ReferenceField(Customer, reverse_delete_rule=mongoengine.PULL))
room_name = db.StringField()
check_in = db.DateTimeField()
check_out = db.DateTimeField()
deposit = db.DecimalField()
modified_at = db.DateTimeField()
ppm = db.DecimalField()
created_at = db.DateTimeField()
created_by = db.ReferenceField(User)
note = db.StringField()
room_type = db.IntField()
confirmed = db.BooleanField()
class Message(db.Document):
from_user = db.ReferenceField(User, db_field="fu", reverse_delete_rule=CASCADE)
#optional, if not set, from_user is broadcasting. If set message sent to specific person
to_user = db.ReferenceField(User, db_field="tu", default=None, reverse_delete_rule=CASCADE)
text = db.StringField(db_field="t", max_length=300)
live = db.BooleanField(db_field="l", default=None)
create_date = db.IntField(db_field="cd", default=now())
parent = db.ObjectIdField(db_field="p", default=None)
image = db.StringField(db_field="i", default=None)
meta = {
'indexes': [('from_user', 'to_user', '-create_date', 'parent', 'live')]
}
