def registration_controller(request): errors = {} is_valid = True data = request.get('data') if 'login' not in data: errors.update({'login': '******'}) is_valid = False if 'password' not in data: errors.update({'password': '******'}) is_valid = False if not is_valid: response = make_response(request, 400, errors) return response hmac_obj = hmac.new(SECRET_KEY.encode(), data.get('password').encode()) password_digest = hmac_obj.digest() with session_scope() as db_session: user = User(name=data.get('login'), password=password_digest) db_session.add(user) token = login(request, user) response = make_response(request, 200, {'token': token}) return response
def setupRecipes(self, recipes, selected=None): tree = self.recipesList try: tree.DeleteChildren(self.recipesRoot) except: self.recipesRoot = tree.AddRoot(_("Recipes")) if recipes["recipes"]: self.addRecipesToTree(tree, self.recipesRoot, recipes, self.icons[FOLDER_ICON], self.icons[FOLDER_OPEN_ICON], self.icons[FILE_ICON]) item, cookie = tree.GetFirstChild(tree.GetRootItem()) while item and tree.ItemHasChildren(item): item, cookie = tree.GetFirstChild(item) with session_scope(self.database) as session: recipe = session.query(Recipe)\ .get(self.recipesList.GetPyData(item)) self.setStatusBarText(recipe) self.showRecipe(recipe, self.recipe_panel) else: self.clearRecipe(self.recipe_panel)
def commit_reddit(self, unique_id, synonyms, text, author, subreddit, date): with session_scope() as session: if self.post_exists(session, unique_id): return False synonyms = [ self.get_synonym(session, synonym) for synonym in synonyms ] if None in synonyms: raise RuntimeError("Synonyms missing from the database.") hashed_author = self.hash_identifier(author) hashed_id = self.hash_identifier(unique_id) reddit_post = RedditPost(author_id=hashed_author, subreddit=subreddit, synonyms=synonyms, date=date, contents=text, id=hashed_id) session.add(reddit_post) session.commit() return True
def get_max_id_from_viewed_candidates_and_category(self, category_id, company_id): with session_scope() as session: return session.query(ViewedCandidatesByCompanyModel.candidate_id).join(CandidateModel).\ filter(ViewedCandidatesByCompanyModel.company_id.like(company_id), CandidateModel.field_of_work.like(category_id)).\ order_by(ViewedCandidatesByCompanyModel.viewed_id.desc()).first()
def add_ocena(ucenik, predmet, vrednost_ocene): check_type(ucenik, Ucenik) check_type(predmet, Predmet) if not isinstance(vrednost_ocene, int) or vrednost_ocene < 1 or vrednost_ocene > 5: raise ValueError('vrednost_ocene is out of predefined domain') daos = {'korisnik': None, 'predmet': None} try: with session_scope() as session: daos['korisnik'] = DAOManager.get_korisnik_dao(session) daos['predmet'] = DAOManager.get_predmet_dao(session) slusa = daos['korisnik'].get_uceniks_predmets_slusa( ucenik, predmet) if slusa is None: raise UpdateInfoError('Ucenik ne slusa uneti predmet') ocena = Ocena(vrednost_ocene, slusa) daos['predmet'].add_ocena(ocena) return True except UpdateInfoError: raise except: return False finally: for dao in daos.values(): DAOManager.release(dao)
def sign_up(self, name, email, password, description): with session_scope() as session: session.add( CompanyModel(name=name, email=email, password=password, description=description))
def registration_controller(request): errors = {} is_valid = True request = get_login_pass_from_data(request) print(f'request-updated: {request}') if not 'password' in request: errors.update({'password': '******'}) is_valid = False if not 'login' in request: errors.update({'login': '******'}) is_valid = False if not is_valid: return make_response(request, 400, {'errors': errors}) hmac_obj = hmac.new(SECRET_KEY, request.get('password').encode()) password_digest = hmac_obj.digest() with session_scope() as db_session: user = User(name=request.get('login'), password=password_digest) db_session.add(user) token = login(request, user) return make_response(request, 200, {'token': token})
def registration_controller(request): errors = {} is_valid = True data = request.get('data') if not 'password' in data: errors.update({'password': '******'}) is_valid = False if not 'login' in data: errors.update({'login': '******'}) is_valid = False if not is_valid: return make_response(request, 400, {'errors': errors}) # сокрытие пароля для хранения на сервере hmac_obj = hmac.new(SECRET_KEY.encode(), data.get('password').encode()) password_digest = hmac_obj.digest() with session_scope() as db_session: user = User(name=data.get('login'), password=password_digest) db_session.add(user) token = login(request, user) return make_response(request, 200, {'token': token})
def make_response(request, code, data=None): action = request.get('action') token = request.get('token') result = { 'action': action, 'time': request.get('time'), 'token': token, 'data': data, 'code': code } # print(f'action={action}') # print(f'token={token}') if action == 'echo' and token: with session_scope() as db_session: user_session = db_session.query(UserSession).filter_by( token=token).first() # print(f'user_session={user_session}') if user_session and not user_session.closed: result['username'] = user_session.user.name return result
def authenticate(login, password): with session_scope() as db_session: user = db_session.query(User).filter_by(name=login).first() hmac_obj = hmac.new(SECRET_KEY.encode(), password.encode()) password_digest = hmac_obj.hexdigest() if user and hmac.compare_digest(password_digest, user.password): return user
def delete_message_controller(request): data = request.get('data') message_id = data.get('message_id') with session_scope() as session: message = session.query(Message).filter_by(id=message_id).first() session.delete(message) return make_response(request, 200)
def get_items(): with session_scope() as session: entries = [{ "title": e.title, "link": e.link, "image": e.image } for e in session.query(Entry).all()] return entries
def index(): with session_scope() as db_session: data = db_session.query(Log).all() # when using the object retrieved from the database outside # the with-scope, use the line below to extract the data. db_session.expunge_all() return render_template('index.html', data=data)
def echo_controller(request): data = request.get('data') message = Message(data=data) with session_scope() as db_session: db_session.add(message) response = make_response(request, 200, data) return response
def write_message_to_candidate(self, candidate_id, company_id, message): with session_scope() as session: session.add( MessageModel(company_id=company_id, candidate_id=candidate_id, send_by=0, seen=0, message=message))
def get_all_messages_with_candidate(self, candidate_id, company_id): with session_scope() as session: session.query(MessageModel).filter( MessageModel.candidate_id.like(candidate_id), MessageModel.company_id.like(company_id)).all() session.query(MessageModel).filter(MessageModel.candidate_id.like(candidate_id), MessageModel.company_id.like(company_id)).\ update({MessageModel.seen: 1}, synchronize_session=False)
def logout_controller(request): with session_scope() as db_session: user_session = db_session.query(Session).filter_by( token=request.get('token')).first() user_session.closed = datetime.now() response = make_response(request, 200, 'Session closed') return response
def saveRecipe(self, edit_recipe): self.setStatusBarText(_("saving recipe")) errors = False ingredients = edit_recipe.get_ingredients() if ingredients is None: errors = True title = edit_recipe.get_name() if not title: errors = True #TODO: display error message if not errors: with session_scope(self.database) as session: logging.debug("user %s" % session.query(User).get(self.userId)) recipe = None if edit_recipe.get_recipe_id(): recipe = session.query(Recipe)\ .get(edit_recipe.get_recipe_id()) if not recipe: recipe = Recipe() recipe.title = title recipe.description = edit_recipe.get_description() recipe.algorythm = edit_recipe.get_algorythm() recipe.time = edit_recipe.get_time() recipe.difficulty = edit_recipe.get_difficulty() recipe.groups = session.query(Group)\ .filter(Group.id.in_(edit_recipe.get_groups())).all() recipe.user = session.query(User).get(self.userId) if not recipe.id: self.setStatusBarText(session.add(recipe)) elif recipe.ingredients: for ingredient in recipe.ingredients: session.delete(ingredient) recipe.ingredients = [] session.flush() for substance, amount, unit in ingredients: try: session.add(Ingredient(recipe=recipe, substance=self.database .getSubstance(substance, session), unit=self.database .getUnit(unit, session), amount=amount)) except sqlalchemy.exc.IntegrityError as e: logging.error(e) current = self.tabsContainer.GetSelection() self.tabsContainer.SetSelection(self.tabs["recipes"]) #TODO: this should be a delete, but that causes everything to blow up self.tabsContainer.RemovePage(current) else: self.setStatusBarText(_("errors"))
def get_messages_controller(request): with session_scope() as db_session: messages = reduce( lambda value, item: value + [{'data': item.data, 'created': item.created.timestamp()}], db_session.query(Message).all(), [] ) response = make_response(request, 200, messages) return response
def get_new_posts(self, synonym=None, with_sentiment=False, limit=None): with session_scope() as session: query = session.query(Post).filter(Post.sentiment.is_(None)) if limit: query = query.order_by(Post.date).limit(limit) posts = query.all() return {post.id: post.contents for post in posts}
def commit_synonyms(self, synonyms): with session_scope() as session: for synonym in synonyms: if self.get_synonym(session, synonym): continue session.add(Synonym(name=synonym)) session.commit()
def __set_job_record_status(self, job_id, status, result = None): job_record = self.__get_job_record(job_id) job_record.job_status = status if status in [QueuedJobStatus.FAIL, QueuedJobStatus.SUCCESS]: job_record.job_result = json.dumps(result) job_record.timestamp = datetime.datetime.now() with session_scope() as db_session: db_session.add(job_record) db_session.commit()
def plot_intersections_curvature(punctured_region_size): with session_scope() as s: statement = s.query(Result).filter( Result.punctured_region_size == punctured_region_size).statement df = pd.read_sql(statement, s.bind) df.groupby("intersections")["curvature"].mean().plot() df.plot.scatter(x="intersections", y="curvature") plt.show()
def random_integer(): min_ = -1000000000 max_ = 1000000000 rand = randint(min_, max_) with session_scope() as session: while session.query(Ocena).filter( Ocena.ocena_id == rand).limit(1).first() is not None: rand = randint(min_, max_) return rand
def setupEditRecipe(self, tab): with session_scope(self.database) as session: substance_names = [name.name for name in self.database.getSubstances(session)] unit_names = [name.name for name in self.database.getUnits(session)] groups = self.database.getGroups(session) tab.setup(groups, substance_names, unit_names) tab.set_save_action(self.saveRecipe)
def login(request, user): hash_obj = hashlib.sha256() hash_obj.update(SECRET_KEY.encode()) hash_obj.update(str(request.get('time')).encode()) token = hash_obj.hexdigest() with session_scope() as db_session: user_session = UserSession(user=user, token=token) db_session.add(user_session) return token
def add_to_database(link_string, server, parent, to_be_visited): with session_scope() as session: # try: session.add( Websites(website_link=link_string, server=server, parent_id=parent)) to_be_visited.append(link_string) print(link_string) return to_be_visited
def update_message_controller(request): data = request.get('data') message_id = data.get('message_id') message_data = data.get('message_data') with session_scope() as db_session: message = db_session.query(Message).filter_by(id=message_id).first() message.data = message_data response = make_response(request, 200) return response
def plot_min_cycled(words): with session_scope() as s: for word in words: cycled_words = Word(word[1:]).get_cyles() statement = s.query(Result).filter( Result.word.in_(cycled_words), ).statement df = pd.read_sql(statement, s.bind) print(df)
def __get_korisnik_by_pk(korisnik_dao_call, primary_key): dao = None try: with session_scope() as session: dao = DAOManager.get_korisnik_dao(session) return korisnik_dao_call(dao, primary_key) except: return None finally: DAOManager.release(dao)
def get_uceniks_slusa(ucenik): dao = None try: with session_scope() as session: dao = DAOManager.get_korisnik_dao(session) return dao.get_uceniks_slusa(ucenik) except: return None finally: DAOManager.release(dao)
def get_slusa_by_pk(ucenik_id, predmet_id): dao = None try: with session_scope() as session: dao = DAOManager.get_korisnik_dao(session) slusa = dao.get_slusa_by_pk(ucenik_id, predmet_id) return slusa except: return None finally: DAOManager.release(dao)
def get_razred_by_godina(godina): dao = None try: with session_scope() as session: dao = DAOManager.get_razred_dao(session) return dao.get_razred_by_godina(godina) except: return None finally: if dao is not None: DAOManager.release(dao)
def get_profesors_predmets_slusa(predmet, profesor): dao = None try: with session_scope() as session: dao = DAOManager.get_korisnik_dao(session) slusas = dao.get_profesors_predmets_slusa(predmet, profesor) return slusas except: return None finally: DAOManager.release(dao)
def getRecipes(self, name=None, ingredients=None, groups=None): print name, ingredients with session_scope(self.database) as session: self.setupRecipes(self.database. getRecipesByGroups(session, title=name, ingredients=ingredients)) if name or ingredients: self.recipesList.ExpandAllChildren(self.recipesList.GetRootItem()) else: self.recipesList.CollapseAllChildren(self.recipesList.GetRootItem())
def selectRecipe(self, event): event.Skip() item = event.GetItem() if item and not self.recipesList.ItemHasChildren(item): with session_scope(self.database) as session: recipe = session.query(Recipe)\ .get(self.recipesList.GetPyData(item)) self.setStatusBarText(recipe) self.showRecipe(recipe, self.recipe_panel) else: self.recipesList.Toggle(item)
def popNextQueuedJob(self): if self.__len__() == 0: return None try: queued_job = self.__get_next_queued_job() queued_job_record = self.__get_job_record(queued_job.job_id) with session_scope() as db_session: db_session.delete(queued_job) # remove this job from the queue db_session.commit() return queued_job_record except: return None
def recipe_options(self, event): with session_scope(self.database) as session: recipe = session.query(Recipe).get(self.selected_recipe) if event.GetId() == 0: # open in new tab self.open_recipe_tab(recipe) elif event.GetId() == 1: # edit self.edit_recipe(recipe) elif event.GetId() == 2: # new self.edit_recipe() elif event.GetId() == 3: # delete session.delete(recipe) session.commit() self.selected_recipe = None self.setupRecipes(self.database.getRecipesByGroups(session)) self.Layout()
def addJobRecord(self, function_id, function_inputs_dict): with session_scope() as db_session: jid = None try: new_job = JobRecord(function_id,json.dumps(function_inputs_dict)) db_session.add(new_job) db_session.commit() except: jid= -1 try: new_queued_job = QueuedJob(new_job.id) db_session.add(new_queued_job) db_session.commit() jid = new_job.id except: db_session.delete(new_job) db_session.commit() jid = -1 return jid
def setup(self): self.tabs = {"recipes": 0, "edit": 1} self.database = DBConfig('sqlite:///database.db') session = self.database.getSession() self.userId = session.query(User)\ .filter(User.name.like('dan')).first().id session.close() self.tabsContainer.SetSelection(self.tabs["recipes"]) isz = (16, 16) self.il = wx.ImageList(isz[0], isz[1]) self.icons = { FOLDER_ICON: self.il.Add(wx.ArtProvider_GetBitmap(wx.ART_FOLDER, wx.ART_OTHER, isz)), FOLDER_OPEN_ICON: self.il.Add(wx.ArtProvider_GetBitmap(wx.ART_FILE_OPEN, wx.ART_OTHER, isz)), FILE_ICON: self.il.Add(wx.ArtProvider_GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))} self.recipesList.SetImageList(self.il) self.getRecipes() with session_scope(self.database) as session: substance_names = [name.name for name in self.database.getSubstances(session)] self.searchIngredients.SetChoices(substance_names) self.searchIngredients.SetItemsCallback(self.filterIngredients) self.setupEditRecipe(self.edit_recipe_tab) self.recipes_menu_options = [_("open in new tab"), _("edit"), _("new"), _("delete")] self.setStatusBarText(_("setup: OK"))
def main(): """ Prompt user & initialization """ print("braindocs2database") print("Copyright (c) 2015 ai-one inc. All rights reserved.") print("") print(">>> Current settings:\n") cfg = PromptingConfigParser() # add default settings cfg.add_section("braindocs") cfg.add_section("database") cfg.set("database", "url", "sqlite:///braindocs_export.db") cfg.set("braindocs", "username", "bd_user") cfg.set("braindocs", "password", "bd_pw") cfg.set("braindocs", "url", "https://nathandev2.cloudapp.net/at") # read settings from file cfg.read("braindocs2database.config") # prompt update print(cfg) while promptyesno("\nUpdate settings?"): print("") cfg.prompt() with open("braindocs2database.config", 'wb') as fp: cfg.write(fp) print("\n>>> Updated settings:\n") print(cfg) """ Setup database connection """ engine = create_engine(cfg.get("database", "url"), echo=False) #Base.metadata.drop_all(engine) # optional: drop all Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) """ Setup braindocs connection """ bd = BraindocsApi( username=cfg.get("braindocs", "username"), password=cfg.get("braindocs", "password"), baseURL=cfg.get("braindocs", "url")) """ Import braindocs entries into database """ print("\nStarting import...") with session_scope(Session()) as session: for ar in iterprogress(bd.getAnalysisResults(), "importing analysis results", 1): arentry = AnalysisResult() for key, value in ar.iteritems(): if isinstance(value, (list, dict)): value = json.dumps(value, ensure_ascii=False) if key == "create_date": value = dateutil.parser.parse(value).replace(tzinfo=None) setattr(arentry, key, value) if key == "analysisId": for tu in bd.getAnalysisDetailsTextUnits(value): tuentry = AnalysisResultTextUnit() for key, value in tu.iteritems(): setattr(tuentry, key, value) arentry.textunits.append(tuentry) session.merge(arentry)
def __len__(self): with session_scope() as db_session: all_jobs = db_session.query(QueuedJob).all() return len(all_jobs)
def removeJobRecord(self,job_id): job_record = self.__get_job_record(job_id) with session_scope() as db_session: db_session.delete(job_record) db_session.commit() return job_record
def __get_job_record(self,job_id): with session_scope() as db_session: return db_session.query(JobRecord).filter_by(id=job_id).one()
def __get_next_queued_job(self): with session_scope() as db_session: return db_session.query(QueuedJob).order_by(QueuedJob.id).first()