def do_user_import(): if not request.files["file"]: return render_template("importusers.html") users = [] reader = csv.reader(request.files["file"]) for id, name, mail, password, salt, admin, lfmsess, lfmstatus in reader: mail = None if mail == "None" else mail admin = admin == "True" lfmsess = None if lfmsess == "None" else lfmsess lfmstatus = lfmstatus == "True" users.append( User( id=uuid.UUID(id), name=name, password=password, salt=salt, admin=admin, lastfm_session=lfmsess, lastfm_status=lfmstatus, ) ) User.query.delete() for u in users: db_sess.add(u) db_sess.commit() return redirect(url_for("user_index"))
def upsert_contributors(o_data, r_data): organization = session.query(Organization).filter(Organization.id==o_data.id).first() contributors = set() for r_item in r_data: if not r_item.fork: c_data = r_item.get_contributors() repo_contributors = [] for c_item in c_data: check_rate_limit(c_item) contributor = p_formatter(c_item) contributor = upsert(model=Person, unique_key='id', item=contributor) contributors.add(contributor) repo_contributors.append(contributor) repository = session.query(Repository).filter(Repository.id==r_item.id).first() repository.contributors = repo_contributors session.add(repository) session.commit() contributors = list(contributors) organization.contributors = contributors try: session.add(organization) session.commit() except: session.rollback()
def upsert_repositories(o_data): organization = session.query(Organization).filter(Organization.id==o_data.id).first() r_data = o_data.get_repos() repositories = [] for r_item in r_data: check_rate_limit(r_item) repository = r_formatter(r_item) source_login = repository['source_owner_login'] if source_login: repository['source_civic'] = source_login.lower() in organizations_civic repository['source_government'] = source_login.lower() in organizations_government else: repository['source_government'] = True repository = upsert(model=Repository, unique_key='id', item=repository) repositories.append(repository) organization.repositories = repositories try: session.add(organization) session.commit() return r_data except: session.rollback()
def on_post(self, req, resp): user = req.context['user'] # Vytvoret novou trofej mohou jen orgove if (not user.is_logged_in()) or (not user.is_org()): req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Přidání trofeje může provést pouze organizátor.' } ] } resp.status = falcon.HTTP_400 return data = json.loads(req.stream.read())['achievement'] achievement = model.Achievement( title = data['title'], picture = data['picture'], description = data['description'], ) if not data['persistent']: achievement.year = req.context['year'] else: achievement.year = None try: session.add(achievement) session.commit() except SQLAlchemyError: session.rollback() raise req.context['result'] = { 'achievement': util.achievement.to_json(achievement) } session.close()
def newMenuItem(restaurant_id): restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one() creator = getUserInfo(restaurant.user_id) if ('username' not in login_session) or (creator.id != login_session['user_id']): return redirect(url_for('showLogin')) if request.method == 'POST': # File upload filename = "" file = request.files['image'] if file and allowed_file(file.filename): filename = secure_filename(file.filename) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) newItem = MenuItem( course=request.form['course'], description=request.form['description'], name=request.form['name'], price=request.form['price'], restaurant_id=restaurant_id, user_id=login_session['user_id'], image=filename ) session.add(newItem) session.commit() flash('New Menu Item created!') return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id)) else: restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one() return render_template( 'new-menu-item.html', restaurant=restaurant, courses=constants.COURSES)
def register(): if 'username' in session: flash("Cannot create new account while logged in.") return redirect(url_for('hello')) else: form = RegistrationForm() if form.validate_on_submit(): login = form.username.data user = dbsession.query(User).filter_by(name=login).first() if user is None: pw_hash = bcrypt.generate_password_hash(form.password.data) user = User(login, '', pw_hash) user.gender = form.gender.data user.species = form.species.data user.bio = form.bio.data user.email = form.email.data user.minorflag = not form.adult.data user.accepttos = True dbsession.add(user) dbsession.commit() flash("User Created") return redirect(url_for('login')) else: flash("User already exists.") return redirect(url_for('register')) return render_template('register.html', form=form)
def post(self): parsed_args = parser.parse_args() gene = Gene(symbol=parsed_args["symbol"]) session.add(gene) session.commit() return gene, 201
def put(self, id): parsed_args = parser.parse_args() todo = session.query(Todo).filter(Todo.id == id).first() todo.task = parsed_args['task'] session.add(todo) session.commit() return todo, 201
def create_topic(cls, title, description): topic = cls() topic.title = title topic.description = description session.add(topic) session.commit() return topic
def on_post(self, req, resp): user = req.context['user'] if (not user.is_logged_in()) or (not user.is_org()): req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Přidat článek může pouze organizátor.' } ] } resp.status = falcon.HTTP_400 return data = json.loads(req.stream.read())['article'] try: article = model.Article( author = user.id, title = data['title'], body = data['body'], published = data['published'], year = req.context['year'], time_created = dateutil.parser.parse(data['time_published']), picture = data['picture'] ) session.add(article) session.commit() article.resource = 'articles/' + str(article.id) session.commit() except SQLAlchemyError: session.rollback() raise req.context['result'] = { 'article': _artice_to_json(article) } session.close()
def append_comment(self, comment): new_comment = Comment() new_comment.topic_id = self.id new_comment.description = comment session.add(new_comment) session.commit() return new_comment
def on_post(self, req, resp): try: user = req.context['user'] # Vytvoret novy rocnik mohou jen ADMINI if (not user.is_logged_in()) or (not user.is_admin()): resp.status = falcon.HTTP_400 return data = json.loads(req.stream.read())['year'] year = model.Year( id = data['index'], year = data['year'], sealed = data['sealed'] if data['sealed'] else False, point_pad = data['point_pad'] ) session.add(year) session.commit() if 'active_orgs' in data: for user_id in data['active_orgs']: org = model.ActiveOrg(org=user_id, year=year.id) session.add(org) session.commit() req.context['result'] = { 'year': util.year.to_json(year) } except SQLAlchemyError: session.rollback() raise finally: session.close()
def on_post(self, req, resp): try: user = req.context['user'] if not user.is_logged_in(): resp.status = falcon.HTTP_400 return if req.context['year_obj'].sealed: resp.status = falcon.HTTP_403 req.context['result'] = { 'errors': [ { 'status': '403', 'title': 'Forbidden', 'detail': u'Ročník zapečetěn.' } ] } return data = json.loads(req.stream.read()) pblic = data['thread']['public'] if data['thread'].has_key('public') else True thread = model.Thread(title=data['thread']['title'], public=pblic, year = req.context['year']) session.add(thread) session.commit() req.context['result'] = { 'thread': util.thread.to_json(thread, user.id) } except SQLAlchemyError: session.rollback() raise finally: session.close()
def on_put(self, req, resp, id): try: user_id = req.context['user'].id if req.context['user'].is_logged_in() else None if not user_id: return if session.query(model.Thread).get(id) is None: status = falcon.HTTP_400 return visit = util.thread.get_visit(user_id, id) if visit: visit.last_last_visit = visit.last_visit visit.last_visit = text('CURRENT_TIMESTAMP') else: visit = model.ThreadVisit(thread=id, user=user_id, last_visit=text('CURRENT_TIMESTAMP')) session.add(visit) session.commit() req.context['result'] = "{}" except SQLAlchemyError: session.rollback() raise finally: session.close()
def on_post(self, req, resp): email = json.loads(req.stream.read())['email'] try: user = session.query(model.User).filter(model.User.email == email).first() except SQLAlchemyError: session.rollback() raise if not user: resp.status = falcon.HTTP_400 req.context['result'] = { 'result': 'error' } return new_password = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits + string.ascii_lowercase) for _ in range(8)) user.password = auth.get_hashed_password(new_password) try: session.add(user) session.commit() except SQLAlchemyError: session.rollback() raise try: util.mail.send(user.email, '[KSI] Nové heslo', u'Ahoj,<br/>na základě tvé žádosti ti bylo vygenerováno nové heslo: %s<br/><br/>KSI' % new_password) except SQLAlchemyError: exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception(exc_type, exc_value, exc_traceback, file=sys.stderr) session.close() req.context['result'] = { 'result': 'ok' }
def _appendQuestion(self, q): print('q: ', q) item = QListWidgetItem() item.setText(q.text) item.setStatusTip(str(q.id)) self.lstQuestions.addItem(item) session.add(q)
def storynew(): if 'username' in session: user = session['username'] form = StoryForm() if form.validate_on_submit(): uid = dbsession.query(User.id).filter_by(name=user).first() newstory = Story(form.title.data) newstory.text = markdown.markdown(form.body.data) newstory.uid = uid[0] newstory.adult = form.adult.data tagslist = form.tags.data tagslist = tagslist.split(',') for tagitem in tagslist: tagitem = tagitem.strip() tagitem = tagitem.lower() tag = dbsession.query(Tag).filter_by(tagname=tagitem).first() if tag is None: tag = Tag(tagitem) newstory.tags.append(tag) dbsession.add(newstory) dbsession.commit() return redirect("~"+user) return render_template("storynew.html", form=form) else: return render_template("storynew.html")
def on_done(self, event): """The done button was pressed.""" name = self.name.GetValue() description = self.description.GetValue() public = self.public.GetValue() logger.debug('Attempting to create playlist with name "%s", description "%s" and public %s.', name, repr(description), public) if not name: do_error('Playlist names cannot be blank.') self.name.SetFocus() else: try: id = application.api.create_playlist(name, description, public) logger.debug('New playlist ID is %s.', id) p = Playlist(id = id, name = name, description = description) logger.debug('Created Playlist object %s.', p) session.add(p) application.frame.add_playlist(p) entry_ids = application.api.add_songs_to_playlist(p.id, [t.id for t in self.tracks]) logger.debug('Entry IDs are: %s.', entry_ids) if len(entry_ids) == len(self.tracks): for pos, track in enumerate(self.tracks): p.tracks.append(track) e = PlaylistEntry(playlist = p, track = track, id = entry_ids[pos]) logger.debug('Created playlist entry %s (%s).', e, e.track) session.add(e) else: do_error('Only %s %s out of %s were added to the playlist.' % (len(entry_ids), 'track' if len(entry_ids) == 1 else 'tracks', len(self.tracks))) session.commit() logger.debug('Done. Closing %s.', self) self.Close(True) except NotLoggedIn: do_login(callback = self.on_done, args = [event])
def on_post(self, req, resp): try: user = req.context['user'] year = req.context['year'] # Vytvorit novou vlnu mohou jen admini. if (not user.is_logged_in()) or (not user.is_admin()): resp.status = falcon.HTTP_400 return data = json.loads(req.stream.read())['wave'] wave = model.Wave( year = year, index = data['index'], caption = data['caption'], garant = data['garant'], time_published = data['time_published'] ) session.add(wave) session.commit() req.context['result'] = { 'wave': util.wave.to_json(wave) } except SQLAlchemyError: session.rollback() raise finally: session.close()
def _process_achievements(self, corr): a_old = util.achievement.ids_list(util.achievement.per_task(corr['user'], corr['task_id'])) a_new = corr['achievements'] if a_old != a_new: # achievementy se nerovnaji -> proste smazeme vsechny dosavadni a pridame do db ty, ktere nam prisly for a_id in a_old: try: ach = session.query(model.UserAchievement).get((corr['user'], a_id)) if ach.task_id == corr['task_id']: session.delete(ach) session.commit() except: session.rollback() raise for a_id in a_new: try: ua = model.UserAchievement(user_id=corr['user'], achievement_id=a_id, task_id=corr['task_id']) session.add(ua) session.commit() except: session.rollback() raise finally: session.close()
def add_pad(self, url, name=None): pad_name = name or url.split('/')[-1] rss_name = self.make_rss_name(pad_name) html_url = self.get_parse_url(url) pad = Pad( name=pad_name, start_url=url, html_url=html_url, rss_name=rss_name ) session.add(pad) try: pad_watcher = PadWatcher(pad_name, rss_name, html_url) except (urllib2.URLError, urllib2.HTTPError, socket.error) as exception: pad.status = Pad.ERROR pad.error_msg = unicode(repr(exception)) else: pad_watcher.db_pad = pad pad.status = Pad.OK self.pads.append(pad_watcher) self.write_rss(pad_watcher) #pad.delete_token = uuid4() session.commit()
def post(self): sectionSchema = SectionSchema() studentsSchema = StudentSchema(many=True) subjectsSchema = SubjectSchema(many=True) subjectsFromDb = session.query(Subject).all() newStudentSubjects = [] json_data = request.get_json() if not json_data: return jsonify({'message' : 'No input data provided'}), 400 section = sectionSchema.load(json_data).data students = studentsSchema.load(json_data['students']).data # when section is serialized from json and then added to db, # it duplicates subjects (inserts them with new ids), which obviously # is undesired - this nested loop replaces serialized subjects with db subjects for student in students: studentsSubjects = student.subjects; for studentSubject in student.subjects: for dbSubject in subjectsFromDb: if dbSubject.name == studentSubject.name: newStudentSubjects.append(dbSubject) student.subjects = newStudentSubjects newStudentSubjects = [] section.students = students session.add(section) session.commit() return sectionSchema.dump(section), 201
def editMenuItem(restaurant_id, menuitem_id): restaurant = session.query(Restaurant).filter_by(id=restaurant_id).one() creator = getUserInfo(restaurant.user_id) if creator.id != login_session['user_id']: return redirect(url_for('showLogin')) menuitem = session.query(MenuItem).filter_by(id=menuitem_id).one() if request.method == 'POST': if request.form['name']: menuitem.name = request.form['name'] if request.form['description']: menuitem.description = request.form['description'] if request.form['price']: menuitem.price = request.form['price'] if request.form['course']: menuitem.course = request.form['course'] session.add(menuitem) session.commit() flash('Menu Item {0} Updated'.format(menuitem.name)) return redirect(url_for('restaurantMenu', restaurant_id=restaurant_id)) else: return render_template( 'edit-menu-item.html', restaurant_id=restaurant_id, menuitem_id=menuitem_id, item=menuitem, courses=constants.COURSES)
def post(self): error_message = None try: # Processing input arguments parser.add_argument('name', type=str, required=True, trim=True) parsed_args = parser.parse_args() # Creating team instance team = Team( created=datetime.datetime.utcnow(), name=parsed_args['name'], params=parsed_args['params'], meta=parsed_args['meta'] ) # Saving to DB session.add(team) session.commit() except IntegrityError: error_message = 'Faulty or a duplicate record' except ValueError as e: error_message = str(e) except Exception as e: print(str(e)) error_message = 'Bad request' finally: if error_message: session.rollback() abort(400, message='Unable to create team record: ' + error_message) else: return team, 201
def get_or_create(cls, user): instance = User.query.filter(User.user_id==str(user.id)).first() if instance is not None: return instance instance = cls.from_api(user) session.add(instance) session.commit() return instance
def put(self, uid): user = session.query(User).filter(User.uid == uid).one_or_none() parsed_args = parser.parse_args() user.username = parsed_args['username'] user.description = parsed_args['description'] session.add(user) session.commit() return user, 200
def add_chat_message(): msg = request.args.get("message") if not msg: return request.error_formatter(10, "Missing message") session.add(ChatMessage(user=request.user, message=msg)) session.commit() return request.formatter({})
def hello(): my_test = Testtable("wew") session.add(my_test) session.commit() res = session.query(Testtable).filter_by(name='wew').all() serialized = [json.dumps(r, cls=JSONSerializer) for r in res] return jsonify(result=serialized)
def add(): name = request.GET.get('name') password = request.GET.get('password') lng = request.GET.get('lng') lat = request.GET.get('lat') user = User(name=name, password=password, location='POINT(%s %s)' %(lat, lng)) session.add(user) session.commit() return 'user %s added!' % (name)
def on_post(self, req, resp): try: userinfo = req.context['user'] if not userinfo.is_logged_in(): resp.status = falcon.HTTP_400 return user = session.query(model.User).filter(model.User.id == userinfo.get_id()).first() files = multipart.MultiDict() content_type, options = multipart.parse_options_header(req.content_type) boundary = options.get('boundary','') if not boundary: raise multipart.MultipartError("No boundary for multipart/form-data.") for part in multipart.MultipartParser(req.stream, boundary, req.content_length): files[part.name] = part file = files.get('file') user_id = req.context['user'].get_id() tmpfile = tempfile.NamedTemporaryFile(delete = False) file.save_as(tmpfile.name) mime = magic.Magic(mime=True).from_file(tmpfile.name) if mime not in ALLOWED_MIME_TYPES: resp.status = falcon.HTTP_400 return if not os.path.isdir(UPLOAD_DIR): try: os.makedirs(UPLOAD_DIR) except OSError: print 'Unable to create directory for profile pictures' resp.status = falcon.HTTP_500 return new_picture = os.path.join(UPLOAD_DIR, 'user_%d.%s' % (user_id, ALLOWED_MIME_TYPES[mime])) self._crop(tmpfile.name, new_picture) try: os.remove(tmpfile.name) except OSError: print 'Unable to remove temporary file %s' % tmpfile.name user.profile_picture = new_picture session.add(user) session.commit() except SQLAlchemyError: session.rollback() raise finally: session.close()
def post(self): parsed_args = parser.parse_args() answer = Answer(input=parsed_args['input'], user_id=parsed_args['user_id'], question_id=parsed_args['question_id']) session.add(answer) session.commit() return answer, 201
def post(self): parsed_args = person_parser.parse_args() person = Person(lastname=parsed_args['lastname'], firstname=parsed_args['firstname'], dateofbirth=parsed_args['dateofbirth'], zipcode=parsed_args['zipcode']) session.add(person) session.commit() return person, 201
def put(self, person_id): parsed_args = person_parser.parse_args() person = session.query(Person).filter(Person.id == person_id).first() person.lastname = parsed_args['lastname'] person.firstname = parsed_args['firstname'] person.dateofbirth = parsed_args['dateofbirth'] session.add(person) session.commit() return person, 201
async def create_article(article:PostArticle): article_db = ArticleTable() article_db.name = article.name article_db.title = article.title article_db.content = article.content article_db.date = datetime.now() session.add(article_db) session.commit() return article_db
def restaurantCreate(): if request.method == 'POST': restaurant = Restaurant(name=request.form['name'], user_id=login_session['user_id']) session.add(restaurant) session.commit() flash('New restaurant: {0} created!'.format(restaurant.name)) return redirect(url_for('restaurantList')) else: return render_template('new-restaurant.html')
def contact(): if request.method == 'POST': g_recaptcha_response = request.form.get('g-recaptcha-response') secret = config.reCaptcha.secret url = config.reCaptcha.uri if request.headers.getlist("X-Forwarded-For"): ip = request.headers.getlist("X-Forwarded-For")[0] else: ip = request.remote_addr site_key = config.reCaptcha.site_key data = { 'secret': secret, 'response': g_recaptcha_response, 'remoteip': ip } r = requests.post(url, data=data) if r.status_code != 200: errors.append('reCAPTCHA service failure') return render_template('error.html', errors=errors), 400 result = r.json() success = result.get('success') if success is not True: errors.append('reCAPTCHA failure') for error in result.get('error-codes'): errors.append(error) return render_template('error.html', errors=errors), 429 contact = Contact() contact.name = request.form.get('name') contact.email = request.form.get('email') contact.message = request.form.get('message') contact.ip = ip session.add(contact) session.commit() session.close() date = datetime.datetime.now( timezone('US/Mountain')).strftime('%Y-%m-%d %I:%M:%S %p') msg = MIMEText("Date/Time: {}\nName: {}\nEmail: {}\n\n{}".format( date, contact.name, contact.email, contact.message)) msg['Subject'] = "Website Comment {}".format(date) msg['Reply-To'] = '"{}" <{}>'.format(contact.name, contact.email) msg['From'] = "*****@*****.**" msg['To'] = "[email protected], [email protected]" server = smtplib.SMTP(config.mail.host, config.mail.port) server.ehlo() server.starttls() server.login(config.mail.user, config.mail.password) server.sendmail("*****@*****.**", ["*****@*****.**", "*****@*****.**"], msg.as_string()) server.quit() return render_template('contact_thanks.html') else: site_key = config.reCaptcha.site_key return render_template('contact.html', site_key=site_key)
def add_result(self, result): """Add a result to the view.""" session.add(result) session.commit() result_str = format_track(result) tracks.storage.tracks.append({'key': result.key, 'name': result_str}) self.view.Append(result_str) self.results.append(result) if self.view.GetSelection() == -1: self.view.SetSelection(0)
def add_movie(data): original_title_normalized = data['original_title'] original_title_normalized = original_title_normalized.replace(' ', '_').lower() original_title_normalized = re.sub('[^A-Za-z0-9_]+', '', original_title_normalized) movie = Movie(data['original_title'], data['original_language'], data['budget'], data['is_adult'], data['release_date'], original_title_normalized) session.add(movie)
def greet(message): user_id = message.from_user.id user = session.query(User).get(user_id) if user is None: user = User(id=user_id) session.add(user) session.commit() bot.reply_to( message, "Hello, %s! \n Send '/jobs' to get offers" % message.chat.username)
def callback(self, ch, method, properties, body: bytes) -> None: order_id = body.decode('utf8') delivery = Delivery(order_id=order_id) session.add(delivery) session.commit() self.produce(exchange='', routing_key='delivery_success', body=order_id) print(f'[*] Produce to `delivery_success` -> `{order_id}`')
async def save_document(msg: Message, state: FSMContext): data = await state.get_data() task_id = data['task_id'] documents = data.get('document_id', []) for document_id in documents: document = DocumentToTask(task_id=task_id, document_id=document_id) session.add(document) session.commit() await msg.answer('Документы добавлены') await show_tools_for_add_file(msg.from_user.id, state)
def pupil_register(): data = request.json p_obj = pupil(first_name=data['first_name'], sur_name=data['sur_name'], email_add=data['email_add']) session.add(p_obj) session.commit() session.close() return json.dumps( {"data": "{} - Added Succesfully ".format(data['first_name'])})
def test_created_admin(): user = User(email='*****@*****.**', password='******', role='admin') session.add(user) session.commit() actual = session.query(User).one() expected = user assert actual == expected
def on_ok(self, event): self.track.lyrics = self.lyrics.GetValue() session.add(self.track) try: session.commit() self.Close(True) if self.track is application.track: application.frame.update_lyrics(self.track) except Exception as e: do_error(e)
def patch(self, name): parsed_args = parser.parse_args() employee = session.query(Employee).filter( Employee.name == name).first() # employee.name = parsed_args['name'] employee.city = parsed_args['city'] employee.age = parsed_args['age'] session.add(employee) session.commit() return employee, 200
def post(self): parsed_args = parser.parse_args() card = Card(title=parsed_args['title'], content=parsed_args['content']) if 'links' in parsed_args and parsed_args['links'] is not None: for l in parsed_args['links']: link = Link(url=l['url']) card.links.append(link) session.add(card) session.commit() return card, 201
def createTask(self): current_user = super().confirmUser() if current_user == None: print("\nInvalid credentials") else: task = CreateTask(self.title, self.description, self.date_created, self.due_date, current_user) session.add(task) session.commit() print("You have successfully add task")
def add_question(): result = "" if request.method == 'POST': question = Question(text=request.form["text"], answer=request.form["answer"], type='SINGLE') session.add(question) session.commit() result = "Question added successfully!" return render_template('add.html', result=result)
def create_or_update(data): filtered_data = EmailRepo.filter_dict(data) q = session.query(Email).filter_by(value=filtered_data['value']) email = q.first() if not email: email = Email(**filtered_data) session.add(email) session.commit() else: q.update(filtered_data)
def post(self): parsed_args = parser.parse_args() note = Note(title=parsed_args['title'], description=parsed_args['description'], create_at=parsed_args['create_at'], create_by=parsed_args['create_by'], priority=parsed_args['priority']) session.add(note) session.commit() return note, 201
def get_settings(chat_id: int) -> Settings: settings = (session.query(Settings).filter( Settings.chat_id == chat_id, ).first()) if not settings: settings = Settings(chat_id=chat_id) session.add(settings) session.commit() return settings
def create_users(name: str, age: int): user = UserTable() user.name = name user.age = age session.add(user) session.commit() return f"{name} create.."
def signup(self): try: new_user = User(username=self.username, password=self.password) session.add(new_user) session.commit() user_id = User_query().return_user_id_by_username(self.username) return user_id except exc.IntegrityError: session.rollback() return None
def doctors_upload(doctors): logger.debug("Выгрузка данных о врачах в PostgreSQL") Doctor.__table__.drop(db) Doctor.__table__.create(db) for doctor in doctors: new_doctor = Doctor(name=doctor["fields"]["Имя"], methods=doctor["fields"]["Методы"], photo=doctor["fields"]["Фотография"][0]["url"]) session.add(new_doctor) session.commit()
def test_create_client(): user = User(email='*****@*****.**', password='******', role='client') session.add(user) session.commit() actual = session.query(User).count() expected = 1 assert actual == expected
def put(self, id): parsed_args = parser.parse_args() link = session.query(Link).filter(Link.id == id).first() link.url = parsed_args['url'] card = session.query(Card).filter( Card.id == parsed_args['card_id']).first() card.links.append(link) session.add(link) session.commit() return link, 201
def post(self) -> dict: create_params = self.create_params() ingredient = Ingredient(**create_params) session.add(ingredient) session.commit() ingredient = IngredientClientSchema().dump(ingredient) response = BasicResponse(ingredient) return BasicResponseSchema().dump(response)
def add_label(): lb = request.query["label"] id = request.query["id"] s = session() p = s.query(News).get(id1) p.lb = lb session.add(s) session.commit() redirect("/news")
def create_topic(cls, user_id, subject, description): new_topic = Topic(created_by=user_id, updated_by=user_id, topic_subject=subject, topic_description=description) session.add(new_topic) session.commit() return new_topic
async def save_photo(msg: Message, state: FSMContext): data = await state.get_data() task_id = data['task_id'] photos = data.get('photo_id', []) for photo_id in photos: photo = PhotoToTask(task_id=task_id, photo_id=photo_id) session.add(photo) session.commit() await msg.answer('Фотографии добавлены') await show_tools_for_add_file(msg.from_user.id, state)