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 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 UserLocation(db.EmbeddedDocument):
date = db.DateTimeField(default=datetime.datetime.utcnow)
position = db.GeoPointField()
duration = db.IntField(default=0)
def __str__(self):
return str(self.position.join(','))
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 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 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 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 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 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']}
