class InventoryGroup(db.Document):
name = db.StringField(max_length=200)
identifier = db.StringField(unique=True, max_length=33)
meta = {'ordering': ['name']}
def __unicode__(self):
return self.name
class InventoryItem(db.Document):
# constants
CHECKED_IN = 1
CHECKED_OUT = 2
# fields
group = db.ReferenceField(InventoryGroup, dbref=True)
name = db.StringField(max_length=255)
identifier = db.StringField(max_length=500)
comment = db.StringField(max_length=200)
date_added = db.DateTimeField()
date_updated = db.DateTimeField()
status = db.IntField(default=1, choices=INVENTORY_STATUS)
meta = {'ordering': ['name']}
def __unicode__(self):
return self.name
def get_latest_log(self):
"""Return the latest log for this item"""
try:
log = InventoryLog.objects(
item=self).order_by('-date_added').first()
if not log:
return None
except InventoryLog.DoesNotExist:
return None
return log
def get_latest_person(self):
"""Return the latest person for this item"""
log = self.get_latest_log()
if not log:
return None
return log.person
class Spot(db.Document):
name = db.StringField(required=True)
user = db.ReferenceField(User)
location = GeoPointField(required=True)
wifi = db.IntField(min_value=0, max_value=5)
power = db.BooleanField()
category = db.StringField()
comments = db.ListField(db.StringField())
creation_date = db.DateTimeField(default=datetime.datetime.utcnow)
user_url = db.StringField()
meta = {
'ordering': ['-creation_date']
}
def __str__(self):
return self.name
def to_dict(self):
data = self.to_mongo()
data['creation_date'] = str(self.creation_date.timestamp())
data['id'] = str(self.id)
del data['_id']
data['user'] = str(data['user'])
return data
def to_json(self):
return json.dumps(self.to_dict())
class Post(db.Document):
slug = db.StringField(required=True, max_length=20, unique=True)
creator = db.StringField(required=True, max_length=20)
title = db.StringField(required=True, max_length=50)
created_at = db.DateTimeField()
comments = db.ListField()
rates = db.ListField()
class Course(db.Document):
"""An AP course."""
name = db.StringField(max_length=80, unique=True)
description = db.StringField(default='')
requirements = db.StringField(default='')
upload_required = db.BooleanField(default=False)
open_for_applications = db.BooleanField(default=False)
class User(UserMixin, db.Document):
email = db.EmailField(unique=True)
password = db.StringField(required=True, min_length=32, max_length=120)
creation_date = db.DateTimeField(default=datetime.datetime.utcnow)
username = db.StringField(unique=True, required=True)
about = db.StringField()
slug = db.StringField(unique=True)
locations = db.EmbeddedDocumentListField(UserLocation, default=[])
allow_community = db.BooleanField()
current_location = GeoPointField()
socials = db.DictField()
image_path = db.ImageField(size=(600, 400), thumbnail=(200, 200))
def set_password(self, password):
self.password = generate_password_hash(password)
return self
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def avatar(self):
return '{}/{}'.format(app.config.get('AVATARS_URL'), self.id)
@property
def has_avatar(self):
return bool(self.image_path)
def clean_about(self):
self.about = (Markup(self.about.replace('<br>', '\^n^'))
.striptags().replace('\^n^', '\n'))
def __str__(self):
return str(self.username or 'Unknown')
def to_dict(self):
data = self.to_mongo()
data['id'] = str(self.id)
del data['_id']
del data['password']
return data
def save(self, *args, **kwargs):
if self.slug is None:
try:
User.objects.get(username=self.username)
# If the code above is reach on the block try, it means that
# there is a duplicate
self.username = uniquify_username(self.username)
except User.DoesNotExist:
pass
self.slug = slugify(self.username)
return super().save(*args, **kwargs)
meta = {'ordering': ['-creation_date']}
class CourseApplication(db.EmbeddedDocument):
"""An application to a course."""
course = db.ReferenceField(Course)
uploaded_content = db.ListField(db.FileField())
average_okay = db.BooleanField(default=False)
have_met_reqs = db.BooleanField(default=False)
# Status: pending, yes, maybe, no, nosampleprovided
writing_sample_status = db.StringField(default='pending')
# Status: pending, approved, rejected
status = db.StringField(default='pending')
class Repository(db.Document):
"""
Main repository document to store data in MongoDB.
"""
full_name = db.StringField()
html_url = db.URLField()
description = db.StringField()
stargazers_count = db.IntField()
language = db.StringField()
meta = {'collection': 'repository'}
class Application(db.Document):
"""An application."""
submitter = db.ReferenceField(User)
is_submitted = db.BooleanField(default=False)
submit_date = db.DateTimeField()
course_applications = db.EmbeddedDocumentListField(CourseApplication)
taking_ap_courses = db.BooleanField(default=False)
current_ap_courses = db.StringField(default='')
test_scores = db.StringField(default='')
teacher_recs = db.EmbeddedDocumentListField(TeacherRec)
confirm_contacted_teachers = db.BooleanField(default=False)
class Spot(db.Document):
name = db.StringField(required=True)
user = db.ReferenceField(User)
location = db.GeoPointField(required=True)
wifi = db.IntField(min_value=0, max_value=5)
power = db.BooleanField()
category = db.StringField()
comments = db.ListField(db.StringField())
creation_date = db.DateTimeField(default=datetime.datetime.utcnow)
meta = {'ordering': ['-creation_date']}
def __str__(self):
return self.name
class User(db.Document):
name = db.StringField(
required=True,
max_length=20,
unique=True,
)
password = db.StringField(required=True)
actions_performed = db.IntField()
cooldown_started = db.DateTimeField()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class User(db.Document):
__documentname__ = 'users'
username = db.StringField()
password = db.StringField()
def get_all():
users = User.query.all()
if users:
print(users)
return users
else:
print("no record")
def find_by_id(id):
user = User.query.get(id)
if user:
return user
else:
return {
"error": {
"statusCode": "404",
"message": "Not Found",
"name": "NOT_FOUND"
}
}
def create(self):
db.session.save(self)
return "saved"
def update(self, data: dict):
for field, value in data.items():
setattr(self, field, value)
db.session.save(self)
return "updated"
def delete(self):
db.session.remove(self)
return 'removed'
class User(db.Document):
name = db.StringField(max_length=120, unique=True)
email = db.StringField(max_length=150) # user id
password = db.StringField(max_length=250)
is_admin = db.BooleanField(default=False)
meta = {'ordering': ['name']}
# Flask-Login integration
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 __unicode__(self):
return self.email
class User(db.Document, UserMixin):
"""A user account object."""
name = db.StringField(max_length=255)
email = db.EmailField(max_length=255, unique=True)
password = db.StringField(max_length=255)
phone_number = db.StringField(max_length=255)
parent_name = db.StringField(max_length=255)
parent_phone_number = db.StringField(max_length=255)
parent_email = db.StringField(max_length=255)
entering_grade = db.IntField()
is_first_year_at_wshs = db.BooleanField(default=False)
roles = db.SortedListField(db.ReferenceField(Role), default=[])
active = db.BooleanField(default=True)
class AiImplementation(db.Document):
# todo: the id field does not show in swagger responses / model documentation
id = db.ObjectIdField(db_field="_id", primary_key=True, default=ObjectId)
name = db.StringField()
endpoint = db.StringField()
class Article(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=True)
creation_date = db.DateTimeField(default=datetime.datetime.utcnow)
slug = db.StringField(required=True, default='no-title')
author = db.ReferenceField(User, reverse_delete_rule='NULLIFY')
language = db.StringField(min_length=2, max_length=2, default='en')
images = db.ListField()
publication_date = db.DateTimeField()
published = db.BooleanField(default=False)
def __str__(self):
return str(self.title)
def get_author(self):
try:
return self.author
except DoesNotExist:
return User.objects.get(slug='neomad')
def extract_images(self):
"""
Extract images from the content, resize and save them locally if they
are base64 encoded.
Saves the list of images into the images list property.
"""
html = BeautifulSoup(self.content, 'html.parser')
images = []
try:
os.makedirs(self.get_images_path())
except FileExistsError:
pass
for img in html.find_all('img'):
data = img.get('src')
if is_base64(data):
m = hashlib.md5()
m.update(data.encode('utf-8'))
img_name = m.hexdigest()
img_path = '{}/{}'.format(self.get_images_path(), img_name)
img_url = '{}/{}'.format(self.get_images_url(), img_name)
save_base64_image(data, img_path, (1000, 800))
img['src'] = img_url
images.append(img_url)
else:
images.append(data)
for outdated_image in set(self.images) - set(images):
os.remove(
os.path.join(self.get_images_path(),
os.path.basename(outdated_image)))
self.images = images
def get_images_path(self):
return '{}/{}'.format(app.config['ARTICLE_IMG_PATH'], self.id)
def get_images_url(self):
return '{}/{}'.format(app.config['ARTICLE_IMG_URL'], self.id)
@property
def image(self):
if len(self.images):
return self.images[0]
def delete(self, *args, **kwargs):
parent = super(Article, self).delete(*args, **kwargs)
path = self.get_images_path()
shutil.rmtree(path)
return parent
def save(self, *args, **kwargs):
self.slug = slugify(self.title)
is_new = not self.id
# when new, the id must exist before extracting images
if is_new:
super(Article, self).save(*args, **kwargs)
self.extract_images()
self.title = Markup(self.title).striptags()
self.content = clean_html(self.content, ALLOWED_TAGS)
self.language = detect(self.content)
morph = self.morph()
if self != morph:
morph.pre_save(*args, **kwargs)
return super(Article, self).save(*args, **kwargs)
def morph(self):
if (self.content and 'https://steemit.com/' in self.content):
match = re.match('.*(https://steemit.com/[^<\s.]*)', self.content)
url = match.groups()[0]
return SteemitArticle(article=self, url=url)
return self
meta = {
'ordering': ['-publication_date'],
'indexes': ['-publication_date']
}
class Teacher(db.Document):
"""A teacher."""
name = db.StringField(unique=True)
email = db.StringField(required=False)
is_pseudo = db.BooleanField(default=False)
class Person(db.Document):
name = db.StringField(max_length=120, unique=True)
meta = {'ordering': ['name']}
def __unicode__(self):
return self.name
class InventoryLog(db.Document):
person = db.ReferenceField(Person, dbref=True)
item = db.ReferenceField(InventoryItem, dbref=True)
status = db.IntField(default=2, choices=INVENTORY_STATUS)
date_added = db.DateTimeField(default=datetime.now)
checkout_meta = db.EmbeddedDocumentField(CheckoutMeta)
meta = {'ordering': ['-date_added']}
person_name = db.StringField(max_length=250)
def __unicode__(self):
return u'%s - %s' % (self.status, self.date_added)
@classmethod
def add_log(cls, person, item, status, checkout_meta, **kwargs):
log = InventoryLog(person=person,
item=item,
status=int(status),
date_added=datetime.now(),
checkout_meta=checkout_meta)
if person.name:
log.person_name = kwargs.get('person_name', person.name)
log.save()
return log
def get_person_name(self):
"""Returns the name of the person assigned to this log"""
if isinstance(self.person, Person):
return self.person.name
# return known/alt person name
return self.person_name
def get_checkout_description(self):
"""Returns a human-readable description for the checkout"""
name = u''
if not self.checkout_meta:
return name
# no duration, then assume default
duration = self.checkout_meta.duration
if not duration:
return u'soon'
# determine name of duration
dtype = self.checkout_meta.duration_type
if dtype == CheckoutMeta.DURATION_TYPE_UNKNOWN:
return u'soon'
elif dtype == CheckoutMeta.DURATION_TYPE_MINS:
name = u'min'
elif dtype == CheckoutMeta.DURATION_TYPE_HOURS:
name = u'hr'
elif dtype == CheckoutMeta.DURATION_TYPE_DAYS:
name = u'day'
# format OOO
ooo_str = ''
if self.checkout_meta.is_ooo:
ooo_str = ' OOO'
# pluralize name
if duration > 1:
name += u's'
description = u'{duration:.0f} {dname}{ooo}'.format(duration=duration,
dname=name,
ooo=ooo_str)
return description
def get_date_added(self):
"""Returns a formatted date added value"""
# ref: http://docs.python.org/2/library/time.html#time.strftime
return self.date_added.strftime(
settings.INVENTORY_CHECKOUT_DATE_FORMAT)
class TeacherRec(db.EmbeddedDocument):
"""A particular recommendation from a teacher about a student."""
teacher = db.ReferenceField(Teacher)
# Status: pending, recommend, withreservations, donotrecommend
status = db.StringField(default='pending')
rationale = db.StringField()
class Role(db.Document, RoleMixin):
"""A role given to a user."""
name = db.StringField(max_length=80, unique=True)
description = db.StringField(max_length=255)
class Article(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=True)
creation_date = db.DateTimeField(default=datetime.datetime.utcnow)
slug = db.StringField(required=True, default='no-title')
author = db.ReferenceField(User)
language = db.StringField(min_length=2, max_length=2, default='en')
images = db.ListField()
def __str__(self):
return str(self.title)
def extract_images(self):
"""
Extract images from the content, resize and save them locally if they
are base64 encoded.
Saves the list of images into the images list property.
"""
html = BeautifulSoup(self.content, 'html.parser')
images = []
try:
os.makedirs(self.get_images_path())
except FileExistsError:
pass
for img in html.find_all('img'):
data = img.get('src')
if is_base64(data):
m = hashlib.md5()
m.update(data.encode('utf-8'))
img_name = m.hexdigest()
img_path = '{}/{}'.format(self.get_images_path(), img_name)
img_url = '{}/{}'.format(self.get_images_url(), img_name)
save_base64_image(data, img_path, (1000, 800))
img['src'] = img_url
images.append(img_url)
else:
images.append(data)
self.images = images
self.content = str(html)
def get_images_path(self):
return '{}/{}'.format(app.config['ARTICLE_IMG_PATH'], self.id)
def get_images_url(self):
return '{}/{}'.format(app.config['ARTICLE_IMG_URL'], self.id)
@property
def image(self):
if len(self.images):
return self.images[0]
def delete(self, *args, **kwargs):
parent = super(Article, self).delete(*args, **kwargs)
path = self.get_images_path()
shutil.rmtree(path)
return parent
def save(self, *args, **kwargs):
if not self.creation_date:
self.creation_date = datetime.datetime.utcnow()
self.slug = slugify(self.title)
is_new = not self.id
# when new, the id must exist before extracting images
if is_new:
super(Article, self).save(*args, **kwargs)
self.extract_images()
self.title = Markup(self.title).striptags()
self.content = clean_html(self.content, ALLOWED_TAGS)
self.language = detect(self.content)
return super(Article, self).save(*args, **kwargs)
meta = {'ordering': ['-creation_date']}
