def find_all(self, *criterion, raw=False, as_json=False, limit=None, offset=None):
if raw:
return session.query(self.__class__).filter(*criterion).limit(limit).offset(offset)
res = session.query(self.__class__).filter(*criterion).limit(limit).offset(offset).all()
if as_json:
return[x.json_dump() for x in res]
return res
def on_post(self, request, response):
params = json.loads(request.stream.read())
random_number = INT(params.get("random_number"))
with sql(commit=True) as session:
stud = get_student_by_id(self.student_id, session)
gid = stud.group_id
group_size = len(get_group_members(gid, session))
if group_size > 8:
response.media = error("Your group is too large")
return
recepient = session.query(models.Student).filter_by(
random_number=random_number).filter_by(sex=stud.sex).first()
if recepient is None:
response.media = error("Student not found")
return
invitation = session.query(models.Invitation).filter_by(
student_id=recepient.student_id, group_id=gid).first()
if invitation is not None: return
invitation = models.Invitation(student_id=recepient.student_id,
group_id=gid)
session.add(invitation)
response.media = {"success": True}
def get_rank(student_id):
model = models.Group
with sql() as session:
gid = get_student_by_id(student_id, session).group_id
random_number = session.query(model).filter_by(
group_id=gid).first().random_number
return session.query(model.random_number).distinct().filter(
model.random_number < random_number).count()
def get_student_by_id(student_id, session=None):
if student_id is None: return None
student = None
with sql(session) as session:
student = session.query(
models.Student).filter_by(student_id=student_id).first()
return student
def on_get(self, request, response):
response.media = []
with sql() as session:
student = get_student_by_id(self.student_id, session)
invitations = session.query(
models.Invitation).filter_by(group_id=student.group_id).all()
for i in invitations:
recepient = get_student_by_id(i.student_id, session)
response.media.append(recepient.dict(exclude="student_id"))
def __get_jokes(self, item):
jokes = session.query(exists().where(JokesModel.link == item.get("link"))).scalar()
if jokes:
return None
jokes = JokesModel()
jokes.title = item.get("title")
jokes.category_id = item.get("category_id")
jokes.link = item.get("link")
jokes.content = item.get("content")
return jokes
def get_user(id: int) -> Utilisateur:
"""
Cette fonction renvoit un utilisateur précis dont l'id est specifié en paramètre
"""
utilisateur = None
try:
utilisateur = session.query(Utilisateur).get(id)
except Exception as error:
print(error)
finally:
return utilisateur
def get_all_utilisateurs():
"""
Cette fonction renvoit tous les utilisateurs
"""
utilisateurs = []
try:
utilisateurs = session.query(Utilisateur).all()
except Exception as error:
print(error)
finally:
return utilisateurs
def on_get(self, request, response):
with sql() as session:
invitations = session.query(
models.Invitation).filter_by(student_id=self.student_id).all()
response.media = []
for inv in invitations:
leader = get_group_leader(inv.group_id)
if leader is None: continue
leader_name = leader.first_name + " " + leader.last_name
invite = {'group_id': inv.group_id, 'leader': leader_name}
response.media.append(invite)
def reinit_group(group_id, session=None):
"""Reinitialize the group data based on the "highest-weighted" student"""
with sql(session, commit=True) as session:
members = get_group_members(group_id, session)
if len(members) == 0:
return
group = session.query(
models.Group).filter_by(group_id=group_id).first()
# update the group table
group.random_number = min(
members, key=lambda student: student.random_number).random_number
group.grade_level = max(
members, key=lambda student: student.grade_level).grade_level
def on_get(self, request, response):
dorm_id = INT(request.params.get("dorm"), nullable=True)
with sql() as session:
student = get_student_by_id(self.student_id, session)
results = session.query(models.Dorm).filter_by(sex=student.sex)
if dorm_id is not None:
response.media = results.filter_by(
dorm_id=dorm_id).first().dict()
else:
response.media = []
for dorm in results:
response.media.append(dorm.dict())
def delete_utilisateur(id: int) -> bool:
"""
Cette fonction supprime un utilisateur dont l'id est passé en parametre
"""
try:
x = session.query(Utilisateur).get(id)
x.delete()
session.commit()
except Exception as exception:
print(exception)
return False
else:
return True
finally:
session.flush()
def on_put(self, request, response):
params = json.loads(request.stream.read())
gid = INT(params.get("group_id"))
with sql(commit=True) as session:
invitation = session.query(models.Invitation).filter_by(
student_id=self.student_id, group_id=gid).first()
if invitation is None:
response.media = error("You were not invited to this group")
return
if len(get_group_members(gid, session)) >= 8:
response.media = error("Group size is too large")
return
student = get_student_by_id(self.student_id, session)
old_gid = student.group_id
student.group_id = gid
reinit_group(old_gid, session)
reinit_group(gid, session)
session.query(models.Invitation).filter_by(
student_id=self.student_id).delete()
response.media = {"success": True}
def update_utilisateur(utilisateur: Utilisateur, id: int) -> bool:
"""
Cette fonction met à jour l'utilisateur dont l'id est passé en deuxieme
parametre par les nouveaux parametres passés en premier parametre
"""
try:
x = session.query(Utilisateur).get(id)
x = utilisateur
session.commit()
except Exception as exception:
print(exception)
return False
else:
return True
finally:
session.flush()
def login_user(email: str, password: str) -> list:
import time
utilisateur = None
try:
utilisateur = session.query(Utilisateur).filter(
Utilisateur.email == email, Utilisateur.password == password)
list_users = list(utilisateur)
if list_users != []:
response = session.set_session(list_users[0])
time.sleep(2.5)
except Exception as error:
return False
finally:
return list(utilisateur)
def on_delete(self, request, response):
gid = INT(request.params.get("group_id"))
with sql(commit=True) as session:
session.query(models.Invitation).filter_by(
student_id=self.student_id, group_id=gid).delete()
def get_group_members(group_id, session=None):
with sql(session) as session:
return session.query(models.Student).filter_by(group_id=group_id).all()
def page(self, *criterion, limit=None, offset=None):
res = session.query(self.__class__).filter(*criterion).limit(limit).offset(offset).all()
return res
def get_verification_token_by_id(id_):
return session.query(VerificationToken).get(id_)
def find_first(self, *criterion, as_json=False):
res = session.query(self.__class__).filter(*criterion).first()
if as_json:
return[x.json_dump() for x in res]
return res
def find(self,*criterion):
return session.query(self.__class__).filter(*criterion)
def get_user_by_id(id_):
return session.query(User).get(id_)
def get_one_user_by_id(id_):
return session.query(User).filter(User.id == id_).one()
'''
Created on Jun 29, 2015
@author: lin
'''
from vod_orm import *
import session
import sqlalchemy.exc
session = session.getSession()
newUser = User(name='tom', id=23)
newVideo = Video(title = 'testvideo', id = 24)
user = session.query(User).filter(User.id == '23').one()
print '..'
print user
print '..'
newVideo.user = newUser.id
try:
session.add(newUser)
session.add(newVideo)
res = session.query(Video).all()
print res[0].title
print newVideo
session.commit()
except sqlalchemy.exc.IntegrityError as detail:
print type(detail)
def on_get(self, request, response):
with sql() as session:
stud = get_student_by_id(self.student_id, session)
gid = stud.group_id
group = session.query(models.Group).filter_by(group_id=gid).first()
response.media = group.dict() if group else "{}"
def get_apartments(neighborhood):
apartments = session.query(Apartment).first()
return render_template('index.html', apartment=apartment)
def q(self):
""" return a raw sqlalchemy query object """
return session.query(self.__class__)
def _get_user_by_email_address(email_address):
return session.query(User).filter(
User.email_address == email_address
)
def get_rands_nearby(db, j, from_db=False):
''' gets rands nearby locations given in json '''
kwd_name = j['kwd_name']
locations_collection = db['points']
# przydaloby sie to do jakiejs funkcji dac
if locations_collection.count() == 0:
for doc in tqdm(db['hits_unwinded'].find(
{"hits.geolocation.location.coordinates": {
"$exists": True
}})):
doc['hits']['geolocation']['location']['coordinates'] = doc[
'hits']['geolocation']['location']['coordinates'][::-1]
db['points'].insert(doc)
#pipeline = [{"$match" : {"hits.geolocation.location": { "$exists" : True }}}, { "$out" : 'points' }]
#db['hits_unwinded'].aggregate(pipeline,allowDiskUse=True, bypassDocumentValidation = True)
# trzeba to do db points wziac
db.points.create_index([('hits.geolocation.location', '2dsphere')])
geoloc_path = j.get('locations_json')
# trzeba pomyśleć nad profilem wiec i miasto
# moze miasto najpierw
if geoloc_path is not None:
geoloc_f = open(geoloc_path, 'r')
lines = geoloc_f.readlines()
if db['pointsNear' + kwd_name].count() == 0:
for line in tqdm(lines):
j = ujson.loads(line)
coordinates = [
j['geometry']['location']['lng'],
j['geometry']['location']['lat']
]
points = db['points']
pipeline = [{
"$geoNear": {
"near": {
"type": "Point",
"coordinates": coordinates
},
"distanceField": "dist.calculated",
"maxDistance": 100,
"includeLocs": "dist.location",
"spherical": True
}
}, {
"$out": 'pointsNear'
}]
points.aggregate(pipeline)
for u in db.pointsNear.find():
db['pointsNear' + kwd_name].save(u)
geoloc_table = j.get('locations_table')
if geoloc_table is not None and kwd_name in ['duze_miasto']:
# so maybe start with the ones in big cities
q = session.query(CT).filter(CT.ct_pop_size >= 500000)
res = q.all()
#res = [i[0] for i in res]
for ct in res:
lat = float(ct.ct_cpkt_N)
lng = float(ct.ct_cpkt_E)
coordinates = [lng, lat]
radius = float(ct.ct_r) * 1000
points = db['points']
pipeline = [{
"$geoNear": {
"near": {
"type": "Point",
"coordinates": coordinates
},
"distanceField": "dist.calculated",
"maxDistance": radius,
"includeLocs": "dist.location",
"spherical": True
}
}, {
"$out": 'pointsNear'
}]
points.aggregate(pipeline)
for u in db.pointsNear.find():
db['pointsNear' + kwd_name].save(u)
elif geoloc_table is not None and kwd_name == 'wies':
q = session.query(CT)
res = q.all()
#res = [i[0] for i in res]
for ct in tqdm(res):
lat = float(ct.ct_cpkt_N)
lng = float(ct.ct_cpkt_E)
coordinates = [lng, lat]
radius = float(ct.ct_r) * 1000
points = db['points']
all_geoloc = set(points.distinct('user.advertisingID'))
pipeline = [{
"$geoNear": {
"near": {
"type": "Point",
"coordinates": coordinates
},
"distanceField": "dist.calculated",
"maxDistance": radius,
"includeLocs": "dist.location",
"spherical": True
}
}, {
"$out": 'pointsNear'
}]
points.aggregate(pipeline)
for adv_id in db.pointsNear.distinct('user.advertisingID'):
doc = {'user': {'advertisingID': adv_id}}
db['pointsNearAnyCity'].save(doc)
city_people = set(
db['pointsNearAnyCity'].distinct('user.advertisingID'))
village_people = all_geoloc - city_people
for adv_id in tqdm(village_people):
doc = {'user': {'advertisingID': adv_id}}
db['pointsNear' + kwd_name].save(doc)
rand_set = db['pointsNear' + kwd_name].distinct('user.advertisingID')
return set(rand_set)
def get_recovery_token_by_id(id_):
return session.query(RecoveryToken).get(id_)
