def editarcomentario(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): comm = Comentarios() info = request.get_json() res = comm.get_comment(info['id_user'], info['id_comment']) if res == 0: respuesta = {'error': True, 'mensaje': 'Comentario no existe.'} return json.dumps(respuesta) else: comm.edit_comment(info['id_user'], info['id_comment'], info['comentario'], info['fecha']) db.session.commit() #guardo los cammbios respuesta = { 'error': False, 'mensaje': 'Comentario editado exitosamente.' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def pagar(user): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): if user.isdigit(): car = Carrito() res = car.all_prod(user) if res == 0: respuesta = { 'error': True, 'mensaje': 'No hay productos en el carrito.' } return json.dumps(respuesta) else: car.aumentar_vendido(user, res) for prod in res: db.session.delete(prod) db.session.commit() respuesta = { 'error': False, 'mensaje': 'Su compra ha sido exitosa.' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Usuario no existe.'} return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def deletecomentario(user, comment): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): if user.isdigit() and comment.isdigit(): comm = Comentarios() oneComm = comm.delete_comment(comment, user) if oneComm == 0: respuesta = { 'error': True, 'mensaje': 'Comentario no existe.' } return json.dumps(respuesta) else: db.session.delete(oneComm) db.session.commit() respuesta = { 'error': False, 'mensaje': 'Comentario borrado exitosamente.' } return json.dumps(respuesta) respuesta = { 'error': True, 'mensaje': 'Comentario o Usuario no existe.' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def deletecarrito(user, prod): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): if user.isdigit() and prod.isdigit(): car = Carrito() oneProd = car.delete_prod(prod, user) if oneProd == 0: respuesta = { 'error': True, 'mensaje': 'Producto no existe.' } return json.dumps(respuesta) else: db.session.delete(oneProd) db.session.commit() respuesta = { 'error': False, 'mensaje': 'Producto borrado del carrito.' } return json.dumps(respuesta) respuesta = { 'error': True, 'mensaje': 'Producto o Usuario no existe' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def check_session(*args, **kwargs): from app.models.session import Session from app.models.user import UserModel g.user = None header = current_app.config.get("SESSION_HEADER") session_id = request.headers.get(header) session = Session() session_data = session.read(session_id) if session_data: g.user = UserModel(session_id) g.user.load() if request.endpoint in ["session", "status"]: pass elif request.method == "POST" and request.endpoint == "user": if not validate_session(session_id): abort(403) else: if not validate_session(session_id): abort(403) if request.method in ["POST", "PUT", "PATCH", "DELETE"]: if request.endpoint == "auth": pass elif not g.user or not g.user.get_id(): print("Request denied (no auth)", request.endpoint) abort(403) g.session_id = session_id
def agregarcarrito(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): car = Carrito() user = Users() datos_user = user.get_user(usuario) datos = request.get_json() res = car.exist_prod(datos_user['id'], datos['id_prod']) if res == 1: car.agg_prod(datos_user['id'], datos['id_prod']) db.session.add(car) respuesta = { 'error': False, 'mensaje': 'Producto agregado exitosamente.' } else: respuesta = { 'error': False, 'mensaje': 'Cantidad aumentada exitosamente.' } db.session.commit() return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def cantcarrito(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): info = request.get_json() car = Carrito() res = car.adm_cant(info['id_user'], info['id_prod'], info['opcion']) if res == 0: #Eliminamos el producto del carrito debido a que se resto la cantidad que estaba en 1 oneProd = car.delete_prod(info['id_prod'], info['id_user']) if oneProd != 0: db.session.delete(oneProd) respuesta = { 'error': False, 'mensaje': 'Producto eliminado del carrito.' } else: respuesta = { 'error': False, 'mensaje': 'Cantidad editada exitosamente.' } db.session.commit() return jsonify(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def delete(ide): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): if ide.isdigit(): _id = ide prod = productos() oneProd = prod.delete_prod(_id) if oneProd == 0: respuesta = { 'error': True, 'mensaje': 'Producto no existe.' } return json.dumps(respuesta) else: db.session.delete(oneProd) db.session.commit() respuesta = { 'error': False, 'mensaje': 'Producto borrado exitosamente.' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Producto no existe.'} return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def logout(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): deletesesion = sesion.delete_session(usuario) if deletesesion == 0: respuesta = { 'error': True, 'mensaje': 'No has iniciado sesión.' } return json.dumps(respuesta) else: db.session.delete(deletesesion) db.session.commit() respuesta = { 'error': False, 'mensaje': 'Cerraste sesión correctamente' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Ya has iniciado sesión.'} return json.dumps(respuesta)
def log_user(): sesion = Session() new = request.get_json() usuario = new['username'] token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): respuesta = {'error': True, 'mensaje': 'Ya has iniciado sesión.'} return json.dumps(respuesta) user = Users() clave = new['password'] if sesion.exist_sesion(usuario): deletesesion = sesion.delete_session(usuario) db.session.delete(deletesesion) db.session.commit() if user.login(usuario, clave): res = create_session(usuario, user.is_Admin(usuario)) respuesta = { 'error': False, 'mensaje': 'Inicio de sesión exitoso.', 'token': res } return json.dumps(respuesta) else: respuesta = { 'error': True, 'mensaje': 'Usuario o Contraseña incorrectos.' } return json.dumps(respuesta)
def validate_session(session_id): from app.models.session import Session session_model = Session() client_origin = (request.remote_addr or "0.0.0.0") client_agent = request.user_agent session_ok = (session_id and session_model.touch(session_id, client_agent, client_origin)) return session_ok
def create_session(username, admin): user = Users() token = user.create_password("secret") sesion = Session() sesion.create_session(username, token, admin) db.session.add(sesion) db.session.commit() return token
def handle_post(data): post = data['post'] session_id = data['session_id'] # save post session = Session().get(session_id) if session is not None: session.addPost(post) # broadcast post to other users in session emit("post", post, room=session_id)
def _handle_regular_user(self, data): session_model = Session() session_id = g.get("session_id", None) model = UserModel(session_id) user = model.create(data) if user: session_model.update(session_id, user_id=user.id) return user return None
def decorated(*args, **kwargs): user = g.get("user") if user and user.get_session_id(): session_touched = g.get("session_touched", None) if not session_touched: session = Session() session_touched = session.touch(user.get_session_id(), request.user_agent, request.remote_addr) if session_touched: return f(*args, **kwargs) abort(401)
def perfil(): sesion = Session() new = request.get_json() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') print(usuario) #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): user = Users() datos = user.get_user(usuario) return json.dumps(datos) respuesta = {'error': True, 'mensaje': 'No has iniciado sesión.'} return json.dumps(respuesta)
def login(email, password, remember: bool, next_url): """Login This is seperated into a function as this code is also needed during signup (see `user_api1.user_post`) Important: This function needs to be called within the context of an request. Otherwise, accessing `g` and `url_for` wont work. """ try: user: User = db.session.query(User).filter(User.email == email).one() if user.check_password(password): g.session = Session(user, session_only=(not remember)) g.session.browser = str(request.user_agent.browser or '?') g.session.platform = str(request.user_agent.platform or '?') db.session.add(g.session) db.session.commit() expiration_date = g.session.last_use + timedelta(days=60) tasks.remove_session.schedule(args=(g.session.id, ), eta=expiration_date) if user.status is Status.pending: next_url = url_for('auth.wait') if not user.email_confirmed: next_url = url_for('auth.confirm') return jsonify({ 'success': True, 'redirect': next_url, 'sid': g.session.token }) else: raise Exception() except Exception as e: return jsonify({'success': False, 'reason': 'credentials'}), 401
def test_my_session_unauthorized_access(self): with app.test_request_context(): event = ObjectMother.get_event() user = ObjectMother.get_user() save_to_db(user, "User saved") save_to_db(event, "Event saved") speaker = Speaker(name="name", email="*****@*****.**", organisation="FOSSASIA", event_id=event.id, user=user, country="India") save_to_db(speaker, "Speaker saved") session = Session(title='test', long_abstract='dsad', start_time=datetime(2003, 8, 4, 12, 30, 45), end_time=datetime(2003, 8, 4, 12, 30, 45), event_id=event.id, speakers=[speaker], state='pending') save_to_db(session, "Session saved") rv = self.app.get(url_for('my_sessions.display_session_view', session_id=session.id), follow_redirects=True) self.assertEqual(rv.status_code, 404)
def test_add_session_type_to_db(self): """Checks the one to many relationship between event and session_types and the many to one relationship between session and session_types""" self.app = Setup.create_app() with app.test_request_context(): event = ObjectMother.get_event() session1 = ObjectMother.get_session() session_type1 = SessionType(name='Type1', length='30', event_id='1') session_type2 = SessionType(name='Type2', length='30', event_id='1') session2 = Session(title='test2', long_abstract='dsadsd', start_time=datetime(2003, 8, 4, 12, 30, 45), end_time=datetime(2003, 8, 4, 12, 30, 45), session_type=session_type1) save_to_db(event, "Event Saved") save_to_db(session1, "Session1 Saved") save_to_db(session2, "Session2 Saved") save_to_db(session_type1, "SessionType1 Saved") save_to_db(session_type2, "SessionType2 Saved") self.assertEqual(session_type1.event_id, 1) self.assertEqual(session_type2.event_id, 1) self.assertEqual(session2.session_type_id, 1) self.assertEqual(session1.session_type_id, None)
def create_app(config: Config): app = FastAPI(openapi_url="/openapi/spec.json", docs_url="/swagger", redoc_url="/redoc", debug=True) app.include_router(router) # wire things up app.config = Config() app.session = SessionWrapper(s=Session()) app.db = DB(app.config.DB_DSN.get_secret_value()) app.repositories = lambda: None app.repositories.zipcodes = ZipCodeRepository(db=app.db) app.shutdown = lambda: __import__('os').kill(app.config.PID, __import__('signal').SIGTERM) @app.on_event("startup") async def setup() -> None: logging.info(f"[APP_SETUP] {app} {app.config}") app.loop = asyncio.get_running_loop() await app.db.setup(app) await app.session.s.setup() @app.on_event("shutdown") async def teardown() -> None: logging.info(f"[APP_TEARDOWN] {app} {app.config}") await app.session.s.teardown() await app.db.teardown() return app
def get_session(event_id=1): return Session(title='test', long_abstract='dsad', start_time=datetime(2003, 8, 4, 12, 30, 45), end_time=datetime(2003, 8, 4, 12, 30, 45), event_id=event_id, state='pending')
def post(self): # validate JSON data parser = reqparse.RequestParser() parser.add_argument('date', type=date, required=True, case_sensitive=False, location='json') parser.add_argument('exercises', type=self.parse_exercises, required=True, case_sensitive=False, location='json') data = parser.parse_args(strict=True) # create a gym session object gym_session = Session(date=data['date'], user_id=g.current_user.id) try: db.session.add(gym_session) db.session.commit() except IntegrityError as exn: current_app.logger.error(exn.args) db.session.rollback() return {'message': 'error: sessions must be unique across dates for each user'}, 409 # create gym record objects and link the to the session try: for exercise in data['exercises']: exercise_id = db.session \ .query(Exercise.exercise_id) \ .filter_by(exercise_name = exercise['exercise name']) \ .scalar() for reps, weight in zip(exercise['reps'], exercise['weights']): record = GymRecord(session_id=gym_session.session_id, exercise_id=exercise_id, reps=reps, weight=weight) db.session.add(record) db.session.commit() return {'Message': 'Record successfully created'}, 201 except Exception as exn: current_app.logger.error(exn.args) abort(500)
class Session(Resource): cache = {} def __init__(self): self._model = SessionModel() def post(self): data = self._model.create((request.remote_addr or "0.0.0.0"), str(request.user_agent)) if data: data = self._model.read(data.id) return jsonify(dict(data)) abort(400) def get(self, session_id=None): response = self._model.read(session_id) if response: return jsonify(response) abort(404) def delete(self, session_id=None): self._model.destroy(session_id) return "" def put(self, session_id=None): data = self._model.update(session_id, data=json.dumps(request.json)) if data: data = self._model.read(session_id) if data: return jsonify(dict(data)) abort(400)
def totalcarrito(user): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): if user.isdigit(): car = Carrito() total = car.get_total_price(user) respuesta = {'total': total} return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Usuario no existe.'} return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def scrape_session(self, session_page): self.browser.get(session_page) speakers = self.speaker_dao.find_all() speakers_by_name = { speaker['speaker_name']: speaker for speaker in speakers } sessions = self.session_dao.find_all() sessions_by_session_id = { session['session_id']: session for session in sessions } self.wait_by_class_name("session") sessions = self.browser.find_elements_by_class_name("session") for session_element in sessions: session = Session() session.from_web_element(session_element) if session.session_id not in sessions_by_session_id: _id = self.session_dao.create(session) session._id = _id sessions_by_session_id[session.session_id] = session speaker_elements = self.browser.find_elements_by_xpath( "//*[@data-modal='user_profile']") for speaker_element in speaker_elements: speaker = Speaker() speaker.from_web_element(speaker_element) if speaker.speaker_name not in speakers_by_name: _id = self.speaker_dao.create(speaker) speaker._id = _id speakers_by_name[speaker.speaker_name] = speaker return len(sessions)
def carrito(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): car = Carrito() lista = car.all_car() if lista == 0: respuesta = { 'error': True, 'mensaje': 'No hay artículos en el carrito.' } return jsonify(respuesta) number = car.number_car() jsona = car.convert(lista, number) return jsonify(jsona) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def create_services(): track = Track.get_service_name() session = Session.get_service_name() speaker = Speaker.get_service_name() sponsor = Sponsor.get_service_name() microlocation = Microlocation.get_service_name() get_or_create(Service, name=track) get_or_create(Service, name=session) get_or_create(Service, name=speaker) get_or_create(Service, name=sponsor) get_or_create(Service, name=microlocation)
def agregarcomentario(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): comm = Comentarios() user = Users() user = user.get_user(usuario) datos = request.get_json() comm.agg_comment(user['id'], datos['comentario'], datos['fecha']) db.session.add(comm) db.session.commit() respuesta = { 'error': False, 'mensaje': 'Comentario agregado exitosamente.' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def create(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): oneProd = productos() product = request.get_json() oneProd.create_prod(product['name'], product['price'], product['img'], product['description'], product['category'], product['sell']) db.session.add(oneProd) db.session.commit() respuesta = { 'error': False, 'mensaje': 'Producto creado exitosamente.' } return json.dumps(respuesta) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def comments(): sesion = Session() usuario = request.headers.get('username') token_angular = request.headers.get('Authorization') #Verificamos si el usuario tiene una sesión activa if token_angular: if sesion.exist_session(usuario, token_angular): comm = Comentarios() lista = comm.all_comments() if lista == 0: respuesta = { 'error': True, 'mensaje': 'No hay notas almacenadas.' } return jsonify(respuesta) number = comm.number_comments() jsona = comm.convert(lista, number) return jsonify(jsona) respuesta = {'error': True, 'mensaje': 'Debes iniciar sesión.'} return json.dumps(respuesta)
def add_session_to_event(request, event_id, state=None, use_current_user=True): """ Session will be saved to database with proper Event id :param use_current_user: :param state: :param request: The request :param event_id: Session belongs to Event by event id """ form = request.form slide_temp_url = form.get('slides_url') video_temp_url = form.get('video_url') audio_temp_url = form.get('audio_url') slide_file = '' video_file = '' audio_file = '' if slide_temp_url: slide_file = UploadedFile(get_path_of_temp_url(slide_temp_url), slide_temp_url.rsplit('/', 1)[1]) if video_temp_url: video_file = UploadedFile(get_path_of_temp_url(video_temp_url), video_temp_url.rsplit('/', 1)[1]) if audio_temp_url: audio_file = UploadedFile(get_path_of_temp_url(audio_temp_url), audio_temp_url.rsplit('/', 1)[1]) if not state: state = form.get('state', 'draft') event = DataGetter.get_event(event_id) new_session = Session(title=form.get('title', ''), subtitle=form.get('subtitle', ''), long_abstract=form.get('long_abstract', ''), start_time=event.start_time, end_time=event.start_time + timedelta(hours=1), event_id=event_id, short_abstract=form.get('short_abstract', ''), level=form.get('level', ''), comments=form.get('comments', ''), language=form.get('language', ''), state=state) if form.get('track', None) != "": new_session.track_id = form.get('track', None) if form.get('session_type', None) != "": new_session.session_type_id = form.get('session_type', None) speaker = Speaker.query.filter_by(email=form.get('email', '')).filter_by(event_id=event_id).first() speaker = save_speaker( request, event_id=event_id, speaker=speaker, user=login.current_user if use_current_user else None ) new_session.speakers.append(speaker) save_to_db(new_session, "Session saved") if state == 'pending': trigger_new_session_notifications(new_session.id, event=event) if slide_temp_url != "" and slide_file: slide_url = upload( slide_file, UPLOAD_PATHS['sessions']['slides'].format( event_id=int(event_id), id=int(new_session.id) )) new_session.slides = slide_url if audio_temp_url != "" and audio_file: audio_url = upload( audio_file, UPLOAD_PATHS['sessions']['audio'].format( event_id=int(event_id), id=int(new_session.id) )) new_session.audio = audio_url if video_temp_url != "" and video_file: video_url = upload( video_file, UPLOAD_PATHS['sessions']['video'].format( event_id=int(event_id), id=int(new_session.id) )) new_session.video = video_url record_activity('create_session', session=new_session, event_id=event_id) update_version(event_id, False, 'sessions_ver') invite_emails = form.getlist("speakers[email]") for index, email in enumerate(invite_emails): if not string_empty(email): new_invite = Invite(event_id=event_id, session_id=new_session.id) hash = random.getrandbits(128) new_invite.hash = "%032x" % hash save_to_db(new_invite, "Invite saved") link = url_for('event_sessions.invited_view', session_id=new_session.id, event_id=event_id, _external=True) Helper.send_email_invitation(email, new_session.title, link) # If a user is registered by the email, send a notification as well user = DataGetter.get_user_by_email(email, no_flash=True) if user: cfs_link = url_for('event_detail.display_event_cfs', identifier=event.identifier) Helper.send_notif_invite_papers(user, event.name, cfs_link, link)
def import_data(file_path, creator_id, task_handle): with open(file_path, 'r') as xml_file: string = xml_file.read().replace('\n', '') update_status(task_handle, 'Parsing XML file') conference_object = PentabarfParser.parse(string) update_status(task_handle, 'Processing event') event = Event() event.start_time = conference_object.start event.end_time = conference_object.end event.has_session_speakers = True event.name = conference_object.title event.location_name = conference_object.venue # + ', ' + conference_object.city event.searchable_location_name = conference_object.city event.state = 'Published' event.privacy = 'public' db.session.add(event) event_time_updated = False update_status(task_handle, 'Adding sessions') for day_object in conference_object.day_objects: for room_object in day_object.room_objects: microlocation, _ = get_or_create(Microlocation, event_id=event.id, name=room_object.name) for event_object in room_object.event_objects: session_type_id = None if event_object.type: session_type, _ = get_or_create(SessionType, event_id=event.id, name=event_object.type, length=str(30)) # TODO: hardcoded here session_type_id = session_type.id track_id = None if event_object.track: string_to_hash = event_object.track seed = int('100'.join(list(str(ord(character)) for character in string_to_hash))) random.seed(seed) color = "#%06x" % random.randint(0, 0xFFFFFF) track, _ = get_or_create(Track, event_id=event.id, name=event_object.track, color=color) track_id = track.id session = Session() session.track_id = track_id session.microlocation_id = microlocation.id session.session_type_id = session_type_id session.title = event_object.title session.short_abstract = event_object.abstract session.long_abstract = event_object.description session.level = getattr(event_object, 'level', None) # https://github.com/niranjan94/python-pentabarf-xml/issues/3 session.start_time = event_object.date + string_to_timedelta(event_object.start) session.end_time = session.start_time + string_to_timedelta(event_object.duration) session.slides = event_object.slides_url session.video = event_object.video_url session.audio = event_object.audio_url session.signup_url = event_object.conf_url session.event_id = event.id session.state = 'accepted' session.speakers = [] save_to_db(session, 'Session Updated') if not event_time_updated: event.start_time = None event.end_time = None event_time_updated = True if not event.start_time or session.start_time < event.start_time: event.start_time = session.start_time if not event.end_time or session.end_time > event.end_time: event.end_time = session.end_time for person_object in event_object.person_objects: name_mix = person_object.name + ' ' + conference_object.title email = ''.join(x for x in name_mix.title() if not x.isspace()) + '@example.com' speaker = Speaker(name=person_object.name, event_id=event.id, email=email, country='Earth', organisation='') db.session.add(speaker) session.speakers.append(speaker) db.session.commit() update_status(task_handle, 'Added session "' + session.title + '"') update_status(task_handle, 'Saving data') save_to_db(event) update_status(task_handle, 'Finalizing') own_event(event=event, user_id=creator_id) return event