class WorkOrder(BaseRecord):
# constructor:
workOrderName = StringField(max_length=15, required=True, unique=True)
dateReceived = DateField(required=True, default=dt.datetime.now())
detail = StringField(defualt='') # multiline
requestingContact = StringField(required=True)
priority = StringField(required=True)
statusCode = StringField(
max_length=30,
required=True) # choices: Pending Materials, Ready Now, Other
requestCode = StringField(max_length=30,
required=True) # choices: P-4, P-48, Other
dateCompleted = DateField(required=True)
inspectForStoreFile = FileField()
detailedReceiptFile = FileField()
signageMapFile = FileField()
partsArrivalDate = DateField()
targetStartDate = DateField(required=True)
fkWorkOrderStatus = ReferenceField('WorkOrderStatus',
required=True,
dbref=False)
fkStoreNumber = ReferenceField('Store', required=True, dbref=False)
meta = {'collection': 'WorkOrder'}
def to_file(self):
return GridFSProxy(self)
def __str__(self):
return f'{self.workOrderName} - {self.fkWorkOrderStatus.status}'
class Message(Document):
nickname = StringField(required=True)
text = StringField(required=True)
date = DateTimeField(required=True, default=datetime.datetime.now)
image_filename = StringField()
image = FileField()
thumb = FileField()
class Job(db.Document):
company = StringField(required=True)
position = StringField(required=True)
status = StringField(required=True)
notes = StringField(required=True)
resume = FileField(required=False, collection_name="resume")
coverletter = FileField(required=False, collection_name="coverletter")
added_by = ReferenceField('User')
class Frame(Document):
name = StringField(required=True, max_length=200, unique=True)
data = FileField()
metadata = DictField(default={})
@property
def frame(self):
str_data = BytesIO(self.data.read()).read().decode()
try:
return pd.read_json(str_data, typ="frame", orient="split")
except ValueError:
return pd.read_json(str_data, typ="series", orient="split")
def __str__(self):
return "{name}: \n{frame}".format(name=self.name, frame=self.frame)
def put(self, frame):
if self.data:
self.data.replace(frame.to_json(orient="split").encode())
else:
self.data.new_file()
self.data.write(frame.to_json(orient="split").encode())
self.data.close()
self.save()
return self.reload()
class Song(Document):
artist = ReferenceField(Artist)
name = StringField(required=True, unique=True, max_length=200)
duration = StringField(required=True)
size = StringField(required=False, default='0 Mb')
download_url = URLField(required=True)
audio_file = FileField(required=False)
created_at = DateTimeField(default=datetime.now())
meta = {'queryset_class': CustomQuerySet}
def to_json(self, *args, **kwargs):
media = kwargs.pop('media', '')
data = self.to_mongo()
if media:
song_name = '-'.join(re.split("[, \-!?:]+", self.name))
file_name = os.path.join(AUDIO,
'{}-{}.{}'.format(song_name, DATE, 'mp3'))
with open(file_name, 'wb') as song_file:
song_file.write(self.audio_file.read())
data['audio_file'] = file_name
else:
data.pop('audio_file')
data['artist'] = self.artist.name
data['created_at'] = data['created_at'].strftime(TIME_FORMAT)
data.pop('_id')
return json_util.dumps(data, *args, **kwargs)
class User(Document):
nickname = StringField(required=True, min=8, max=16)
name = StringField(max=126)
password = StringField(required=True, min=8, max=16)
email = StringField(required=True, max=128)
active = BooleanField(default=False)
photo = FileField(default=settings.DEFAULT_PHOTO)
class challange(Document):
done_by = ObjectIdField()
clanChallange_id = ObjectIdField()
accepted_by_head = BooleanField(default=False)
sent_for_review = BooleanField(default=False)
discription = StringField(max_length=1000)
proof_of_completion = FileField()
class VCSSystem(Document):
"""
VCSSystem class.
Inherits from :class:`mongoengine.Document`
Index: #url
ShardKey: #url
:property url: (:class:`~mongoengine.fields.StringField`) url to the repository
:property project_id: (:class:`~mongoengine.fields.ObjectIdField`) :class:`~pycoshark.mongomodels.Project` id to which this vcs system belongs
:property repository_type: (:class:`~mongoengine.fields.StringField`) type of the repository (e.g., git)
:property last_updated: (:class:`~mongoengine.fields.DateTimeField`) date when the data in the database for this repository was last updates
"""
meta = {
'collection': 'vcs_system',
'indexes': ['#url'],
'shard_key': ('url', ),
}
# PK: url
# Shard Key: hashed url
url = StringField(required=True, unique=True)
project_id = ObjectIdField(required=True)
repository_type = StringField(required=True)
last_updated = DateTimeField()
submodules = ListField(ObjectIdField())
repository_file = FileField(collection_name='repository_data')
class Uploads(Document):
"""
Uploads : Contains informaiton about file that have been uploaded by the user
Fields
----------
file_name : Character String
The name of the file
location : Character String
The location of the uploaded file
uploader : Document
Information about the faculty member who uploaded the file
time : Datetime
The time the file was uploaded to the database
"""
file_name = StringField(required=True, unique=True)
location = StringField(required=True)
uploader = StringField(required=True)
upload_time = DateTimeField(required=True)
file = FileField(required=True)
meta = {
'indexes': [
'file_name',
'$file_name',
'location',
]
}
class User(Document):
gfname = StringField()
glname = StringField()
email = EmailField()
aeriesid = IntField()
gid = StringField(unique=True)
# App Admin, Student
role = StringField()
issenior = BooleanField(default=False)
admin = BooleanField(default=False)
pronouns = StringField()
fname = StringField()
lname = StringField()
image = FileField()
birthdate = DateField()
personalemail = EmailField()
mobile = StringField()
address = StringField()
city = StringField()
state = StringField()
zipcode = IntField()
socmedia = StringField()
nextyr = StringField()
invitelist = ListField()
meta = {'ordering': ['+glname', '+gfname']}
class BaseTextGridDocument(Document):
textgrid_file = FileField(required=True)
task = ReferenceField('BaseTask')
checking_scheme: TextGridCheckingScheme = ReferenceField(TextGridCheckingScheme)
creators: List['User'] = ListField(ReferenceField('User'))
creation_time = DateTimeField(default=datetime.now, required=True)
meta = {'allow_inheritance': True,
'abstract': True}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._textgrid_obj: TextGrid = None
@classmethod
def from_textgrid(cls, tg: Union[TextGrid, str],
creators: List['Annotator'],
task: 'BaseTask'):
if task is not None:
checking_scheme = task.campaign.checking_scheme
else:
checking_scheme = None
if isinstance(tg, TextGrid):
tg_file = tg_to_str(tg).encode(encoding='utf-8')
elif isinstance(tg, str):
tg_file = tg.encode('utf-8')
else:
raise TypeError("Unsupported textgrid object type %s")
return cls(textgrid_file=tg_file, task=task, creators=creators,
checking_scheme=checking_scheme)
@property
def textgrid(self):
if self._textgrid_obj is None:
# TODO : make sure to catch a potential textgrid parsing error somewhere
self._textgrid_obj = open_str_textgrid(self.textgrid_file.read().decode("utf-8").strip())
return self._textgrid_obj
@textgrid.setter
def textgrid(self, tg: Union[TextGrid, str]):
if isinstance(tg, str):
self.textgrid_file.put(tg.encode("utf-8"))
elif isinstance(tg, TextGrid):
self._textgrid_obj = tg
self.textgrid_file.put(tg_to_str(tg).encode("utf-8"))
else:
raise ValueError("Expecting textgrid in string format or as a TextGrid object")
def to_str(self):
return self.textgrid_file.read().decode("utf-8")
def check(self):
raise NotImplemented()
@property
def task_tg_msg(self):
return {
"id": self.id,
"creators": [annotator.short_profile for annotator in self.creators],
"created": self.creation_time
}
class User(gj.Document):
phonenumber = StringField(required=True, unique=True)
password = StringField(required=True, min_length=6)
firstname = StringField(required=True)
lastname = StringField(required=True)
username = StringField(required=True)
birthday = StringField(required=True)
blocks = ListField(ReferenceField('User'))
avatar = FileField(default=None)
uuid = StringField(required=True)
verify = BooleanField()
creation_date = DateTimeField()
modified_date = DateTimeField(default=datetime.datetime.now)
def hash_password(self):
self.password = generate_password_hash(self.password).decode('utf8')
def default(self):
self.username = self.firstname + " " + self.lastname
self.uuid = str(uuid.uuid4())
self.verify = False
with open('app/model/default.jpg', 'rb') as fd:
self.avatar.put(fd, content_type='image/jpeg')
# self.blocks = []
def check_password(self, password):
return check_password_hash(self.password, password)
def check_uuid(self, uuid):
return self.uuid == uuid
def save(self, *args, **kwargs):
if not self.creation_date:
self.creation_date = datetime.datetime.now()
self.modified_date = datetime.datetime.now()
return super(User, self).save(*args, **kwargs)
def update_username(self, firstname="", lastname=""):
if firstname == "":
firstname = self.firstname
if lastname == "":
lastname = self.lastname
self.username = firstname + " " + lastname
def compare_password(self, password, new_password):
lcs = pylcs.lcs(password, new_password)
if (lcs / len(new_password)) < 0.8:
return True
return False
def get_user_dic(self):
res = {"user": self.id, "username": self.username}
return res
def get_user_embedded(self):
res = UserEmbedd()
res.user = self.id
res.username = self.username
return res
class ImageDoc(Document):
id_no = SequenceField()
description = StringField()
#asfdffimage = ImageField(thumbnail_size=(120, 100, True))
image = FileField() # sdf
url = StringField()
create = DateTimeField(default=datetime.datetime.now)
class News(Document):
author = ReferenceField(Account, reverse_delete_rule=CASCADE)
discription = StringField(max_length=140)
picture = ImageField()
voice = FileField()
comments = ListField(EmbeddedDocumentField(Comment))
good = ReferenceField(Goods)
time = DateTimeField(default=datetime.datetime.now)
class ProjectMeta(EmbeddedDocument):
version = StringField(required=True, default="latest")
status = StringField(
choices=["NEW", "UPDATE", "REJECTED", "APPROVED", "PRODUCTION"], required=True
)
status_date = DateTimeField(default=datetime.utcnow, required=True)
status_user = ReferenceField(User, required=True)
installation_date = DateTimeField()
installation_company = ReferenceField(ExternalCompany)
maintainer = ReferenceField(ExternalCompany)
commune = ReferenceField(Commune)
img = FileField()
pdf_data = FileField()
pedestrian_demand = BooleanField()
pedestrian_facility = BooleanField()
local_detector = BooleanField()
scoot_detector = BooleanField()
class RawFile(Document):
file = FileField()
created_at = DateTimeField(default=datetime.datetime.utcnow, required=True)
request = LazyReferenceField(Request,
required=False,
reverse_delete_rule=CASCADE)
meta = {"queryset_class": FileFieldHandlingQuerySet}
class File(Document):
name = StringField(primary_key=True)
endpoint = StringField()
checksum = StringField()
size = StringField()
timestamp = DateTimeField(default=datetime.datetime.now)
last_modified = DateTimeField(default=datetime.datetime.now)
user_uuid = StringField()
file_content = FileField()
class Analysis(Document):
name = StringField(required=True)
input = FileField()
def __unicode__(self):
return self.name
def __repr__(self):
return self.name
class Tasks(Document):
user_id = StringField(required=True)
community_id = StringField(required=True)
album_id = StringField(required=True)
album_name = StringField(required=True)
archive = FileField()
created_at = DateTimeField(default=datetime.now)
meta = {'collection': 'tasks'}
def getFileField(db_alias=DEFAULT_CONNECTION_NAME, collection_name="fs", **kwargs):
"""
Determine if the admin has configured CRITs to utilize GridFS or S3 for
binary storage.
"""
if settings.FILE_DB == settings.GRIDFS:
return FileField(db_alias, collection_name, **kwargs)
elif settings.FILE_DB == settings.S3:
return S3FileField(db_alias, collection_name, **kwargs)
class Posts(Document):
user = ReferenceField(Users)
description = StringField(max_length=280)
photo = FileField()
fishes = ListField(StringField())
post_date = DateTimeField(default=datetime.datetime.utcnow)
comments = ListField(EmbeddedDocumentField(Comment))
def __repr__(self):
return f"Post({self.user}, {self.description})"
class Users(Document, UserMixin):
first_name = StringField(max_length=50)
last_name = StringField(max_length=50)
email = StringField(required=True)
password = StringField()
profile_picture = FileField(default="/static/images/img_avatar1.png")
huddle = ListField(StringField())
def __repr__(self):
return f"User({self.first_name}, {self.last_name}, {self.email})"
class Book(Document):
title = StringField()
author = StringField()
description = StringField()
publisher = StringField()
genre = StringField()
publishing_date = IntField()
img = FileField()
rating = FloatField()
price = FloatField()
class GroupPost(Document):
description = StringField()
image = FileField()
likes = IntField(default=0)
likedBy = ListField(ObjectIdField())
comments = ListField(ObjectIdField())
reports = IntField(default=0)
reportedBy = ListField(ObjectIdField())
owner = ObjectIdField()
createdAt = DateTimeField(default=datetime.now())
class Attachment(EmbeddedDocument):
"""
An attachment (file) on a ticket
"""
def __hash__(self):
return self.owner.__hash__() * (31 * self.title.__hash__())
owner = ReferenceField(User, required=True)
files = ListField(FileField())
title = StringField()
class Verb(Document):
verb_name = StringField(required=True, unique=True, max_length=500)
eng_meaning = StringField(required=True, max_length=500)
hin_meaning = StringField(required=True, max_length=500)
satz = StringField(required=True, max_length=1000)
level = StringField()
type = StringField()
subtype = StringField()
case = StringField()
input_pic = FileField()
class Users(Document):
email = EmailField(required=True)
password = StringField(required=True)
first_name = StringField(max_length=50)
last_name = StringField(max_length=50)
daily_steps = DictField(default={})
achievements = ListField(default=[])
photo = FileField()
daily_steps = DictField(default={})
achievements = ListField(default=[])
class Record(Document):
title = StringField(max_length=100)
comment = StringField()
created_time = ComplexDateTimeField(default=now)
finished_time = ComplexDateTimeField(default=now)
modified_time = ComplexDateTimeField(default=now)
hidden = BooleanField(default=False)
children = ListField(ReferenceField('Record'))
config=DictField()
setting=DictField()
tags = ListField(StringField(max_length=50))
datafield = FileField(collection_name='data')
imagefield = FileField(collection_name='images')
imagefields = ListField(BinaryField())
work = ReferenceField('CodeSnippet')
notebook = ReferenceField('Notebook')
notebook_index = IntField(min_value=0)
def __repr__(self):
return 'Record(title=%s, finished_time=%s, tags=%s)' % (
self.title, self.finished_time, self.tags)
@property
def data(self):
return from_pickle(self.datafield)
@property
@functools.lru_cache(maxsize=1)
def image(self):
return from_pickle(self.imagefield)
def set_data(self, obj, content_type='application/octet-stream'):
if self.datafield is None:
self.datafield.put(to_pickle(obj), content_type=content_type)
else:
self.datafield.replace(to_pickle(obj), content_type=content_type)
def set_image(self, img, content_type='image/png'):
if self.imagefield is None:
self.imagefield.put(to_pickle(img), content_type=content_type)
else:
self.imagefield.replace(to_pickle(img), content_type=content_type)
class Report(db.Document):
REPORT_STATUS_CODE_OK = 0
REPORT_STATUS_CODE_FAILURE = 1
REPORT_STATUS_CODES = (
(REPORT_STATUS_CODE_OK, 'OK'),
(REPORT_STATUS_CODE_FAILURE, 'FAIL'),
)
analysis_system = ReferenceField(AnalysisSystem, required=True)
sample = ReferenceField(Sample, required=True)
analysis_date = DateTimeField()
upload_date = DateTimeField(default=TimeFunctions.get_timestamp, required=True)
status = IntField(choices=REPORT_STATUS_CODES, default=REPORT_STATUS_CODE_OK, required=True)
error_message = StringField(null=True, required=False)
tags = ListField(StringField())
additional_metadata = DictField()
json_report_objects = MapField(field=FileField())
raw_report_objects = MapField(field=FileField())
meta = {
'ordering': ['-upload_date'],
'indexes': ['upload_date']
}
def __repr__(self):
return '[Report] {} on {}'.format(self.sample.id, self.analysis_system.identifier_name)
def __str__(self):
return self.__repr__()
def _add_report_object(self, file, target):
proxy = GridFSProxy()
proxy.put(file)
target[file.name] = proxy
def add_json_report_object(self, file):
self._add_report_object(file, self.json_report_objects)
def add_raw_report_object(self, file):
self._add_report_object(file, self.raw_report_objects)
class community(Document):
name = StringField(max_length=200)
discription = StringField(max_length=200)
no_of_participants = IntField(default=0)
Heads = ListField(ObjectIdField())
participants = ListField(ObjectIdField())
group_challanges = ListField(ObjectIdField())
messages = ListField(ObjectIdField())
community_blog = ListField(ObjectIdField())
photo = FileField()
createdAt = DateTimeField(default=datetime.now())
