def test_08_interests(self):
session = Session()
doey = session.query(Volunteer).filter_by(name='Joey Wood').first()
moey = VolunteerInterests("youth", doey.id)
joey = session.query(VolunteerInterests).filter_by(volunteer_id=doey.id).first()
#self.assertTrue(moey.interest == joey.interest)
session.close()
def form_entity(type, id=None):
session = Session()
entity = None
tag_ids = None
if id != None:
entity = session.query(Entity).filter(Entity.id == id).first()
tag_ids = [ tag.id for tag in entity.tags ]
files = None
series = None
soundtracks = None
if(type == 'song'):
files = session.query(File).filter(File.type == 'song').all()
series = session.query(Series).filter(or_(Series.type == 'album', Series.type == 'soundtrack')).all()
if(type == 'book'):
files = session.query(File).filter(File.type == 'book').all()
series = session.query(Series).filter(Series.type == 'book_series').all()
if(type == 'movie'):
series = session.query(Series).filter(Series.type == 'movie_series').all()
soundtracks = session.query(Series).filter(Series.type == 'soundtrack').all()
covers = session.query(File).filter(File.type == 'image').all()
keywords = session.query(Tag).filter(Tag.type == 'keyword').all()
genres = session.query(Tag).filter(Tag.type == 'genres').all()
rendered = render_template("form_entity.html", type=type, entity=entity, covers=covers, files=files,
series=series, soundtracks=soundtracks, keywords=keywords, genres=genres, tag_ids=tag_ids)
session.commit()
return rendered
def play_next(self, skip=False):
if self.empty():
random_song = random_songs(1)['results']
if len(random_song) == 1:
self.vote_song('RANDOM', random_song[0]['id'])
if not self.empty():
if player.now_playing:
if isinstance(player.now_playing, YouTubeVideo):
self.remove_video(player.now_playing.url, skip=skip)
else:
self.remove_song(player.now_playing.id, skip=skip)
session = Session()
next_packet = session.query(Packet).order_by(Packet.finish_time).first()
if next_packet:
if next_packet.video_url:
video = YouTubeVideo(next_packet)
player.play_media(video)
session.commit()
return video.dictify()
else:
next_song = session.query(Song).get(next_packet.song_id)
player.play_media(next_song)
next_song.history.append(PlayHistory(user=next_packet.user))
session.commit()
return next_song.dictify()
class TableMappingsTestCase(unittest.TestCase):
def setUp(self):
engine = bind_session_engine("sqlite:///:memory:", echo=False)
tables.metadata.create_all(engine)
self.session = Session()
self.room = Room("living-room")
self.item = Item("TV", self.room, "80", "plasma screen", True)
self.session.add_all([self.room, self.item])
self.session.commit()
def test_room_relations(self):
r = self.session.query(Room).one()
self.assertTrue(isinstance(r, Room))
self.assertTrue(r.name, "living-room")
def test_item_relations(self):
i = self.session.query(Item).one()
self.assertTrue(isinstance(i, Item))
self.assertTrue(i.name, "TV")
self.assertTrue(i.room, self.room)
self.assertTrue(i.weight, "80")
self.assertTrue(i.description, "plasma screen")
self.assertTrue(i.is_fragile, True)
def _update_finish_times(self, user=None):
"""
Updates finish times for packets
If a user is specified, only update given user's queue.
"""
session = Session()
if user:
packets = session.query(Packet).filter_by(user=user).order_by(Packet.arrival_time).all()
else:
packets = session.query(Packet).order_by(Packet.arrival_time).all()
last_finish_time = {}
for packet in packets:
length = packet.video_length or session.query(Song).get(packet.song_id).length
user = packet.user
if user in last_finish_time:
last_finish = max(last_finish_time[user], packet.arrival_time)
packet.finish_time = last_finish + length / packet.weight()
last_finish_time[user] = packet.finish_time
else:
packet.finish_time = packet.arrival_time + length / packet.weight()
last_finish_time[user] = packet.finish_time
session.commit()
def test_12_interests(self):
session = Session()
race = session.query(Event).filter_by(name='Race for the Cure').first()
dace = EventInterests("Youth", race.id)
lace = session.query(EventInterests).filter_by(event_id=race.id).first()
self.assertTrue(dace.interest == lace.interest)
session.close()
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 test_14_neighborhoods(self):
session = Session()
race = session.query(Event).filter_by(name='Race for the Cure').first()
dace = EventNeighborhoods("Back Bay", race.id)
lace = session.query(EventNeighborhoods).filter_by(event_id=race.id).first()
self.assertTrue(dace.neighborhood == lace.neighborhood)
session.close()
def test_16_skills(self):
session = Session()
race = session.query(Event).filter_by(name='Race for the Cure').first()
dace = EventSkills("Teaching/Tutoring", race.id)
lace = session.query(EventSkills).filter_by(event_id=race.id).first()
self.assertTrue(dace.skill == lace.skill)
session.close()
def get_task_list(self, start_task_id=0, limit=30, q="", t="", a="", order=db.Task.createtime, dis=db.desc, all=False):
session = Session()
self._last_get_task_list = self.time()
# base query
query = session.query(db.Task)
# query or tags
if q:
query = query.filter(db.or_(db.Task.taskname.like("%%%s%%" % q),
db.Task.tags.like("%%%s%%" % q)))
elif t:
query = query.filter(db.Task.tags.like("%%|%s|%%" % t));
# author query
if a:
query = query.filter(db.Task.creator == a)
# next page offset
if start_task_id:
value = session.query(order).filter(db.Task.id == start_task_id).first()
if not value:
return []
if dis == db.desc:
query = query.filter(order < value[0])
else:
query = query.filter(order > value[0])
query = query.filter(db.Task.id < start_task_id)
# order or limit
if not all:
query = query.filter(db.Task.invalid == False)
query = query.order_by(dis(order), dis(db.Task.id)).limit(limit)
return query.all()
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 event(event_id):
content = {'events': 'test'}
success = {'status': 'event created'}
updateSuccess = {'status':'account updated'}
noEvent = {'error': 'User not found.'}
updateError = {'error': 'User not found/input validation failed.'}
error = {'error': "Error in JSON/SQL syntax"}
if request.method == 'POST':
data = request.json
if event.createEvent(data):
return success, status.HTTP_200_OK
else:
return error, status.HTTP_500_INTERNAL_SERVER_ERROR
if request.method == 'GET':
s = Session()
e = s.query(Event).filter_by(id=event_id).first()
if e:
return Event.asdict(e), status.HTTP_200_OK
else:
return noEvent, status.HTTP_404_NOT_FOUND
if request.method == 'POST':
data = request.json
if data:
s = Session()
u = s.query(Event).filter_by(id=event_id).update(data)
if u:
s.commit()
s.close()
return updateSuccess, status.HTTP_200_OK
else:
return updateError, status.HTTP_400_BAD_REQUEST
def test_10_neighborhoods(self):
session = Session()
doey = session.query(Volunteer).filter_by(name='Joey Wood').first()
moey = VolunteerNeighborhoods("backbay", doey.id)
joey = session.query(VolunteerNeighborhoods).filter_by(volunteer_id=doey.id).first()
#self.assertTrue(moey.neighborhood == joey.neighborhood)
session.close()
def test_12_skills(self):
session = Session()
doey = session.query(Volunteer).filter_by(name='Joey Wood').first()
moey = VolunteerSkills("teaching", doey.id)
joey = session.query(VolunteerSkills).filter_by(volunteer_id=doey.id).first()
#self.assertTrue(moey.skill == joey.skill)
session.close()
def create_token(user):
payload = {
# subject
'sub': user.id,
#issued at
'iat': datetime.utcnow(),
#expiry
'exp': datetime.utcnow() + timedelta(days=1)
}
s = Session()
token = jwt.encode(payload, app.secret_key, algorithm='HS256')
try:
if (user.permissions == 'volunteer'):
us = s.query(Volunteer).filter_by(id=user.id).first()
d = volunteer.Volunteer.asdict(us)
d['skills'] = VolunteerSkills.get_skills(us.id)
d['neighborhoods'] = VolunteerNeighborhoods.get_neighborhoods(us.id)
d['interests'] = VolunteerInterests.get_interests(us.id)
if (user.permissions == 'admin'):
us = s.query(Admin).filter_by(id=user.id).first()
d = admin.Admin.asdict(us)
if (user.permissions == 'organization'):
us = s.query(Organization).filter_by(id=user.id).first()
d =organization.Organization.asdict(us)
except:
return None
finally:
s.close()
m = {'token': str(token), 'user': d}
return m
def test_14_availability(self):
session = Session()
doey = session.query(Volunteer).filter_by(name='Joey Wood').first()
moey = VolunteerAvailability("Monday", doey.id)
joey = session.query(VolunteerAvailability).filter_by(volunteer_id=doey.id).first()
#self.assertTrue(moey.day == joey.day)
session.close()
def delete_file(id):
session = Session()
session.query(File).filter(File.id==id).delete()
session.commit()
return redirect(url_for('manage_files'))
def test_05_updating_email(self):
session = Session()
test = session.query(User).filter_by(name='Test Org').first()
q = session.query(User).filter_by(id=test.id)
q = q.update({"email":"*****@*****.**"})
test = session.query(User).filter_by(id=test.id).first()
self.assertTrue(test.email == '*****@*****.**')
session.close()
def test_04_updating_name(self):
session = Session()
test = session.query(User).filter_by(name='Test Org').first()
q = session.query(User).filter_by(id=test.id)
q = q.update({"name":"Wood Joey"})
test = session.query(User).filter_by(id=test.id).first()
self.assertTrue(test.name == 'Wood Joey')
session.close()
def test_07_updating_email(self):
session = Session()
mickey = session.query(User).filter_by(name='Mickey Mouse').first()
q = session.query(User).filter_by(id=mickey.id)
q = q.update({"email":"*****@*****.**"})
mickey = session.query(User).filter_by(id=mickey.id).first()
self.assertTrue(mickey.email == '*****@*****.**')
session.close()
def test_06_updating_name(self):
session = Session()
mickey = session.query(User).filter_by(name='Mickey Mouse').first()
q = session.query(User).filter_by(id=mickey.id)
q = q.update({"name":"Wood Joey"})
mickey = session.query(User).filter_by(id=mickey.id).first()
self.assertTrue(mickey.name == 'Wood Joey')
session.close()
def delete_series_job(id):
session = Session()
session.query(SeriesJob).filter(SeriesJob.id==id).delete()
session.commit()
return redirect(url_for('index'))
def list_movies():
year = request.args.get('year')
session = Session()
if not year:
movies = session.query(Movie).all()
else:
movies = session.query(Movie).filter(Movie.year == year).all()
return render_template('list-movies.html', movies=movies)
def test_06_updating_zip(self):
session = Session()
race = session.query(Event).filter_by(name='Race for the Cure').first()
q = session.query(Event).filter_by(id=race.id)
q = q.update({"zip":"02120"})
race = session.query(Event).filter_by(id=race.id).first()
self.assertTrue(race.zip == '02120')
session.close()
def test_17_updating_name(self):
session = Session()
joey = session.query(User).filter_by(name='Joey Wood').first()
q = session.query(User).filter_by(id=joey.id)
q = q.update({"name":"Wood Joey"})
joey = session.query(User).filter_by(id=joey.id).first()
self.assertTrue(joey.name == 'Wood Joey')
session.close()
def test_18_updating_email(self):
session = Session()
joey = session.query(User).filter_by(name='Joey Wood').first()
q = session.query(User).filter_by(id=joey.id)
q = q.update({"email":"*****@*****.**"})
joey = session.query(User).filter_by(id=joey.id).first()
self.assertTrue(joey.email == '*****@*****.**')
session.close()
def delete_person(id):
session = Session()
session.query(Person).filter(Person.id==id).delete()
session.commit()
return redirect(url_for('manage_persons'))
def delete_note(id):
session = Session()
session.query(Note).filter(Note.id==id).delete()
session.commit()
return redirect(url_for('index'))
def test_05_updating_name(self):
session = Session()
race = session.query(Event).filter_by(name='Race for the Cure').first()
q = session.query(Event).filter_by(id=race.id)
q = q.update({"name":"Wood Joey"})
race = session.query(Event).filter_by(id=race.id).first()
self.assertTrue(race.name == 'Wood Joey')
session.close()
def delete_rating(id):
session = Session()
session.query(Rating).filter(Rating.id==id).delete()
session.commit()
return redirect(url_for('index'))
def hasInitDutyData(month, year=2019):
session = Session()
try:
#print(d.duty_date.year==2019)
query = session.query(OriginDuty)
for q in query:
if q.duty_date.year == year and q.duty_date.month == month:
return True
else:
return False
except Exception as e:
print(e)
finally:
session.close()
def from_db(cls, uid): # for already existing user
session = Session()
user = session.query(User).filter_by(uid=uid).first()
username = user.username
password = user.password
first_name = user.first_name
last_name = user.last_name
phone_number = user.phone_number
email = user.email
address = user.address
verified = user.verified
session.close()
return cls(uid, first_name, last_name, username, password,
phone_number, email, address, verified)
def filter_id(df, col, dcol):
"""Elimine de la DataFrame les éléments de col déjà présents en base"""
session = Session()
ids = session.query(dcol) \
.filter(dcol.in_(df[col])) \
.all()
session.close()
ids = [idx[0] for idx in ids]
c = ~df[col].isin(ids)
return df.loc[c]
def saveContents(contents):
session = Session()
contentIds = {content['id'] for content in contents}
contentsInDB = session.query(Content.id).filter(
Content.id.in_(contentIds)).all()
contentIdsInDB = {content.id for content in contentsInDB}
needToSaveContentIds = contentIds - contentIdsInDB
needToSabeContents = list(
filter(lambda a: a['id'] in needToSaveContentIds, contents))
session.add_all([Content(**content) for content in needToSabeContents])
session.commit()
session.close()
def __init__(self):
dispatcher.connect(self.spider_opened, signal=signals.spider_opened)
dispatcher.connect(self.spider_closed, signal=signals.spider_closed)
self.use_proxies = set()
db_session = Session()
self.proxy_lists = {}
self.proxy_list_names = {}
pl = db_session.query(ProxyList).all()
for p in pl:
self.proxy_lists[p.id] = p.proxies.split('\n')
self.proxy_list_names[p.id] = p.name
db_session.close()
def cmd_search(bot: telegram.Bot, update: telegram.Update, session: db.Session):
try:
query = update.message.text.split(" ", 1)[1]
except IndexError:
reply(bot, update, strings.DIARIOSEARCH.ERRORS.INVALID_SYNTAX, command="search")
return
query = query.replace('%', '\\%').replace('_', '\\_')
entries = session.query(db.Diario)\
.filter(db.Diario.text.op("~*")(r"(?:[\s\.,:;!?\"'<{([]+|^)"
+ query +
r"(?:[\s\.,:;!?\"'>\})\]]+|$)"))\
.order_by(db.Diario.id.desc())\
.all()
bot.send_message(update.message.chat.id, generate_search_message(f"<b>{query}</b>", entries), parse_mode="HTML")
def activate_server(self, server_id, months):
sleep(random.randint(3, 20))
server = Session.query(Server).filter(Server.id == server_id).first()
if server.state == Server.DELETED:
return
months = Server.DEFAULT_MONTHS_PAID if months is None else int(months)
server.state = Server.ACTIVE
dt_now = datetime.now()
# relativedelta измеряется в минутах, чтобы можно было проверить переход из Active в Unpaid по планировщику
server.expired_date = dt_now + relativedelta(minutes=+months)
server.change_date = dt_now
Session.add(server)
Session.commit()
log.info("Server id={} activated".format(server_id))
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']:
try:
self.xunlei.session.get(task['lixian_url'], cookies={"gdriveid": self.gdriveid}, prefetch=False)
self.task_id_sample.add(task['task_id'])
except:
pass
if not self.last_task_id and task['lixian_url']:
try:
self.xunlei.session.get(task['lixian_url'], cookies={"gdriveid": self.gdriveid}, prefetch=False)
self.last_task_id = task['task_id']
except:
pass
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 = self.get_task(int(task['task_id']))
if not db_task:
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']
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']
db_task.status = task['status']
if db_task.status == "failed":
db_task.invalid = True
db_task.process = task['process']
session.add(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 login():
session = Session()
data = request.json
if data["type"] == "creds":
u = session.query(Caretaker).filter_by(name = data["name"]).first()
if u == None:
return jsonify({"message" : "name not found"}), 400
if u.password != data["password"]:
return jsonify({"message" : "wrong password"}), 400
key = random_key(128)
Cache[key] = {
"family_id": u.family_id,
"type": 1,
"id": u.id
}
print ("c:", key)
return jsonify({"token":key}), 200
else:
f = session.query(Family).filter_by(id = data["family_id"]).first()
if f == None:
return jsonify({"message":"not found"}), 400
u = session.query(Patient).filter_by(id = data["patient_id"]).first()
if u == None:
return jsonify({"message":"not found"}), 400
key = random_key(128)
Cache[key] = {
"family_id": data["family_id"],
"type": 0,
"id": u.id
}
print ("p:", key)
return jsonify({"token":key}), 200
def alias_name(message, user_name, alias_name=None):
"""指定したユーザにエイリアス名を紐付ける
:param message: slackbotの各種パラメータを保持したclass
:param str user_name: エイリアス名を紐付けるSlackユーザー
:param str alias_name: Slackユーザーに紐付けるエイリアス名
alias_nameがNoneの場合、user_nameをalias_nameとして扱う
上記の場合user_nameは投稿者となる
"""
if alias_name:
# ユーザー名とエイリアス名が指定されているパターン
slack_id = get_slack_id_by_name(user_name)
else:
# 投稿者のエイリアス名を更新するパターン
alias_name = user_name
slack_id = message.body['user']
user_name = get_user_name(slack_id)
user = get_slack_id_by_name(alias_name)
if user:
botsend(message, '`{}` はユーザーが存在しているので使用できません'.format(alias_name))
return
if not slack_id:
botsend(message, '{}に紐づくSlackのuser_idは存在しません'.format(user_name))
return
s = Session()
alias_user_name = (s.query(UserAliasName).filter(
UserAliasName.alias_name == alias_name))
if s.query(alias_user_name.exists()).scalar():
botsend(message, 'エイリアス名 `{}` は既に登録されています'.format(alias_name))
return
s.add(UserAliasName(slack_id=slack_id, alias_name=alias_name))
s.commit()
botsend(message, '{}のエイリアス名に `{}` を追加しました'.format(user_name, alias_name))
def import_issues(cls, website_id, filename):
db_session = Session()
spider_id = db_session.query(Spider)\
.filter(Spider.website_id == int(website_id))\
.first().id
error_crawl = db_session.query(Crawl)\
.filter(Crawl.spider_id == int(spider_id),
Crawl.status == 'errors_found')\
.order_by(Crawl.crawl_date.desc(),
Crawl.id.desc())\
.limit(1).first()
if error_crawl:
new_filename = '%s_%s_delisted_duplicate_errors.csv' % (
website_id, error_crawl.id)
new_filename_full = os.path.join(DATA_DIR, new_filename)
new_filename_full_tmp = new_filename_full + '~'
shutil.copy(filename, new_filename_full_tmp)
os.rename(new_filename_full_tmp, new_filename_full)
dd_error = db_session.query(DelistedDuplicateError)\
.filter(DelistedDuplicateError.website_id == website_id,
DelistedDuplicateError.crawl_id == error_crawl.id)\
.first()
if not dd_error:
dd_error = DelistedDuplicateError()
dd_error.website_id = website_id
dd_error.crawl_id = error_crawl.id
dd_error.filename = new_filename
dd_error.fixed = False
db_session.add(dd_error)
db_session.commit()
db_session.close()
def cmd_newevent(bot: telegram.Bot, update: telegram.Update, session: db.Session):
try:
_, timestring, name_desc = update.message.text.split(" ", 2)
except ValueError:
bot.send_message(update.message.chat.id, "⚠️ Sintassi del comando non valida.\n"
"Sintassi corretta:\n"
"```/newevent <timestamp|[[[anno-]mese-]giorno-]ore-minuti"
"|{numero}{w|d|h|m}> <nome>\n"
"[descrizione]```", parse_mode="Markdown")
return
try:
name, description = name_desc.split("\n", 1)
except ValueError:
name = name_desc
description = None
# Parse the timestring
try:
parsed_time = parse_timestring(timestring)
if parsed_time < datetime.datetime.now():
raise errors.PastDateError()
except ValueError:
bot.send_message(update.message.chat.id, "⚠ Non è stato possibile leggere la data.\n"
"Sintassi corretta:\n"
"```/newevent <timestamp|[[[anno-]mese-]giorno-]ore-minuti"
"|{numero}{w|d|h|m}> <nome>\n"
"[descrizione]```", parse_mode="Markdown")
return
except errors.PastDateError:
bot.send_message(update.message.chat.id, "⚠ La data inserita è una data passata.\n"
"per favore inserisci una data futura.\n", parse_mode="Markdown")
return
# Create the event
telegram_user = session.query(db.Telegram)\
.filter_by(telegram_id=update.message.from_user.id)\
.join(db.Royal)\
.one_or_none()
event = db.Event(author=telegram_user.royal,
name=name,
description=description,
time=datetime.datetime.fromtimestamp(0))
# Set the time
if isinstance(parsed_time, datetime.datetime):
event.time = parsed_time
else:
event.time_left = parsed_time
# Save the event
session.add(event)
session.commit()
bot.send_message(update.message.chat.id, "✅ Evento aggiunto al Calendario Royal Games!")
def emailOfPerson_notes_add(_id):
"""
Додавання нової нотатки на фіз особу. В групу Note
:param _id: id фіз особи на яку додають нотатку
"""
session = Session()
data = request.json
id_author = session.query(
Person.id).filter(Person.email == current_user.get_id()).first()
data.setdefault('fk_author', id_author[0])
note = Note(**data)
session.add(note)
session.commit()
session.close()
return 'ok'
def query_location(name=None, latitude=None, longitude=None):
location = None
session = Session(expire_on_commit=False)
if name is not None and len(name) > 0:
name = unquote(name)
location = session.query(Location).filter(
Location.name.like(name)).first()
if (latitude is not None and len(latitude) > 0
and longitude is not None and len(longitude) > 0):
if location is None:
# print('create')
location = Location(name=name.upper(),
latitude=latitude,
longitude=longitude)
session.add(location)
else:
# print('update')
location.latitude = latitude
location.longitude = longitude
location.lastseen = datetime.now()
session.commit()
else: # not on our database
if location is None:
# print('import')
rloc = locator.geocode(name)
location = Location(name=name.upper(),
latitude=rloc.latitude,
longitude=rloc.longitude)
session.add(location)
session.commit()
else:
location = session.query(Location).order_by(Location.name.asc()).all()
session.close()
return to_csv(location)
def worker_documents(_id):
"""
Повертає список документів фіз особи. В групу Document
:param id_: фіз особи
"""
session = Session()
all_records = session.query(Document).filter_by(fk_person=_id).all()
converter = DocumentSchema(many=True,
only=[
'id', 'name', 'file_type', 'created',
'status', 'type_', 'fk_person'
])
response = converter.dump(all_records).data
session.close()
return jsonify(response)
def update_user_db_1c():
"""
оновлення даних з 1с
"""
_1c = json.loads(load_users())
session = Session()
for arg in _1c['data']:
worker = session.query(Worker).filter(Worker.sid == arg['SID']).first()
if worker and arg['SID'] != '':
if arg['dismissed']:
status = 'dismissed'
else:
status = 'active'
update_from_1c(arg, status, worker.fk_person)
session.close()
def credential_check(username,
password): # returns -1 if username doesnt exist
# returns uid of person
session = Session()
user = session.query(User).filter_by(username=username).first()
if user == None:
session.close()
return -1
if password == user.password:
uid = user.uid
session.close()
return uid
else:
session.close()
return False
def api_admin_branch_list():
"""
Повертає список філіалів.
"""
session = Session()
result = session.query(Branch).join(City, City.id == Branch.fk_city).all()
converter = BranchSchema(many=True,
only=[
'id', 'name', 'name_en', 'zip_code',
'address_ua', 'address_ru', 'address_en',
'fk_city', 'city.name', 'status'
])
dumps_data = converter.dump(result).data
session.close()
return jsonify(dumps_data)
def api_admin_city_list():
"""
Список міст.
"""
session = Session()
result = session.query(City).join(Region,
Region.id == City.fk_region).all()
converter = CitySchema(many=True,
only=[
'name', 'name_en', 'id', 'fk_region',
'region.name', 'region.name_en'
])
dumps_data = converter.dump(result).data
session.close()
return jsonify(dumps_data)
class Repository:
def __init__(self):
logger.info("init Repository")
self.session = Session()
logger.info(self.session)
def add_user1(self):
logger.info("add_user1")
user = User(name="ika", email="*****@*****.**")
self.session.add(user)
def add_user2(self):
logger.info("add_user2")
user = User(name="tako", email="*****@*****.**")
self.session.add(user)
def read_users(self, name=None):
logger.info("read_users")
if name:
res = self.session.query(User).filter(User.name == name).first()
else:
res = self.session.query(User).all()
return res
def note_edit(note_id=None):
s = get_session()
if not s.get('authenticated'):
return bottle.redirect('/login')
note = None
if note_id is not None:
db_session = Session()
note = db_session.query(Note).get(note_id)
return template('note/edit.html',
note=note,
types={
Note.SOURCE_TYPE_MARKDOWN: 'Markdown',
Note.SOURCE_TYPE_HTML: 'HTML',
Note.SOURCE_TYPE_PLAINTEXT: 'Plain text',
})
def poll_status(status):
"""
Повертає список опитувань в залежгості до status(в розробці, активні, завершені). в групу Poll
:param status: status(в розробці, активні, завершені)
"""
session = Session()
all_records = session.query(Poll).filter_by(status=status).all()
converter = PollSchema(many=True,
only=[
'id', 'name', 'created', 'count_of_complete',
'total_count', 'status', 'description'
])
response = converter.dump(all_records).data
session.close()
return jsonify(response)
def reset_permission(user_id, permission):
try:
session_obj = Session()
tmp = session_obj.query(user_info).filter_by(id=user_id).first()
if tmp == None:
Session.remove()
return -1
tmp.permission = permission
session_obj.commit()
Session.remove()
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
return 0
def packages(user_id):
try:
session_obj = Session()
ret = session_obj.query(package_info).options(
subqueryload(package_info.user)).filter(
or_(package_info.user_id == user_id,
package_info.user_id == 1)).order_by(
desc(package_info.user_id),
desc(package_info.time)).all()
Session.remove()
return ret
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
def view_patients():
data = request.json
if not is_auth(request.headers):
return 'not authenticated', 401
family_id = None
try:
family_id = Cache[request.headers['Token']]['family_id']
except:
return 'invalid parameters', 400
s = Session()
r = s.query(Patient).filter_by(family_id=family_id).all()
return repr(r)
def update_pwd(user_id, pwd, new_pwd) -> int:
try:
session_obj = Session()
tmp = session_obj.query(user_info).filter_by(id=user_id).first()
if tmp == None:
return -1
if tmp.pwd != pwd:
return -2
tmp.pwd = new_pwd
session_obj.commit()
Session.remove()
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -3
return 0
def reset_pwd(user_id) -> int:
try:
session_obj = Session()
tmp = session_obj.query(user_info).filter_by(id=user_id).first()
if tmp == None:
Session.remove()
return -1
tmp.pwd = "e10adc3949ba59abbe56e057f20f883e"
session_obj.commit()
Session.remove()
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
return 0
def top_songs(limit=20):
songs = Song.__table__
play_history = PlayHistory.__table__
conn = engine.connect()
cols = [songs.c.id, func.count(play_history.c.id).label('play_count')]
s = (select(cols)
.select_from(songs.join(play_history))
.group_by(songs.c.id)
.order_by('play_count DESC')
.limit(limit))
res = conn.execute(s)
conn.close()
session = Session()
songs = [session.query(Song).get(song[0]).dictify() for song in res]
session.commit()
return {'limit': limit, 'results': songs}
def update(package_id, remark):
try:
session_obj = Session()
tmp = session_obj.query(package_info).filter_by(
id=package_id).first()
if tmp == None:
Session.remove()
return -1
tmp.remarks = remark
session_obj.commit()
Session.remove()
return 0
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
async def list_sub(inline_query: InlineQuery):
session = Session()
_startwith = inline_query.query
items = []
for row in session.query(BD_Subs).filter_by(user_id=inline_query.from_user.id):
if not row.sub_name.lower().startswith(_startwith): continue
sub_name = row.sub_name
item = InlineQueryResultArticle(
id=row.id,
title=f'Result {sub_name}',
input_message_content=InputTextMessageContent(sub_name),
)
items.append(item)
await bot.answer_inline_query(inline_query.id, results=items, cache_time=1)
