def upload_file(): """ Збереження файлів в БД. """ MAX_FILE_SIZE = 4024 * 4024 + 1 if request.method == 'POST': file = request.files["file"] print(request.files) if bool(file.filename): file_bytes = file.read(MAX_FILE_SIZE) gif_str = base64.b64encode(file_bytes) id_ = request.form['id'] print(id_) url = request.form['redirect'] print(url) type = request.form['type'] date1 = datetime.strftime(datetime.now(), "%Y.%m.%d") name = request.form['name'] print(name) session = Session() documents = Document(name=name, file_type=file.mimetype, file=gif_str, type_=type, fk_person=id_) session.add(documents) session.commit() session.close() return redirect('/#!' + url + '#' + request.form['part']) return 'ok'
def add(self, message, latitude, longitude, time_limit=60): post = Post(message, latitude, longitude, time_limit) session = Session() session.add(post) session.commit() session.close() return post
def post_links(): session = Session() data = json.loads(request.data) for link in data['links']: post = Post.get_or_create(session, link['reddit_id']) subreddit = Subreddit.get_or_create(session, link['sub_name']) user = User.get_or_create(session, link['authorname']) post.subreddit_id = subreddit.id post.author_id = user.id post.domain = link['domain'] post.title = link['title'] post.url = link['url'] post.score = link['score'] post.downs = link['downs'] post.ups = link['ups'] post.is_self = link['is_self'] post.over_18 = link['over_18'] post.thumbnail = link['thumbnail'] post.created = float(link['created']) post.scraped_time = Util.now() session.add(post) session.commit() session.close() return jsonify({'received':True})
def put_batch(): session = Session() data = json.loads(request.data) worker = data['id'] users = data['users'] users = filter(lambda u: u is not None, users) usernames = [user['name'] for user in users] for lock in session.query(UserLock).join(User) \ .filter(User.name.in_(usernames), UserLock.status == UserLock.STATUS_WIP, UserLock.locker == worker): for u in users: if u['name'] == lock.user.name: if 'error' in u: eId = str(uuid4()) lock.user.reddit_id = eId else: lock.user.update_from_json(u) session.add(lock.user) session.commit() session.query(UserLock).join(User) \ .filter(User.reddit_id != None, User.name.in_(usernames), UserLock.status == UserLock.STATUS_WIP, UserLock.locker == worker) \ .update({'status': UserLock.STATUS_DONE, 'locker': None}, synchronize_session='fetch') session.commit() session.close() return jsonify({'received':'true'})
def create_item(request, redirect_url, user_id): """Creates a new item and add to database""" # Check if form is complete check_item_form_data(request, redirect_url) # Create DB session db_session = Session() # Add new item to database try: new_item = Item(title=request.form.get("title"), description=request.form.get("description"), category_id=request.form.get("category"), owner_id=user_id) db_session.add(new_item) db_session.commit() except exc.SQLAlchemyError: flash("There was an error. Please try again.", "danger") return redirect(redirect_url) # Close DB session db_session.close() flash("Item added!", "success")
def insert(user_id, file_name, file_size): try: session_obj = Session() tmp = session_obj.query(user_info).filter_by(id=user_id).first() if (tmp == None): Session.remove() return -1 tmp = session_obj.query(file_list).filter_by( user_id=user_id).filter_by(file_name=file_name).first() if (tmp != None): Session.remove() return -2 time = datetime.datetime.now() list_obj = file_list(user_id=user_id, file_name=file_name, file_size=file_size, time=time) session_obj.add(list_obj) session_obj.commit() Session.remove() return 0 except Exception as e: session_obj.rollback() Logger().get_logger().error(str(e)) return -3
def send_stats(): data = request.json if not is_auth(request.headers): return 'not authenticated', 401 patient_id = None time = None moves = None answers_right = None answers_wrong = None try: time = data['time'] answers_right = data['answers_right'] answers_wrong = data['answers_wrong'] patient_id = Cache[request.headers['Token']]['id'] except: return 'invalid parameters', 400 t = Stats(time=time, answers_wrong=answers_wrong, answers_right=answers_right, patient_id=patient_id) s = Session() s.add(t) s.commit() return 'OK'
def upload_photo(): """ Збереження файлів в БД. """ MAX_FILE_SIZE = 4024 * 4024 + 1 if request.method == 'POST': file = request.files["file"] print(file) if bool(file.filename): file_bytes = file.read(MAX_FILE_SIZE) gif_str = base64.b64encode(file_bytes) id_ = request.form['id'] print(id_) type = 'photo' date1 = datetime.strftime(datetime.now(), "%Y.%m.%d") name = 'фотографія' session = Session() documents = Document(name=name, file_type=file.mimetype, file=gif_str, type_=type, fk_person=id_) session.add(documents) session.commit() session.close() print('hello') return redirect('/#!/employees/new/') # return 'ok' return 'ok'
def create_user(login_session, redirect_url): """Creates a new user and add to database""" # Create db_session db_session = Session() # Check to see if user exists in database and add it otherwise user_id = get_user_id(login_session['profile']['username']) if not user_id: # Add user to database try: new_user = User(username=login_session['profile']['username']) db_session.add(new_user) db_session.commit() flash("User created", "success") except exc.SQLAlchemyError: flash("Failed to create user", "danger") return redirect(redirect_url) # Query created user user = db_session.query(User).filter_by( username=login_session['profile']['username']).one() # Close DB session db_session.close() return user.id
def group_alias(login_id, group_name): try: session_obj = Session() ret = session_obj.query(user_info).filter_by(id=login_id).first() if not ret: Session.remove() return (-1, '') ret = session_obj.query(group_alias_info).filter_by( user_id=login_id).filter_by(name=group_name).first() if ret is None: alias_obj = group_alias_info(user_id=login_id, name=group_name) session_obj.add(alias_obj) session_obj.commit() Session.remove() return (0, '') if ret.alias is None: Session.remove() return (0, '') Session.remove() return (0, ret.alias) except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() return (-2, '')
def read_item(shopping: UserResp): aUser = User(username=shopping.username, password=shopping.password) session = Session() session.add(aUser) session.commit() session.close() return
def on_post(self, req, resp): doc = req.context['doc'] lat = doc['lat'] lon = doc['lon'] date_in = datetime.datetime.utcnow() if lat and lon: user = get_user(req, resp) if lon >= -79.8921061: if lon <= -79.8833942: if lat <= 36.0984408: if lat >= 36.0903956: signin = Signin(date_in=date_in, user=user) user.signedin = True Session.add(signin) Session.commit() resp.status = falcon.HTTP_201 resp.location = '/signins/%s' % (signin.id) req.context['result'] = {"action": "sign in", "result": "success"} else: resp.status = falcon.HTTP_409 req.context['result'] = {"action": "sign in", "result": "failure"} else: resp.status = falcon.HTTP_409 req.context['result'] = {"action": "sign in", "result": "failure"}
def upsert_bank(jurisdiction_id, bank_code=None, name=None, fetched=False): if bank_code not in swift_banks: if is_blank(name): name = None if not jurisdiction_id: jurisdiction_id = jurisdiction_by_code("XX") s = Session() bank = _get_bank(s, jurisdiction_id, bank_code) if not bank: bank = Bank(code=bank_code, name=name, country_id=jurisdiction_id, fetched=fetched) s.add(bank) cash_account = Account( code=None, acc_type="CASH", bank=bank, fetched=True ) # CASH accounts don't really exist, so all pre-fetched s.add(cash_account) elif name: if not bank.name: bank.name = name elif bank.name != name: print("Bank with different name: old: %s; new: %s"\ %(bank.name, name)) if len(name) > len(bank.name): bank.name = name s.commit() swift_banks[bank_code] = bank.id s.close() return swift_banks[bank_code]
def add_todo(): data = request.json if not is_auth(request.headers): return 'not authenticated', 401 family_id = None patient_id = None todo = None try: family_id = Cache[request.headers['Token']]['family_id'] patient_id = data['patient_id'] todo = data['todo'] except: return 'invalid parameters', 400 t = Todo(desc=todo, done=False, patient_id=patient_id, caretaker_id=Cache[request.headers['Token']]['id']) s = Session() s.add(t) s.commit() return 'OK'
def update_user_db_ad(): """ Доповнення БД даними з АД """ session = Session() records = session.query(Worker.sid, Worker.fk_person).filter(Worker.sid != '').all() for arg in records: user = [] res = ad.search(search_base=BASE_DN, search_filter="(objectSid={sid})".format(sid=arg[0]), attributes=[ 'mail', 'sn', 'givenName', 'pager', 'thumbnailPhoto', 'mobile', 'givenName-En', 'givenNameUa', 'cityUa', 'ipPhone', 'l', 'givenName-En', 'snEn', 'givenNameUa', 'snUa', 'objectSid' ]) if res: for entry in ad.response: if 'dn' in entry: user.append(dict(entry['attributes'])) if user: if user[0]['thumbnailPhoto']: byte_string = user[0]['thumbnailPhoto'] encoded_data = base64.b64encode(byte_string) photo = Document(name='фотографія', file_type='', file=encoded_data, type_='', fk_person=arg[1]) session.add(photo) for resp in user[0]: if not user[0][resp]: user[0][resp] = '' session.query(Person).filter_by(id=arg[1]).update({ "email": user[0]['mail'], "skype": user[0]['pager'] }) session.query(Worker).filter_by(fk_person=arg[1]).update({ "name_en": user[0]['givenName-En'], "name_ru": user[0]['givenName'], "surname_en": user[0]['snEn'], "surname_ru": user[0]['sn'], "skype": user[0]['pager'], "ip_phone": user[0]['ipPhone'], "email": user[0]['mail'] }) session.commit() session.close()
def create(self, model): session = Session() session.add(model) session.commit() session.close()
def register_room(message, project_identifier): """RedmineのプロジェクトとSlackチャンネルを繋ぐ. :param message: slackbotの各種パラメータを保持したclass :param project_identifier: redmineのプロジェクトの識別名 """ s = Session() channel = message.channel channel_id = channel._body['id'] user = user_from_message(message, s) if not user: return project, project_channel = project_channel_from_identifier( user.api_key, project_identifier, s) if not project: botsend(message, PROJECT_NOT_FOUND) return if not project_channel: project_channel = ProjectChannel(project_id=project.id) s.add(project_channel) channels = project_channel.channels.split( ",") if project_channel.channels else [] if channel_id not in channels: channels.append(channel_id) project_channel.channels = ",".join(channels) s.commit() botsend(message, CHANNEL_REGISTERED.format(project.name)) else: botsend(message, CHANNEL_ALREADY_REGISTERED)
def vacation_user(_id): """ Нарахування відпустки працівнику за діючий рік якщо він прийнятий на роботу цього ж року :param _id: ід працівника """ session = Session() datenow = datetime.strftime(datetime.now(), "%Y-%m-%d") date2 = datetime.strptime(str(datenow), "%Y-%m-%d").date() result = session.query( Worker.id, Worker.started_to_work, Worker.finished_to_work).filter( Worker.status == 'active').filter(Worker.id == _id).first() date = str(result[1].year) + '-12-31' date1 = datetime.strptime(str(date), "%Y-%m-%d").date() if result[1].year == date1.year: if result[1].day < 10: s1 = 2 elif result[1].day < 21: s1 = 1 else: s1 = 0 # кількість заробленої відпустки за цей рік count = s1 + 2 * (date1.month - result[1].month) vacation_new = Vacation(count=count, used=0, balance=count, year=date2.year, updated=date2, fk_worker=result[0]) session.add(vacation_new) session.commit() session.close() return count
def vacation(): """ Заповнення відпусти за поточний рік всім працівникам """ session = Session() date2 = datetime.strftime(datetime.now(), "%Y-%m-%d") date1 = datetime.date(datetime.now()) result = session.query( Worker.id, Worker.started_to_work, Worker.finished_to_work).filter(Worker.status == 'active').all() for arg in result: if date1.year != arg[1].year and not session.query(Vacation).filter( Vacation.year == date1.year).filter( Vacation.fk_worker == arg[0]).first(): # Додати період +24 за поточний рік vacation_new = Vacation(count=24, used=0, balance=24, year=date1.year, updated=date2[0:10], fk_worker=arg[0]) session.add(vacation_new) # нарахування відпустки якщо людина була прийнята на роботу цього року elif not session.query(Vacation).filter( Vacation.year == date1.year).filter( Vacation.fk_worker == arg[0]).first(): vacation_user(arg[0]) session.commit() session.close()
def add_style(): if request.form: name = request.form.get('name', '') s = Session.query(WineStyle).filter_by(name=name).first() if not s: desc = request.form.get('description', '') s = WineStyle(name=name, description=desc) Session.add(s) wineries_id = request.form.get('wineries', '').split(',') s.wineries = [] for _id in wineries_id: w = Session.query(Winery).filter_by(id=_id.strip()).first() if w: s.wineries.append(w) try: Session.commit() except Exception as e: print('unable to add WineStyle') print(e) return style(s.id)
class TestItem(TestCase): def setUp(self): reset_db() self.sess = Session() def tearDown(self): self.sess.close() def test_crud(self): store = StoreModel('testStore') item = ItemModel(name='test', price=12.99, store_id=1) self.assertEqual( self.sess.query(ItemModel).filter( ItemModel.name == 'test').count(), 0) self.sess.add(store) self.sess.add(item) self.sess.commit() self.assertEqual( self.sess.query(ItemModel).filter( ItemModel.name == 'test').count(), 1) self.sess.delete(item) self.sess.commit() self.assertEqual( self.sess.query(ItemModel).filter( ItemModel.name == 'test').count(), 0) self.sess.delete(store) self.sess.commit()
def main(notify): session = Session() gen = session.query(User) \ .join(UserMeta) \ .filter(User.reddit_id != None, \ UserMeta.has_public_likes == UserMeta.YES, \ UserMeta.is_active != UserMeta.NO) for user in gen: try: praw_user = r.get_redditor(user.name) user.update_from_praw(praw_user) for praw_post in praw_user.get_liked(limit=100): update(session, user, praw_post, 1) for praw_post in praw_user.get_disliked(limit=100): update(session, user, praw_post, -1) user.meta.has_public_likes = UserMeta.YES except praw.requests.exceptions.HTTPError as e: print str(e) if '403' in str(e): user.meta.has_public_likes = UserMeta.NO elif '404' in str(e): user.meta.is_active = UserMeta.NO session.add(user.meta) session.add(user) session.commit() session.close()
def upload(user_id, package_name, version, time, remark): try: session_obj = Session() tmp = session_obj.query(user_info).filter_by(id=user_id).first() if (tmp == None): Session.remove() return -1 tmp = session_obj.query(package_info).options( subqueryload(package_info.user)).filter_by( package_name=package_name).filter_by( user_id=user_id).first() if tmp is not None: tmp = session_obj.query(package_info).get(tmp.id) session_obj.delete(tmp) session_obj.commit() package_obj = package_info(user_id=user_id, package_name=package_name, version=version, time=time, remarks=remark) session_obj.add(package_obj) session_obj.commit() Session.remove() return 0 except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() return -2
def branch_list(): """ Заповнення філіалу в БД """ users_list = [] if load_users_from_ad(): process_ad_response(ad.response, users_list, (('userAccountControl', [], False), ('company', [], False))) session = Session() for arg in users_list: if not session.query(Branch).filter( Branch.name == arg['company']).all(): fk_city = session.query( City.id).filter(City.name == arg['cityUa']).first() branch = Branch(name=arg['company'], name_en=arg['companyEn'], zip_code=arg['postalCode'], address_ua=arg['streetAddressUa'], address_en=arg['street'], address_ru=arg['streetAddress'], fk_city=fk_city[0]) session.add(branch) session.commit() session.close()
def _update_task_list(self, limit=10, st=0, ignore=False): session = Session() tasks = self.xunlei.get_task_list(limit, st) for task in tasks[::-1]: if task['status'] == "finished": self.last_task_id = task['task_id'] db_task_status = session.query( db.Task.status).filter(db.Task.id == task['task_id']).first() if db_task_status and db_task_status[0] == "finished": continue db_task = db.Task() db_task.id = task['task_id'] db_task.create_uid = self.uid db_task.cid = task['cid'] db_task.url = task['url'] db_task.lixian_url = task['lixian_url'] db_task.taskname = task['taskname'] db_task.task_type = task['task_type'] db_task.status = task['status'] if db_task.status == "failed": db_task.invalid = True db_task.process = task['process'] db_task.size = task['size'] db_task.format = task['format'] db_task = session.merge(db_task) if not self._update_file_list(db_task): db_task.status = "failed" db_task.invalid = True session.add(db_task) session.commit()
def update_item(item_id, request, redirect_url): """Update item in database""" # Check if form is complete check_item_form_data(request, redirect_url) # Create DB session db_session = Session() # Query item in database by id item = db_session.query(Item).filter_by(id=item_id).one() # Update corresponding item in database try: item.title = request.form.get("title") item.description = request.form.get("description") item.category_id = request.form.get("category") item.last_updated = datetime.utcnow() db_session.add(item) db_session.commit() except exc.SQLAlchemyError: flash("There was an error. Please try again.", "danger") return redirect(redirect_url, item_id=item_id) # Close DB session db_session.close()
def log(user, message): session = Session() message = AuditLogMessage(user=user, message=message, player_name=PLAYER_NAME) session.add(message) session.commit()
def on_post(self, req, resp): doc = req.context['doc'] title = doc['title'] description = doc['description'] from_date = doc['from_date'] to_date = doc['to_date'] from_date_datetime = datetime.datetime.strptime(from_date, "%Y-%m-%d") to_date_datetime = datetime.datetime.strptime(to_date, "%Y-%m-%d") user = get_user(req, resp) event = Event(from_date=from_date_datetime, to_date=to_date_datetime, title=title, description=description, user=user) Session.add(event) Session.commit() resp.status = falcon.HTTP_201 req.context['result'] = {"action": "add event", "result": "success", "event": { 'id': event.id, 'from_date': from_date, 'to_date': to_date, 'title': event.title, 'description': event.description } }
def _update_tasks(self, tasks): session = Session() nm_list = [] bt_list = [] for task in tasks: if task.task_type in ("bt", "magnet"): bt_list.append(task.id) else: nm_list.append(task.id) for res in self.xunlei.get_task_process(nm_list, bt_list): task = self.get_task(res['task_id']) task.status = res['status'] if task.status == "failed": task.invalid = True task.process = res['process'] if res['cid'] and res['lixian_url']: task.cid = res['cid'] task.lixian_url = res['lixian_url'] task = session.merge(task) if task.status in ("downloading", "finished"): if not self._update_file_list(task): task.status = "downloading" session.add(task) session.commit()
def cleaning_add(message, user_name, day_of_week): """指定した曜日の掃除当番にユーザーを追加する :param message: slackbot.dispatcher.Message :param str user_name: 掃除当番に登録するユーザー名 :param str day_of_week: 追加する掃除曜日 """ if day_of_week not in DAY_OF_WEEK: botsend(message, '曜日には `月` 、 `火` 、 `水` 、 `木` 、 `金` のいずれかを指定してください') return s = Session() slack_id = get_slack_id(s, user_name) if not slack_id: botsend(message, '{}はSlackのユーザーとして存在しません'.format(user_name)) return q = s.query(Cleaning).filter(Cleaning.slack_id == slack_id) if s.query(q.exists()).scalar(): botsend(message, '{}は既に登録されています'.format(user_name, day_of_week)) return s.add( Cleaning(slack_id=slack_id, day_of_week=DAY_OF_WEEK.index(day_of_week))) s.commit() botsend(message, '{}を{}曜日の掃除当番に登録しました'.format(user_name, day_of_week))
def import_json(json): session = Session() for item_json in json['items']: positions = [] for p in item_json['positions']: dt = datetime_from_json(p, 'datetime', datetime.now()) positions.append( Position( name=p['name'], description=p['description'], datetime=dt, created=datetime_from_json(p, 'created', dt), updated=datetime_from_json(p, 'updated', dt), )) now = datetime.now() item = Item( name=item_json['name'], description=item_json['description'], tags=get(item_json, 'tags', ''), image_filename=item_json['image_filename'], created=datetime_from_json(item_json, 'created', now), updated=datetime_from_json(item_json, 'updated', now), positions=positions, ) session.add(item) session.commit()
def _update_task_list(self, limit=10, st=0, ignore=False): session = Session() tasks = self.xunlei.get_task_list(limit, st) for task in tasks[::-1]: if len(self.task_id_sample) < TASK_ID_SAMPLE_SIZE and task['lixian_url']: self.task_id_sample.add(task['task_id']) if not self.last_task_id and task['lixian_url']: self.last_task_id = task['task_id'] db_task_status = session.query(db.Task.status).filter( db.Task.id == task['task_id']).first() if db_task_status and db_task_status[0] == "finished" and self.last_task_id: continue db_task = db.Task() db_task.id = task['task_id'] db_task.create_uid = self.uid db_task.cid = task['cid'] db_task.url = task['url'] db_task.lixian_url = task['lixian_url'] db_task.taskname = task['taskname'] db_task.task_type = task['task_type'] db_task.status = task['status'] if db_task.status == "failed": db_task.invalid = True db_task.process = task['process'] db_task.size = task['size'] db_task.format = task['format'] db_task = session.merge(db_task) if not self._update_file_list(db_task): db_task.status = "failed" db_task.invalid = True session.add(db_task) session.commit()
def _update_tasks(self, tasks): session = Session() nm_list = [] bt_list = [] for task in tasks: if task.task_type in ("bt", "magnet"): bt_list.append(task.id) else: nm_list.append(task.id) for res in self.xunlei.get_task_process(nm_list, bt_list): task = self.get_task(res['task_id']) task.status = res['status'] if task.status == "failed": task.invalid = True task.process = res['process'] if res['cid'] and res['lixian_url']: task.cid = res['cid'] task.lixian_url = res['lixian_url'] task = session.merge(task) if task.status in ("downloading", "finished"): if not self._update_file_list(task): task.status = "failed" task.invalid = True session.add(task) session.commit()
def process_command_output(queue): # TODO: run the command and put its data in the db command = queue.get() start_time = time.time() try: proc = Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=os.setsid) longer_exec_command = False #For longer running commands while proc.poll() is None: exec_time = time.time() - start_time if exec_time > 60: #kill the command execution os.killpg(os.getpgid(proc.pid), signal.SIGKILL) longer_exec_command = True stdout, stderr = proc.communicate() duration = 0 if longer_exec_command else time.time() - start_time length = len(command) output = stdout if not stderr else stderr cmd_metadata = Command(command, length, duration, output) dbsession = Session() dbsession.add(cmd_metadata) dbsession.commit() except Exception as e: raise Exception("DB insertion failed...")
def upsert_organisation(name, core=None, fetched=False): """Includes normalisation Update not implemented """ s = Session() name = clean_name(name) org = _organisation_by_name(s, name) if org: #if name_norm != None and name_norm != org.name_norm: # print("Organisation %s with different normalised name: old: '%s'; new: '%s'"\ # %(name, org.name_norm, name_norm)) # if jurisdiction != None and jurisdiction != org.jurisdiction: # print("Organisation %s with different jurisdiction: old: '%s'; new: '%s'"\ # %(name, org.jurisdiction, jurisdiction)) # if org_type != None and org_type != org.org_type: # print("Organisation %s with different type: old: '%s'; new: '%s'"\ # %(name, org.org_type, org_type)) if core != None and core != org.core: print("Organisation %s with different core: old: '%s'; new: '%s'"\ %(name, org.core, core)) else: org = Organisation(name=name, core=core, fetched=fetched) s.add(org) s.commit() result = org.id s.close() return result
def upsert_alias(name, org_id, jurisdiction_id): """Atomic operation includes commit does not include normalisation """ s = Session() name = clean_name(name) if is_blank(name) or not org_id: return None alias = _get_alias(s, name, org_id, jurisdiction_id) if not alias: alias = Alias(alias=name, org_id=org_id, country_id=jurisdiction_id) s.add(alias) company = _get_organisation(s, org_id) if not company: # TODO: What do we do with anonymous entities? E.g. cash sources raise Exception("Expected company with id=%d but not found"%org_id) # Out because names are processed after import is complete # if len(name) < len(company.name): # company.name = name s.commit() result = alias.id s.close() return result
def load_actions(json_data): data = json.loads(json_data) items = data["items"] items.remove({}) session = Session() for item in items: action = action_from_json(item) if action and not _sgx_key_exists(session, action.sgx_key): security_query = session.query(SgxActionSecurity).filter(SgxActionSecurity.company_name == action.company_name) if (security_query.count() == 0): # New company_name security = SgxActionSecurity(company_name=action.company_name) session.add(security) else: security = security_query.one() if (security.symbol != None): action.symbol = security.symbol session.add(action) print "Added %s" % action session.commit()
def add_winery(): if request.method == 'POST': if request.form: name = request.form.get('name', '') w = Session.query(Winery).filter_by(name=name).first() if not w: address = request.form.get('address', '') phone = request.form.get('phone', '') url = request.form.get('url', '') desc= request.form.get('description', '') try: w = Winery(name=name, address=address, phone=phone, url=url, description=desc) Session.add(w) Session.commit() except Exception as e: print('unable to add winery') print(e) return winery(w.id) else: print('found winery with the same name') return redirect('/') else: return render_template('wineryformpage.html')
def submit_person(): session = Session() person = None if 'id' in request.form: person = session.query(Person).filter(Person.id == request.form['id']).first() else: person = Person() person.name = request.form['name'] if 'location' in request.form: person.location = request.form['location'] if 'image_id' in request.form and request.form['image_id']: person.image_id = request.form['image_id'] elif('cover' in request.files) and request.files['cover'] and request.files['cover'].filename: upload = request.files['cover'] file = File() file.name = secure_filename(upload.filename) file.type = 'image' file.mime = guess_type(file.name)[0] file.data = upload.read() person.image = file session.add(person) session.commit() return redirect(url_for('index'))
def main(notify): session = Session() total = session.query(Subreddit).count() count = 0 notify("starting update of %d subs" % total) query = session.query(Subreddit).order_by("scraped_time asc") dbi = DBIterator(query=query, use_offset=None) for subreddit in dbi.results_iter(): count += 1 try: subreddit.update_from_praw(r.get_subreddit(subreddit.url.split('/')[2])) session.add(subreddit) except (praw.requests.exceptions.HTTPError, praw.errors.InvalidSubreddit) as e: print "ERROR", str(e) subreddit.touch() session.add(subreddit) if count % 2000 == 0 and notify is not None: notify("at %d of %d" % (count, total)) if count % 10 == 0: session.commit() session.commit()
def log(user, message): if not LOGGING_ENABLED: return session = Session() message = AuditLogMessage( user=user, message=message, player_name=PLAYER_NAME) session.add(message) session.commit()
def addPost(): title = request.form.get('title') year = request.form.get('year') session = Session() m = Movie(title=title, year=year) session.add(m) session.commit() return redirect('/')
def on_post(self, req, resp): doc = req.context['doc'] users=Session.query(User).all() unique=True for user in users: if doc['email'] == user.email: unique=False if unique: user = User(name=doc['name'], email=doc['email'].lower(), signedin=False,registerTime=datetime.datetime.today()) print(datetime.datetime.today()) user.salt = bcrypt.gensalt() user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt) s=smtplib.SMTP_SSL('smtp.gmail.com',465) s.ehlo() s.login('*****@*****.**','helloworld@ppclub') code=randint(1000000,10000000) user.code=code msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code)) msg['From']='*****@*****.**' msg['To']=user.email msg['Subject']='PhoenixNow Account Confirmation' s.send_message(msg) s.close() Session.add(user) Session.flush() Session.commit() req.context['user'] = user.id req.context['result'] = {"result": "success", "action": "register"} else: user=get_user(req,resp) td=datetime.timedelta(minutes=30) if datetime.datetime.today()-td<user.registerTime or user.emailVerified==True: description = "User was already made" title = "User creation conflict" raise falcon.HTTPConflict(title=title, description=description) else: Session.delete(user) Session.flush() user = User(name=doc['name'], email=doc['email'], signedin=False,registerTime=datetime.datetime.today()) print(datetime.datetime.today()) user.salt = bcrypt.gensalt() user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt) s=smtplib.SMTP_SSL('smtp.gmail.com',465) s.ehlo() s.login('*****@*****.**','helloworld@ppclub') code=randint(1000000,10000000) user.code=code msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code)) msg['From']='*****@*****.**' msg['To']=user.email msg['Subject']='PhoenixNow Account Confirmation' s.send_message(msg) s.close() Session.add(user) Session.flush() Session.commit() req.context['user'] = user.id req.context['result'] = {"result": "success", "action": "register"}
def submit(uid, problem, lang, source, fn): #Validate parameters if not lang in ['cc','python','java']: if fn[-3:] == '.py': lang = 'python' elif fn[-3:] in ['.cc','.c','.cpp','.cxx']: lang = 'cc' elif fn[-3:] in ['.java']: lang = 'java' else: p = re.compile(r'\$\$[ ]*language:[ ]*(python|cc|java)[ ]*\$\$') m = p.search(source) if m: lang = m.group(1) else: #Todo detect by magic regexps return "Unable to detect language" if problem == -1: p = re.compile(r'\$\$[ ]*problem:[ ]*([0-9]+)[ ]*\$\$') m = p.search(source) if m: problem = int(m.group(1)) else: p = re.compile(r'(0-9)+') m = p.search(fn) if m: problem = int(m.group(1)) else: return "Unable to detect problem number" if len(source) < 5: return "No source code submitted" #Send job to overlord try: code, msg = client.judge(problem, lang, source) session = Session() s = Submission() s.submitter_id = uid s.source = source s.problem_id = problem s.submitTime = datetime.utcnow() if int(code) == 12: s.jobid = int(msg) s.code = -1 s.msg = '' else: s.msg = msg s.code = code s.jobid = None s.judgeTime = datetime.utcnow() session.add(s) session.commit() return "" except Exception as e: return str(e)
def setUp(self): Base.metadata.drop_all(engine) Base.metadata.create_all(engine) p1 = Pyexcel(id=0, name="Adam", weight=11.25, birth=datetime.date(2014, 11, 11)) session = Session() session.add(p1) p1 = Pyexcel(id=1, name="Smith", weight=12.25, birth=datetime.date(2014, 11, 12)) session.add(p1) session.commit()
def store(data): session = Session() if Data.compare_last(session, data): item = Data(**data) session.add(item) session.commit() logging.info('Stored!') else: logging.debug('No Changes')
def add_song_to_playlist(playlist_id, song_id): session = Session() append_index = session.query(PlaylistItem) \ .filter_by(playlist_id=playlist_id) \ .count() item = PlaylistItem(playlist_id=playlist_id, song_id=song_id, index=append_index) session.add(item) session.commit() return get_playlist(playlist_id)
def post(self): session = Session() new_user = db.User(flask.request.form['username'], flask.request.form['first_name'], flask.request.form['last_name'], flask.request.form['password']) session.add(new_user) session.commit() flask.flash('Welcome! Please log in now!') return flask.redirect(flask.url_for('login'))
def update_tags(cls, xg_device_token, tags): try: r = Session.query(cls).filter(cls.xg_device_token == xg_device_token).first() r.tags = tags Session.add(r) Session.commit() except sqlalchemy.exc.IntegrityError, e: logger.warning('msg[update tags error] table[%s] e[%s]' % (__tablename__, e)) Session.rollback()
def addRelation(self, user, event): s = Session() attendee = Attendee(user,event) try: s.add(attendee) s.commit() except: return False finally: s.close() return True
def add(): if request.method == 'GET': return render_template('add-movie.html') else: title = request.form.get('title') year = request.form.get('year') session = Session() m = Movie(title=title, year=year) session.add(m) session.commit() return redirect('/')
def createOrganization(json1): e = Organization.fromdict(json1) s = Session() try: s.add(e) s.commit() except: print("here") return False finally: s.close() return True
def test_07_interests_write(self): session = Session() joey = session.query(Volunteer).filter_by(name='Joey Wood').first() moey = VolunteerInterests("youth", joey.id) self.assertTrue(moey.interest == "youth") try: session.add(moey) session.commit() session.close() self.assertTrue(True) except exc.SQLAlchemyError: self.assertTrue(False)
def test_09_neighborhood_write(self): session = Session() joey = session.query(Volunteer).filter_by(name='Joey Wood').first() moey = VolunteerNeighborhoods("backbay", joey.id) self.assertTrue(moey.neighborhood == "backbay") try: session.add(moey) session.commit() session.close() self.assertTrue(True) except exc.SQLAlchemyError: self.assertTrue(False)
def test_11_skill_write(self): session = Session() joey = session.query(Volunteer).filter_by(name='Joey Wood').first() moey = VolunteerSkills(SkillsEnum.teaching, joey.id) self.assertTrue(moey.skill == "teaching") try: session.add(moey) session.commit() session.close() self.assertTrue(True) except exc.SQLAlchemyError: self.assertTrue(False)
def test_11_interests_write(self): session = Session() race = session.query(Event).filter_by(name='Race for the Cure').first() dace = EventInterests("Youth", race.id) self.assertTrue(dace.interest == "Youth") try: session.add(dace) session.commit() session.close() self.assertTrue(True) except exc.SQLAlchemyError: self.assertTrue(False)
def test_13_neighborhood_write(self): session = Session() race = session.query(Event).filter_by(name='Race for the Cure').first() dace = EventNeighborhoods("Back Bay", race.id) self.assertTrue(dace.neighborhood == "Back Bay") try: session.add(dace) session.commit() session.close() self.assertTrue(True) except exc.SQLAlchemyError: self.assertTrue(False)
def test_15_skill_write(self): session = Session() race = session.query(Event).filter_by(name='Race for the Cure').first() dace = EventSkills("Teaching/Tutoring", race.id) self.assertTrue(dace.skill == "Teaching/Tutoring") try: session.add(dace) session.commit() session.close() self.assertTrue(True) except exc.SQLAlchemyError: self.assertTrue(False)
def _update_task_list(self, limit=10, st=0, ignore=False): now = self.time() with self._last_update_task_lock: if now <= self._last_update_task and limit <= self._last_update_task_size: return self._last_update_task = self.time() self._last_update_task_size = limit session = Session() tasks = self.xunlei.get_task_list(limit, st) for task in tasks[::-1]: db_task_status = session.query(db.Task.status).filter( db.Task.id == task['task_id']).first() if db_task_status and db_task_status[0] == "finished": continue db_task = self.get_task(int(task['task_id'])) changed = False if not db_task: changed = True db_task = db.Task() db_task.id = task['task_id'] db_task.create_uid = self.uid db_task.cid = task['cid'] db_task.url = task['url'] db_task.lixian_url = task['lixian_url'] db_task.taskname = task['taskname'] or "NULL" db_task.task_type = task['task_type'] db_task.status = task['status'] db_task.invalid = True db_task.process = task['process'] db_task.size = task['size'] db_task.format = task['format'] else: db_task.lixian_url = task['lixian_url'] if db_task.status != task['status']: changed = True db_task.status = task['status'] if db_task.status == "failed": db_task.invalid = True if db_task.process != task['process']: changed = True db_task.process = task['process'] session.add(db_task) if changed and not self._update_file_list(db_task, session): db_task.status = "failed" db_task.invalid = True session.add(db_task) session.commit() session.close()