def review(db):
roomid = request.form['roomid']
room = db.Room.get(id=roomid)
netid = cas.netid()
user = db.User.get_or_create(netid=netid)
rating = request.form.get('rating')
text = request.form.get('text')
# TODO: # automate this with the rating attributes
room_review = db.Review(user=user, room=room, rating=rating, text=text)
flush()
pictures = []
uploaded_pictures = request.files.getlist('pictures')
upload_folder = current_app.config['UPLOAD_DIR']
for i, picture in enumerate(uploaded_pictures):
if allowed_file(picture.filename):
# filename = secure_filename(picture.filename)
filename, extension = os.path.splitext(
secure_filename(picture.filename))
filename = f"{room_review.id}_{i}{extension}"
filepath = os.path.join(upload_folder, filename)
picture.save(filepath)
pictures.append(filename)
room_review.pictures = json.dumps(pictures)
return jsonify({"success": True})
def signup(cls, nickname, username, password, sign_type, sessionid,
**kwargs):
try:
user = cls.get(username=username)
except ObjectNotFound:
pass
if user:
raise error.UsernameExisted(username=username)
create_at = datetime.now()
update_at = datetime.now()
user = cls(
nickname=nickname,
username=username,
sign_type=sign_type,
is_enable=const.UserEnable.OK,
status=const.UserStatus.OK,
password=cls.generate_password(password, create_at),
email=kwargs.get('email'),
phone=kwargs.get('phone'),
create_at=create_at,
update_at=update_at,
)
flush()
commit()
return user.signin(password, sessionid)
def reset_password(self, password, repeat_password, **kwargs):
if password != repeat_password:
raise error.RepeatPasswordError()
self.password = self.generate_password(password, self.create_at)
flush()
commit()
def UpdateTinyAvatar(cls, id, name, box):
user = cls.get(id=id)
user.tiny_avatar = name
user.avatar_frame = ','.join(
(str(box.x1), str(box.y1), str(box.x2), str(box.y2)))
flush()
commit()
return user
def update(self, entity, **attributes):
assert isinstance(entity, self.entity_class)
entity = pickle.loads(pickle.dumps(entity))
for attr, value in attributes.items():
setattr(entity, attr, value)
flush()
def test_from_payload(self):
"""
Test converting a metadata payload to a metadata object
"""
metadata = self.mds.ChannelNode.from_dict({})
metadata_dict = metadata.to_dict()
metadata.delete()
orm.flush()
metadata_payload = ChannelNodePayload(**metadata_dict)
self.assertTrue(self.mds.ChannelNode.from_payload(metadata_payload))
def loaders(request, Agent, transaction):
record = Agent()
pn.flush()
patch(
request.cls,
Loader=PonyLoader,
Schema=Agent,
record=record,
primary=Agent.id.name,
secondary=Agent.name.name,
)
def from_dict(self, user):
with db_session:
user = UserModel(
login=user['login'],
password=user['password'],
email=user['email'],
)
flush() # Чтобы сразу получить id
user = user.to_dict()
log.info('New user added: login=%r, password=%r', user['login'], user['password'])
return user
def load(developdb):
from pony.orm import (sql_debug, commit, db_session, flush)
from tools import LoadConfig
from os import path
wk = path.dirname(path.dirname(path.realpath(__file__)))
conf = LoadConfig(wk).conf()
sql_debug(True)
#db.bind('sqlite', 'telesalud.sqlite', create_db=True)
loadconf = lambda: conf.developdb if developdb else conf.productiondb
db.bind('postgres', **loadconf())
db.generate_mapping(create_tables=True)
with db_session:
[Tipo(nombre=nm) for nm in [u'Embarazada',u'Contacto']]; flush()
pr = Persona(telf='76180435',ci='5669297',nombres=u'Luis Eduardo',apellidos=u'Miranda Barja',sexo='m')
Usuario(persona=pr, login=u'eduardo',passwd=u'Mast3R',rol=u'Administrador'); commit()
def save_evaluation(run_id, out_hash, did_succeed):
r = mod.Run.get(id=run_id)
cp = r.configured_solution.solution.challenge_problem
ev = cp.evaluator
if not ev:
raise utility.FormattedError(
"No registered evaluator for challenge problem {}",
cp.cp_ids
)
evaluation = mod.Evaluation.get(run=r)
if evaluation:
utility.write("Old evaluation found, deleting it to save the new one.")
evaluation.delete()
pny.flush()
evaluation = mod.Evaluation(
id = out_hash,
evaluator = ev,
run = r,
did_succeed = did_succeed
)
def test_serialization(self):
"""
Test converting metadata to serialized data and back
"""
metadata1 = self.mds.ChannelNode.from_dict({})
serialized1 = metadata1.serialized()
metadata1.delete()
orm.flush()
metadata2 = self.mds.ChannelNode.from_payload(ChannelNodePayload.from_signed_blob(serialized1))
serialized2 = metadata2.serialized()
self.assertEqual(serialized1, serialized2)
# Test no signature exception
metadata2_dict = metadata2.to_dict()
metadata2_dict.pop("signature")
self.assertRaises(InvalidSignatureException, ChannelNodePayload, **metadata2_dict)
serialized3 = serialized2[:-5] + "\xee" * 5
self.assertRaises(InvalidSignatureException, ChannelNodePayload.from_signed_blob, serialized3)
# Test bypass signature check
ChannelNodePayload.from_signed_blob(serialized3, check_signature=False)
def delete(self, entity):
assert isinstance(entity, self.entity_class)
entity.delete()
flush()
def create(self, **attributes):
entity = self.entity_class(**attributes)
flush()
return entity
def wrapper(get, **kwargs):
obj = entity._find_one_(get)
self.mutate_func(obj, **kwargs)
orm.flush()
return obj
def mutate(self, **kwargs):
ret = self.mutate_func(**kwargs)
orm.flush()
return ret
