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)
