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_)