class User(UserMixin, db.Document):
meta = {'collection': 'users'}
username = db.StringField(max_length=20)
email = db.StringField(max_length=30)
password = db.StringField()
image_file = db.StringField(default='default.jpg')
bio = db.StringField(max_length=200, default='This is my bio...')
entries = db.LazyReferenceField('Calculation')
models = db.LazyReferenceField('UserModel')
posts = db.LazyReferenceField('Post')
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
def get_entries(self):
return Calculation.objects(owner=self.id)
def get_models(self):
return UserModel.objects(owner=self.id)
class Ticket(db.Document):
title = db.StringField(min_length=5, max_length=50, required=True)
price = db.FloatField(min_value=1, required=True)
user_id = db.StringField(required=True)
order_id = db.StringField(default=None)
version = db.IntField(default=0)
def response(self):
return {
"id": str(self.id),
"title": self.title,
"price": self.price,
"user_id": self.user_id,
"order_id": self.order_id,
"version": self.version
}
def update_version_if_record_exists(self):
if not self.id:
return
existing_record = Ticket.objects(id=self.id)
if existing_record:
self.version += 1
def save(self, *args, **kwargs):
self.update_version_if_record_exists()
super().save(*args, **kwargs)
class Order(db.Document):
user_id = db.StringField()
status = db.StringField(choices=tuple(
types.get_events(types.EventType.Order())),
default=types.EventType.Order.CREATED)
expires_at = db.DateTimeField(
default=datetime.datetime.now() +
datetime.timedelta(minutes=Config.ORDER_EXPIRE_TIME_MIN))
ticket = db.ReferenceField('Ticket')
version = db.IntField(default=0)
def response(self):
return {
"id": str(self.id),
"user_id": self.user_id,
"status": self.status,
"expires_at": str(self.expires_at),
"ticket": self.ticket.response(),
"version": self.version
}
def update_version_if_record_exists(self):
if not self.id:
return
existing_record = Order.objects(id=self.id)
if existing_record:
self.version += 1
def save(self, *args, **kwargs):
self.update_version_if_record_exists()
super().save(*args, **kwargs)
class Post(UserMixin, db.Document):
meta = {'collection': 'posts'}
title = db.StringField(max_length=30)
date = db.DateTimeField()
content = db.StringField(max_length=1000)
author = db.StringField(max_length=30)
tags = db.ListField()
owner = db.LazyReferenceField('User')
class User(UserMixin, db.Document):
phonenumber = db.StringField(max_length=13, required=True, unique=True)
email = db.EmailField(max_length=128)
password = db.StringField(min_length=8, max_length=128, required=True)
fname = db.StringField(max_length=128)
lname = db.StringField(max_length=256)
sex = db.StringField()
age = db.StringField(min_length=1, max_length=2)
address = db.StringField()
melli_code = db.StringField(min_length=10, max_length=10)
role = db.StringField(default=ROLES['USER'], choices=ROLES)
datetime = db.DateTimeField()
# phonenumber_status = db.StringField(default=USER_INFO_STATUS['PENDING'])
# email_status = db.StringField(default=USER_INFO_STATUS['NOT_FILLED'])
# melli_code_status = db.StringField(default=USER_INFO_STATUS['NOT_FILLED'])
# status = db.StringField(default=USER_STATUS['ACTIVE'], choices=USER_STATUS)
# authorization_errors = db.ListField(db.EmbeddedDocumentField(AuthorizationError))
# email_notifications = db.ListField(db.StringField(choices=EMAIL_NOTIFICATION))
# email_verification_code = db.StringField()
meta = {'indexes': ['phonenumber']}
def register(self):
pass
class InvitationNotification(GenericNotification):
params = {'inviter_id': 'inviter_name', 'task_id': 'task_name'}
contents = {
'en': '{inviter_name} invites you to join {task_name}.',
'zh': '{inviter_name}邀请你加入{task_name}。'
}
_cls = 'InvitationNotification'
inviter_id = db.StringField(max_length=40, required=True, null=False)
task_id = db.StringField(max_length=40, required=True, null=False)
class ClubEvent(BaseDocument):
name = db.StringField(required=True)
image = db.ImageField(size=(500, 500), thumbnail_size=(20, 20))
tags = db.ListField(db.StringField())
presenter = db.EmbeddedDocumentField(Presenter)
start = db.DateTimeField(requried=True)
end = db.DateTimeField(requried=True)
description = db.StringField()
location = db.StringField()
meta = {"ordering": ["start"]}
class Event(BaseDocument):
name = db.StringField(unique=True, required=True)
date_time = db.DateTimeField(required=True)
description = db.StringField()
image = db.URLField()
link = db.URLField(required=True)
end_date_time = db.DateTimeField(required=True)
attendees_count = db.IntField()
event_status = db.StringField()
event_type = db.StringField()
loc = db.StringField()
class Model(UserMixin, db.Document):
meta = {'collection': 'models'}
keep = db.BooleanField(default=True)
mod_type = db.StringField(max_length=3, choices=TYPES)
ticker = db.StringField(max_length=6)
period = db.StringField(max_length=6)
interval = db.StringField(max_length=6)
money = db.FloatField()
buy = db.FloatField()
sell = db.FloatField()
av_length = db.IntField()
trade_cost = db.FloatField()
class UserModel(UserMixin, db.Document):
meta = {'collection': 'user_models'}
name = db.StringField(max_length=30)
mod_type = db.StringField(max_length=3, choices=TYPES)
period = db.StringField(max_length=6)
interval = db.StringField(max_length=6)
money = db.FloatField()
buy = db.FloatField()
sell = db.FloatField()
av_length = db.IntField()
trade_cost = db.FloatField()
owner = db.LazyReferenceField('User')
class Feed(db.Document):
title = db.StringField()
url = db.StringField(required=True)
articles = db.ListField(db.ReferenceField("Article"))
users = db.ListField(db.ReferenceField("User"))
def as_dict(self):
return dict(title=self.title, url=self.url)
def __repr__(self):
return '<Feed %r (%s)>' % (self.title, self.url)
class Patient(db.Document):
ssnid = db.StringField(max_length=9, unique=True)
patientId = db.IntField()
name = db.StringField(required=True)
age = db.IntField(max_length=3)
address = db.StringField()
dateOfJoining = db.StringField()
roomType = db.StringField()
city = db.StringField()
state = db.StringField()
pharmacy = db.ListField(db.StringField())
diagnostics = db.ListField(db.StringField())
status = db.StringField(default="active")
class Vote(db.Document):
CUSTOM_VOTE_ID = 6
voteFields = {
1: 'Easy to read',
2: 'Easy to use',
3: 'Internet of things opportunities',
4: 'Asynchronous coding benefits',
5: 'Multiparadigm approach bests Java'
}
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
ip = db.StringField(max_length=15, required=True)
votes = db.DictField(required=True)
def get_absolute_url(self):
return url_for('post', kwargs={"slug": self.slug})
def __unicode__(self):
return self.title
def get_vote_title(self, vote_id):
"""
Get title by identifier
:type vote_id: int
"""
vote_id = int(vote_id)
return self.voteFields[vote_id] if vote_id in self.voteFields.keys(
) else None
meta = {
'allow_inheritance': True,
'indexes': ['-created_at', 'ip'],
'ordering': ['-created_at']
}
class Sponsor(BaseDocument):
private_fields = [
"id",
]
sponsor_name = db.StringField(unique=True, required=True)
description = db.StringField()
logo = db.URLField()
subscription_tier = db.StringField()
socials = db.DictField()
sponsor_website = db.URLField()
def to_mongo(self, *args, **kwargs):
data = super().to_mongo(*args, **kwargs)
return data
class Check(UserMixin, db.Document):
meta = {'collection': 'checks'}
ticker = db.StringField()
name = db.StringField()
previous_close = db.FloatField()
three_mo_avg_vol = db.FloatField()
year_range = db.StringField()
def get_info(self):
stock = yf.Ticker(self.ticker)
info = stock.info
if info['quoteType'] == 'EQUITY':
self.name = info['longName']
self.previous_close = info['regularMarketPreviousClose']
self.three_mo_avg_vol = info['averageDailyVolume3Month']
self.year_range = info['fiftyTwoWeekRange']
self.save()
return self.id
class Subscriber(BaseDocument):
cellphone = db.StringField()
email = db.EmailField()
vaccine_site = db.ListField(db.ReferenceField(Maps))
def to_mongo(self, *args, **kwargs):
data = super().to_mongo(*args, **kwargs)
data["vaccine_site"] = [s.name for s in self.vaccine_site]
return data
class Hacker(BaseDocument): # Stored in the "user" collection
meta = {"indexes": ["email"]}
private_fields = ["id", "email_token_hash"]
first_name = db.StringField()
last_name = db.StringField()
birthday = db.DateTimeField()
country = db.StringField()
phone_number = db.StringField()
isaccepted = db.BooleanField(default=False)
can_share_info = db.BooleanField(default=False)
rsvp_status = db.BooleanField(default=False)
beginner = db.BooleanField(default=False)
ethnicity = db.StringField()
pronouns = db.StringField()
edu_info = db.EmbeddedDocumentField(Education_Info)
resume = db.ReferenceField(Resume)
socials = db.EmbeddedDocumentField(Socials)
why_attend = db.StringField()
what_learn = db.ListField()
in_person = db.BooleanField(default=False)
dietary_restrictions = db.StringField()
email = db.EmailField(unique=True, required=True)
date = db.DateTimeField(default=datetime.utcnow)
mlh = db.EmbeddedDocumentField(MLH_Authorizations)
def encode_email_token(self) -> str:
"""Encode the email token"""
email_token = encode_jwt(sub=self.email)
conf = app.config["BCRYPT_LOG_ROUNDS"]
email_token_hash = bcrypt.generate_password_hash(email_token, conf)
self.modify(set__email_token_hash=email_token_hash)
self.save()
return email_token
@staticmethod
def decode_email_token(email_token: str) -> str:
"""Decodes the email token"""
return decode_jwt(email_token)["sub"]
@classmethod
def pre_delete(cls, sender, document, **kwargs):
if document.resume:
document.resume.delete()
class User(db.Document):
email = db.EmailField()
password = db.StringField()
def response(self):
return {"id": str(self.id), "email": self.email}
def hash_password(self):
self.password = hash_password(self.password)
return self
def check_password(self, password):
return check_password(self.password, password)
class Presenter(db.EmbeddedDocument):
name = db.StringField()
image = db.ImageField(size=(500, 500), thumbnail_size=(20, 20))
class Education_Info(db.EmbeddedDocument):
college = db.StringField()
major = db.StringField()
graduation_date = db.StringField()
level_of_study = db.StringField()
class Calculation(UserMixin, db.Document):
meta = {'collection': 'entries'}
keep = db.BooleanField(default=True)
date_stamp = db.StringField(max_length=40)
type_info = db.StringField()
buy = db.FloatField()
sell = db.FloatField()
av_length = db.IntField()
ticker = db.StringField()
period = db.StringField()
interval = db.StringField()
money = db.FloatField()
trade_cost = db.FloatField()
owner = db.LazyReferenceField('User')
final_money = db.FloatField()
final_owned = db.FloatField()
final_liquid = db.FloatField()
td = db.ListField()
tt = db.ListField()
ty = db.ListField()
tp = db.ListField()
tv = db.ListField()
graph_x = db.ListField()
graph_y = db.ListField()
chart_x = db.ListField()
chart_y = db.ListField()
model = db.LazyReferenceField('Model')
user_model = db.LazyReferenceField('UserModel')
def static_range(self):
stock = yf.Ticker(self.ticker)
df = stock.history(period=self.period, interval=self.interval)
owned = 0
count = 0
trade_money = self.money
trade_cost = self.trade_cost
buy = self.buy
sell = self.sell
td = [] #trade date
tt = [] #trade time
ty = [] #trade type
tp = [] #trade price
tv = [] #trade volume
store_chart_x = []
store_chart_y = []
for index, row in df.iterrows():
count += 1
available_money = trade_money - trade_cost
available_volume = row['Volume']/40
low = round(row['Low'], 4)
high = round(row['High'], 4)
date = index.to_pydatetime().strftime("%d-%m-%Y")
time = index.to_pydatetime().strftime("%H:%M")
etime = index.to_pydatetime() + timedelta(minutes=2)
endtime = etime.strftime("%H:%M")
if low != high:
if float(row['Open']) > float(row['Close']):
store_chart_y.append(float(high))
store_chart_x.append(date[6:10]+'-'+date[3:5]+'-'+date[0:2] + 'T' + time + ':00')
store_chart_y.append(float(low))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T' + endtime + ':00')
elif float(row['Close']) > float(row['Open']):
store_chart_y.append(float(low))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T' + time + ':00')
store_chart_y.append(float(high))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T' + endtime + ':00')
elif low == high:
store_chart_y.append(low)
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T' + time + ':00')
lvalue = (low * available_volume)
hvalue = (high * available_volume)
if available_money > 0 and low <= buy and lvalue > trade_cost:
if lvalue>available_money>0:
owned += (available_money/low)
trade_money = 0
td.append(date)
tt.append(time)
ty.append('b')
tp.append(low)
tv.append(available_volume)
elif available_money>lvalue>0:
owned += (lvalue/low)
trade_money -= trade_cost
trade_money -= lvalue
td.append(date)
tt.append(time)
ty.append('b')
tp.append(low)
tv.append(available_volume)
if owned > 0 and high >= sell and hvalue > trade_cost:
if available_volume > owned:
trade_money += (owned*high)
trade_money -= trade_cost
owned = 0
td.append(date)
tt.append(time)
ty.append('s')
tp.append(high)
tv.append(available_volume)
elif owned > available_volume:
trade_money += (available_volume*high)
trade_money -= trade_cost
owned -= available_volume
td.append(date)
tt.append(time)
ty.append('s')
tp.append(high)
tv.append(available_volume)
if owned > 0:
liquid_money = (trade_money - trade_cost) + df.Low.ix[count-1]*owned
else:
liquid_money = trade_money
self.chart_x = store_chart_x
self.chart_y = store_chart_y
self.final_money = round(trade_money, 2)
self.final_owned = round(owned)
self.final_liquid = round(liquid_money, 2)
self.td = td
self.tt = tt
self.ty = ty
self.tp = tp
self.tv = tv
self.save()
return self.id
def moving_average(self):
stock = yf.Ticker(self.ticker)
df = stock.history(period=self.period, interval='1d')
owned = 0
count = 0
trade_money = self.money
trade_cost = self.trade_cost
bd = self.buy
sd = self.sell
ma_length = self.av_length
ma_conv = ma_length - 1
ma_sum = 0
td = [] # trade date
tt = [] # trade time
ty = [] # trade type
tp = [] # trade price
tv = [] # trade volume
store_ma = []
store_ma_x = []
store_chart_x = []
store_chart_y = []
for i in range(0, df.shape[0] - ma_conv):
for j in range(0, ma_length):
ma_sum += df.iloc[i + j, 3]
df.loc[df.index[i + ma_conv], 'SMA_' + str(ma_length)] = np.round((ma_sum / ma_length), 4)
ma_sum = 0
for index, row in df.iloc[ma_length:].iterrows():
count += 1
available_money = trade_money - trade_cost
available_volume = row['Volume'] / 40
low = round(row['Low'], 4)
high = round(row['High'], 4)
date = index.to_pydatetime().strftime("%d-%m-%Y")
time = index.to_pydatetime().strftime("%H:%M")
if low != high:
if float(row['Open']) > float(row['Close']):
store_chart_y.append(float(high))
store_chart_x.append(date[6:10]+'-'+date[3:5]+'-'+date[0:2]+'T09:30:00')
store_chart_y.append(float(low))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T16:00:00')
elif float(row['Close']) > float(row['Open']):
store_chart_y.append(float(low))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T09:30:00')
store_chart_y.append(float(high))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T16:00:00')
elif low == high:
store_chart_y.append(low)
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T12:45:00')
lvalue = (low * available_volume)
hvalue = (high * available_volume)
buy = row['SMA_' + str(ma_length)] - bd
sell = row['SMA_' + str(ma_length)] + sd
store_ma.append(float(row['SMA_' + str(ma_length)]))
store_ma_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T' + time + ':00')
if available_money > 0 and low <= buy and lvalue > trade_cost:
if lvalue > available_money > 0:
owned += (available_money / low)
trade_money = 0
td.append(date)
tt.append(time)
ty.append('b')
tp.append(low)
tv.append(available_volume)
elif available_money > lvalue > 0:
owned += (lvalue / low)
trade_money -= trade_cost
trade_money -= lvalue
td.append(date)
tt.append(time)
ty.append('b')
tp.append(low)
tv.append(available_volume)
if owned > 0 and high >= sell and hvalue > trade_cost:
if available_volume > owned:
trade_money += (owned * high)
trade_money -= trade_cost
owned = 0
td.append(date)
tt.append(time)
ty.append('s')
tp.append(high)
tv.append(available_volume)
elif owned > available_volume:
trade_money += (available_volume * high)
trade_money -= trade_cost
owned -= available_volume
td.append(date)
tt.append(time)
ty.append('s')
tp.append(high)
tv.append(available_volume)
if owned > 0:
liquid_money = (trade_money - trade_cost) + df.Low.ix[count - 1] * owned
else:
liquid_money = trade_money
self.chart_x = store_chart_x
self.chart_y = store_chart_y
self.graph_y = store_ma
self.graph_x = store_ma_x
self.final_money = round(trade_money, 2)
self.final_owned = round(owned)
self.final_liquid = round(liquid_money, 2)
self.td = td
self.tt = tt
self.ty = ty
self.tp = tp
self.tv = tv
self.save()
return self.id
def weighted_moving_average(self):
stock = yf.Ticker(self.ticker)
df = stock.history(period=self.period, interval='1d')
owned = 0
count = 0
trade_money = self.money
trade_cost = self.trade_cost
bd = self.buy
sd = self.sell
wma_length = self.av_length
wma_conv = wma_length - 1
wma_sum = 0
weight = 0
weight_sum = 0
for k in range(1, wma_length + 1):
weight_sum += k
td = [] # trade date
tt = [] # trade time
ty = [] # trade type
tp = [] # trade price
tv = [] # trade volume
store_wma = []
store_wma_x = []
store_chart_y = []
store_chart_x = []
for i in range(0, df.shape[0] - wma_conv):
for j in range(0, wma_length):
weight += 1
wma_sum += (df.iloc[i + j, 3]*weight)
weight = 0
df.loc[df.index[i + wma_conv], 'WMA_' + str(wma_length)] = np.round((wma_sum / weight_sum), 4)
wma_sum = 0
for index, row in df.iloc[wma_length:].iterrows():
count += 1
available_money = trade_money - trade_cost
available_volume = row['Volume'] / 40
low = round(row['Low'], 4)
high = round(row['High'], 4)
date = index.to_pydatetime().strftime("%d-%m-%Y")
time = index.to_pydatetime().strftime("%H:%M")
if low != high:
if float(row['Open']) > float(row['Close']):
store_chart_y.append(float(high))
store_chart_x.append(date[6:10]+'-'+date[3:5]+'-'+date[0:2]+'T09:30:00')
store_chart_y.append(float(low))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T16:00:00')
elif float(row['Close']) > float(row['Open']):
store_chart_y.append(float(low))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T09:30:00')
store_chart_y.append(float(high))
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T16:00:00')
elif low == high:
store_chart_y.append(low)
store_chart_x.append(date[6:10] + '-' + date[3:5] + '-' + date[0:2] + 'T12:45:00')
lvalue = (low * available_volume)
hvalue = (high * available_volume)
buy = row['WMA_' + str(wma_length)] - bd
sell = row['WMA_' + str(wma_length)] + sd
store_wma.append(float(row['WMA_' + str(wma_length)]))
store_wma_x.append(date[6:10]+'-'+date[3:5]+'-'+date[0:2]+'T'+time+':00')
if available_money > 0 and low <= buy and lvalue > trade_cost:
if lvalue > available_money > 0:
owned += (available_money / low)
trade_money = 0
td.append(date)
tt.append(time)
ty.append('b')
tp.append(low)
tv.append(available_volume)
elif available_money > lvalue > 0:
owned += (lvalue / low)
trade_money -= trade_cost
trade_money -= lvalue
td.append(date)
tt.append(time)
ty.append('b')
tp.append(low)
tv.append(available_volume)
if owned > 0 and high >= sell and hvalue > trade_cost:
if available_volume > owned:
trade_money += (owned * high)
trade_money -= trade_cost
owned = 0
td.append(date)
tt.append(time)
ty.append('s')
tp.append(high)
tv.append(available_volume)
elif owned > available_volume:
trade_money += (available_volume * high)
trade_money -= trade_cost
owned -= available_volume
td.append(date)
tt.append(time)
ty.append('s')
tp.append(high)
tv.append(available_volume)
if owned > 0:
liquid_money = (trade_money - trade_cost) + df.Low.ix[count - 1] * owned
else:
liquid_money = trade_money
self.chart_x = store_chart_x
self.chart_y = store_chart_y
self.graph_x = store_wma_x
self.graph_y = store_wma
self.final_money = round(trade_money, 2)
self.final_owned = round(owned)
self.final_liquid = round(liquid_money, 2)
self.td = td
self.tt = tt
self.ty = ty
self.tp = tp
self.tv = tv
self.save()
return self.id
class PahrmacyInventory(db.Document):
name = db.StringField()
quantity = db.IntField()
price = db.FloatField()
class Article(db.Document):
feed = db.ReferenceField(Feed, required=True)
source_id = db.StringField(required=True)
url = db.StringField()
title = db.StringField()
top_image = db.StringField()
movies = db.ListField()
keywords = db.ListField()
tags = db.ListField()
authors = db.ListField()
publish_date = db.DateTimeField()
summary = db.StringField()
html = db.StringField()
meta_data = db.DictField()
language = db.StringField()
text = db.StringField()
active = db.BooleanField(default=True)
vector = db.ListField(db.FloatField())
vector_2d = db.ListField(db.FloatField())
def as_dict(self):
return dict(feed=self.feed.url,
source_id=self.source_id,
url=self.url,
title=self.title,
top_image=self.top_image,
movies=self.movies,
keywords=self.keywords,
tags=self.tags,
authors=self.authors,
publish_date='%s' % self.publish_date,
summary=self.summary,
html=self.html,
meta_data=self.meta_data,
language=self.language,
text=self.text,
vector=self.vector,
vector_2d=self.vector_2d)
@staticmethod
def update_vectors(model, vectors_2d=[]):
# https://stackoverflow.com/questions/30943076/mongoengine-bulk-update-without-objects-update
bulk_operations = []
keys = model.docvecs.doctags.keys()
vectors = model.docvecs.vectors_docs
for key, vector, vector_2d in zip(keys, vectors, vectors_2d):
bulk_operations.append(
UpdateOne({'_id': key}, {
'$set':
dict(vector=vector.tolist(), vector_2d=vector_2d)
}))
if bulk_operations:
collection = Article._get_collection() \
.bulk_write(bulk_operations, ordered=False)
class User(db.Document):
name = db.StringField(max_length=50)
email = db.StringField(max_length=50, unique=True)
password = db.StringField(max_length=500)
dept = db.StringField()
class Socials(db.EmbeddedDocument):
github = db.StringField()
linkedin = db.StringField()
class LabInventory(db.Document):
name = db.StringField()
price = db.FloatField()
class Exam(db.Document):
user = db.ReferenceField('User')
type = db.StringField(choices=EXAM_TYPE)
pure_tone = db.EmbeddedDocumentField('PureTone')
speech_noise = db.EmbeddedDocumentField('SpeechNoise')
dichotic = db.EmbeddedDocumentField('Dichotic')
def __repr__(self):
return '[Exam] user :{} type:{} pure_tone:{}'.format(
self.user, self.type, self.pure_tone)
@classmethod
def passed_exam_before(cls, userid):
return cls.objects.get(user=userid) if cls.objects(
user=userid) else False
@classmethod
def passed_pure_before(cls, userid):
return cls.objects.get(
user=userid, type=EXAM_TYPE['PURE_TONE']) if cls.objects(
user=userid, pure_tone__exists=True) else False
@classmethod
def passed_dichotic_before(cls, userid):
return cls.objects.get(
user=userid, type=EXAM_TYPE['DICHOTIC']) if cls.objects(
user=userid, dichotic__exists=True) else False
@classmethod
def passed_dicho_type_before(cls, userid, dicho_type):
dicho_type_phrase = 'dichotic__' + dicho_type + '__exists'
args = {'user': userid, dicho_type_phrase: True}
return cls.objects.get(user=userid) if cls.objects(**args) else False
@classmethod
def passed_speech_noise_before(cls, userid):
return cls.objects.get(
user=userid, speech_noise__exists=True) if cls.objects.get(
user=userid, speech_noise__exists=True) else False
@classmethod
def get_puretone_by_user_id(cls, userid):
return cls.objects.get(user=userid, type=EXAM_TYPE['PURE_TONE'])
def pure_tone_report(self):
result = {}
result['Right_250'] = self.pure_tone.Right_250
result['Right_500'] = self.pure_tone.Right_500
result['Right_1000'] = self.pure_tone.Right_1000
result['Right_2000'] = self.pure_tone.Right_2000
result['Right_4000'] = self.pure_tone.Right_4000
result['Right_8000'] = self.pure_tone.Right_8000
result['Left_250'] = self.pure_tone.Left_250
result['Left_500'] = self.pure_tone.Left_500
result['Left_1000'] = self.pure_tone.Left_1000
result['Left_2000'] = self.pure_tone.Left_2000
result['Left_4000'] = self.pure_tone.Left_4000
result['Left_8000'] = self.pure_tone.Left_8000
lentgh = 0
for i in result:
if result[i] != None:
lentgh = lentgh + 1
count = 0
for i in result:
if result[i] == False:
count += 1
if count >= 1:
need_to_clinic = True
elif lentgh != 12:
need_to_clinic = True
else:
need_to_clinic = False
return {'result': result, 'need': need_to_clinic}
@classmethod
def get_dichotic_by_user_id(cls, userid):
return cls.objects.get(user=userid, dichotic__exists=True)
def dichotic_report(self):
self.result = {}
self.result['Single'] = {}
self.result['Binary'] = {}
self.result['Ternary'] = {}
# print(self.dichotic.Ternary)
if self.dichotic.Single != None:
for i in self.dichotic.Single:
self.result['Single'][i] = self.dichotic.Single[i]
if self.dichotic.Binary != None:
for i in self.dichotic.Binary:
self.result['Binary'][i] = self.dichotic.Binary[i]
if self.dichotic.Ternary != None:
for i in self.dichotic.Ternary:
self.result['Ternary'][i] = self.dichotic.Ternary[i]
return {'result': self.result}
def count_dichotic_score(self):
self.dichotic_report()
if self.result['Single'] != {}:
pass
elif self.result['Binary'] != {}:
score_left = 0
score_right = 0
right_answer = 0
left_answer = 0
count = 0
for i, j in self.result['Binary'].items():
if i == 'start_time':
continue
right_flag = 0
left_flag = 0
for key, value in enumerate(j):
if value in right_dichotic_binary[count]:
if right_flag >= 2:
continue
right_flag += 1
right_answer += 1
if right_flag == 2:
score_right = score_right + 4
elif value in left_dichotic_binary[count]:
if left_flag >= 2:
continue
left_flag += 1
left_answer += 1
if left_flag == 2:
score_left = score_left + 4
count += 1
return (score_right, score_left, right_answer, left_answer)
elif self.result['Ternary'] != {}:
score_left = 0
score_right = 0
right_answer = 0
left_answer = 0
count = 0
for i, j in self.result['Ternary'].items():
if i == 'start_time':
continue
right_flag = 0
left_flag = 0
for key, value in enumerate(j):
if value in right_dichotic_ternary[count]:
if right_flag >= 3:
continue
right_flag += 1
right_answer += 1
if right_flag == 3:
score_right = score_right + 4
elif value in left_dichotic_ternary[count]:
if left_flag >= 3:
continue
left_flag += 1
left_answer += 1
if left_flag == 3:
score_left = score_left + 4
count += 1
return (score_right, score_left, right_answer, left_answer)
def speech_noise_report(self):
right_silence_score = 0
left_silence_score = 0
right_noise_score = 0
left_noise_score = 0
for i in self.speech_noise:
if i == 'start_time':
continue
elif i == 'right_silence':
for k, v in enumerate(self.speech_noise[i]):
if v in right_silence:
right_silence_score += 1
elif i == 'left_silence':
for k, v in enumerate(self.speech_noise[i]):
if v in left_silence:
left_silence_score += 1
elif i == 'right_noise':
for k, v in enumerate(self.speech_noise[i]):
if v in right_noise:
right_noise_score += 1
elif i == 'left_noise':
for k, v in enumerate(self.speech_noise[i]):
if v in left_noise:
left_noise_score += 1
return (right_silence_score, left_silence_score, right_noise_score,
left_noise_score)