def group(call):
if not is_person(call.message.chat):
return
try:
user = User.get(telegram_id=call.message.chat.id)
if user not in User.select(User).join(Links).join(Group).where(Group.group_name == 'Admins'):
raise Exception("Unauthorized user")
except Exception:
bot.send_message(text=get_unauthorized_user_start_message(), chat_id=call.message.chat.id)
return
group_to_add_to = Group.get(id=int(call.data.split('_')[1]))
user_to_be_entered_to_group = User.get(id=int(call.data.split('_')[2]))
Links.get_or_create(user=user_to_be_entered_to_group,
group=group_to_add_to)
if user_to_be_entered_to_group in User.select(User).join(Links).join(Group).where(
Group.group_name == 'Unauthorized'):
temp_link = Links.get(user=user_to_be_entered_to_group,
group=Group.get(group_name='Unauthorized'))
temp_link.delete_instance()
logger.info(
f'{user.first_name} {user.last_name} added user {user_to_be_entered_to_group.first_name} {user_to_be_entered_to_group.last_name} to group {group_to_add_to.group_name}')
bot.send_message(chat_id=user_to_be_entered_to_group.telegram_id,
text=f'Вы авторизованы и добавлены в группу {group_to_add_to.group_name}',
reply_markup=get_start_keyboard(user))
bot.send_message(chat_id=user_to_be_entered_to_group.telegram_id,
text='Список доступных Вам функций',
reply_markup=get_main_inline_keyboard(user_to_be_entered_to_group))
bot.edit_message_text(message_id=call.message.message_id,
chat_id=call.message.chat.id,
text=user_info(user_to_be_entered_to_group),
reply_markup=keyboard_to_chose_users_groups(user_to_be_entered_to_group))
def group(call):
if not is_person(call.message.chat):
return
try:
user = User.get(telegram_id=call.message.chat.id)
if user not in User.select(User).join(Links).join(Group).where(Group.group_name == 'Admins'):
raise Exception("Unauthorized user")
except Exception:
bot.send_message(text=get_unauthorized_user_start_message(), chat_id=call.message.chat.id)
return
group_to_remove_from = Group.get(id=int(call.data.split('_')[1]))
user_to_be_removed_from_group = User.get(id=int(call.data.split('_')[2]))
Links.get(user=user_to_be_removed_from_group,
group=group_to_remove_from).delete_instance()
logger.info(
f'{user.first_name} {user.last_name} removed user {user_to_be_removed_from_group.first_name} {user_to_be_removed_from_group.last_name} from group {group_to_remove_from.group_name}')
bot.send_message(chat_id=user_to_be_removed_from_group.telegram_id,
text=f'Вы удалены из группы {group_to_remove_from.group_name}',
reply_markup=get_start_keyboard(user))
bot.send_message(chat_id=user_to_be_removed_from_group.telegram_id,
text='Список доступных Вам функций',
reply_markup=get_main_inline_keyboard(user_to_be_removed_from_group))
if Group.select(Group).join(Links).join(User).where(User.id == user_to_be_removed_from_group.id).count() == 0:
Links.get_or_create(user=user_to_be_removed_from_group,
group=Group.get(group_name='Unauthorized'))
bot.send_message(chat_id=user_to_be_removed_from_group.telegram_id,
text='Вы были удалены из всех групп. Получите авторизацию у администратора, чтобы продолжить пользоваться этим ботом!',
reply_markup=None)
bot.edit_message_text(message_id=call.message.message_id,
chat_id=call.message.chat.id,
text=user_info(user_to_be_removed_from_group),
reply_markup=keyboard_to_chose_users_groups(user_to_be_removed_from_group))
def delete(self, key):
if auth.user_is_admin():
Group.get(key).delete()
else:
Messages.add('Only an administrator may delete groups. This ' +
'incident has been logged.')
return self.redirect('/groups')
def delete(self, key):
"""Deletes a group."""
if auth.user_is_admin():
Group.get(key).delete()
else:
Messages.add('Only an administrator may delete groups. This ' +
'incident has been logged.')
return self.redirect('/groups')
def popup(self, pos):
row = self.selectionModel().selection().indexes()[0].row()
if row < 1:
return
menu = QMenu()
delaction = menu.addAction("Supprimer")
action = menu.exec_(self.mapToGlobal(pos))
if action == delaction:
Group.get(Group.name == self.item(row).text()).delete_instance()
self.refresh_()
def show(self, key):
if self.request.method == 'GET':
return self.render('groups_show', { 'group': Group.get(key)})
elif self.request.method == 'POST':
self.update_group(key)
else:
return self.abort(405) # all other methods not allowed
def addEvent(user, cs, name, where, when, who, repeat):
calendars = []
if who:
try:
key = db.Key(who)
group = Group.get(key)
except:
return JsonResponse({}, 404)
gg = group.getAllChildren()
#gg.append(group)
for g in gg:
if g.calendarId and len(g.calendarId) > 0 and g.type != 'user':
calendars.append(g.calendarId)
#try:
calendars.append(user.calendarId)
#return JsonResponse(calendars)
#event = InsertSingleEvent(calendarService,
# user.calendarId, name, '', where, when[0], when[1])
cs2 = CS(cs)
for cal in calendars:
event = cs2.InsertSingleEvent(cal, name, '',
where, when[0], when[1], reccurence(when, repeat),
{ 'name': user.name if cal != user.calendarId else group.name,
'email': getSystemAccount().email
})
#except Exception, err:
# return JsonResponse(cal + ' ' + err.__str__())
return JsonResponse({ 'id': event.id.text })
def groups_put(request):
try:
try:
r = GetParams(request)
except:# Exception as e:
return JsonResponse(sys.exc_info()[0].__str__())
if (not 'id' in r or not 'name' in r):
return JsonResponse({}, 400)
id = r['id']
name = r['name']
try:
key = db.Key(id)
group = Group.get(key)
if (group.type() == 'user'):
if ('email' in r):
group.account = users.User(r['email'])
except: # Exception as e:
return JsonResponse(sys.exc_info()[0].__str__(), 404)
if 'calId' in r:
group.calendarId = r['calId'].strip() if r['calId'].strip().__len__() > 0 else None
group.name = name
group.put()
return JsonResponse({})
except:# Exception as e:
return JsonResponse(sys.exc_info()[0].__str__())
def get_character_skills(character_id, current_user=None):
character = Character.get(character_id)
character_application_access_check(current_user, character)
skill_data = character.get_op(
'get_characters_character_id_skills',
character_id=character_id,
)
queue_data = character.get_op(
'get_characters_character_id_skillqueue',
character_id=character_id,
)
for skill_list in skill_data['skills'], queue_data:
for entry in skill_list:
skill = Type.get(entry['skill_id'])
group = Group.get(skill.group_id)
entry['skill_id'] = {
'group_name': group.name,
'skill_name': skill.name,
}
return {
'info': {
'skills': skill_data['skills'],
'queue': queue_data,
'total_sp': skill_data['total_sp']
}
}
def get_group(self, title):
db.connect()
try:
g = Group.get(Group.title == title)
except Group.DoesNotExist:
g = Group.create(title = title)
db.close()
return g
def show(self, key):
"""Displays details about a group."""
if self.request.method == 'GET':
return self.render('groups_show', {'group': Group.get(key)})
elif self.request.method == 'POST':
self.update_group(key)
else:
return self.abort(405) # all other methods not allowed
def get(self, id):
try:
group = Group.get(Group.id == id)
except Exception as e:
print(e)
abort(404, message="Group not found")
else:
return group
def update_group(self, key):
if not auth.logged_in():
return self.redirect('/groups')
user = auth.current_user()
group = Group.get(key)
if group.owner.user_id() != user.user_id() and not auth.user_is_admin():
Messages.add('Only the owner of the group owner may modify it')
return self.redirect('/groups')
name = self.request.get('name')
public = self.request.get('public') == 'public'
abandon = self.request.get('abandon-project')
sub_text = self.request.get('submission-text')
sub_url = self.request.get('submission-url')
remove_submission = self.request.get_all('remove-submission')
remove = self.request.get_all('remove')
owner = self.request.get('owner')
delete = self.request.get('delete')
if delete:
group.delete()
return self.redirect('/groups')
group.name = name
group.public = public
if abandon:
group.project = None
if sub_text and sub_url:
Submission(text=sub_text, url=sub_url, group=group).put()
for sub in Submission.get(remove_submission):
sub.delete()
pending = list(group.pending_users)
for user in pending:
approve = self.request.get("approve-%s" % user)
if approve == "approve":
group.members.append(user)
group.pending_users.remove(user)
elif approve == "refuse":
group.pending_users.remove(user)
group.owner = auth.user_from_email(owner)
for user in remove:
if auth.user_from_email(user) == group.owner:
Messages.add('Cannot remove the group owner')
return self.redirect('/groups/%s/edit' % key)
else:
group.members.remove(auth.user_from_email(user))
group.put()
return self.redirect('/groups/%s' % key)
def group(group_name):
group_answers = []
for puzzle in Puzzle.select().order_by(Puzzle.name):
puzzle_answers = (
puzzle.answers.select().join(Player).join(Group).where(
Group.name == group_name))
group_answers.append((puzzle.name, puzzle_answers))
return render_template('group.html',
group=Group.get(Group.name == group_name),
group_answers=group_answers)
def leave(self, key):
group = Group.get(key)
user = auth.User(auth.current_user())
if user.group != group:
Messages.add('You cannot leave a group you are not in')
return self.redirect('/groups/%s' % key)
group.members.remove(user.gae_user)
group.put()
return self.redirect('/groups')
def edit(self, key):
if not auth.logged_in():
return self.redirect('/groups')
user = auth.current_user()
group = Group.get(key)
if group.owner.user_id() == user.user_id() or auth.user_is_admin():
return self.render('groups_edit', { 'group': group })
else:
Messages.add('Only the owner of this group may edit it')
return self.redirect('/groups/%s' % key)
def leave(self, key):
"""Removes the current user from the group's roster."""
group = Group.get(key)
user = auth.User(auth.current_user())
if user.group != group:
Messages.add('You cannot leave a group you are not in')
return self.redirect('/groups/%s' % key)
group.members.remove(user.gae_user)
group.put()
return self.redirect('/groups')
def edit(self, key):
"""Displays the group moderation form."""
if not auth.logged_in():
return self.redirect('/groups')
user = auth.current_user()
group = Group.get(key)
if group.owner.user_id() == user.user_id() or auth.user_is_admin():
return self.render('groups_edit', {'group': group})
else:
Messages.add('Only the owner of this group may edit it')
return self.redirect('/groups/%s' % key)
def send_image():
"""
send image/photo to given telegram user
"""
username = request.args.get("username", "")
to_id = request.args.get("to", "")
photo_file = request.files.get("photo", "")
photo = request.form.get("photo", "")
if not username:
msg = "username missing"
raise Error(msg)
if not to_id:
msg = "to id missing"
raise Error(msg)
if not any([photo_file, photo]):
msg = "photo can not be blank"
raise Error(msg)
user_obj = User()
user = user_obj.get(username=username)
if not user:
msg = "you dont have permisson to send notification"
raise Error(msg)
to = user_obj.get(username=to_id)
if not to:
group_obj = Group()
to = group_obj.get(group_name=to_id)
if not to:
msg = "invalid to id"
raise Error(msg)
else:
if photo:
send_photo(my_bot, user["uid"], to["gid"], photo)
else:
out = BytesIO()
out.write(photo_file.stream.read())
out.seek(0)
send_photo(my_bot, user["uid"], to["gid"], out)
return jsonify({"ok": 1})
if photo:
send_photo(my_bot, user["uid"], to["uid"], photo)
else:
out = BytesIO()
out.write(photo_file.stream.read())
out.seek(0)
send_photo(my_bot, user["uid"], to["uid"], out)
return jsonify({"ok": 1})
def group(group_name):
group_answers = []
for puzzle in Puzzle.select().order_by(Puzzle.name):
puzzle_answers = (
puzzle.answers.select()
.join(Player).join(Group)
.where(Group.name == group_name)
)
group_answers.append((puzzle.name, puzzle_answers))
return render_template(
'group.html',
group=Group.get(Group.name == group_name),
group_answers=group_answers)
def set_data_for(self, group_id=None, search=None):
if isinstance(group_id, int):
qs = ContactGroup.select().where(ContactGroup.group ==
Group.get(Group.id == group_id))
self.data = [("", contact_gp.contact.name, contact_gp.contact.number)
for contact_gp in qs]
else:
qs = Contact.select()
if search:
print(search)
qs = qs.where(Contact.number.contains(search)
| Contact.name.contains(search))
print(qs)
self.data = [("", contact.name, contact.number) for contact in qs]
def groups_newcal(request):
if not 'id' in request.REQUEST:
return JsonResponse({}, 400)
id = request.REQUEST['id']
try:
key = db.Key(id)
group = Group.get(key)
except:
return JsonResponse({}, 404)
cs = getCalendarService(request)
cal = createCalendar(cs, group.name)
calendarId = cal.GetEventFeedLink()
group.calendarId = calendarId
group.put()
return JsonResponse({ 'calId' : calendarId })
def upload_document():
"""
send document to given telegram user
"""
username = request.args.get("username", "")
to_id = request.args.get("to", "")
document_file = request.files.get("document", "")
if not username:
msg = "username missing"
raise Error(msg)
if not to_id:
msg = "to id missing"
raise Error(msg)
if not document_file:
msg = "document can not be blank"
raise Error(msg)
user_obj = User()
user = user_obj.get(username=username)
if not user:
msg = "you dont have permisson to send notification"
raise Error(msg)
to = user_obj.get(username=to_id)
if not to:
group_obj = Group()
to = group_obj.get(group_name=to_id)
if not to:
msg = "invalid to id"
raise Error(msg)
else:
out = BytesIO()
out.write(document_file.stream.read())
out.seek(0)
send_document(my_bot, user["uid"], to[
"gid"], out, str(document_file.filename))
return jsonify({"ok": 1})
out = BytesIO()
out.write(document_file.stream.read())
out.seek(0)
send_document(my_bot, user["uid"], to["uid"],
out, str(document_file.filename))
return jsonify({"ok": 1})
def save_group(request, group_id):
if request.method == 'POST':
form = GroupForm(request.POST)
if form.is_valid():
try:
group = Group.get(group_id)
except:
return HttpResponseRedirect('/webconf/couchauth/show_groups/')
users = request.POST.getlist('users')
group.update_users(users)
if group.name != form.cleaned_data['name']:
group.name = form.cleaned_data['name']
group.save()
return HttpResponseRedirect('/webconf/couchauth/show_groups/')
def join(self, key):
group = Group.get(key)
user = auth.User(auth.current_user())
if user.in_group():
Messages.add('You are already in a group')
return self.redirect('/groups/%s' % key)
if user.pending_join():
Messages.add('You have already applied to join a group')
return self.redirect('/groups/%s' % key)
if group.public:
group.members.append(auth.current_user())
Messages.add('You have joined the group')
else:
group.pending_users.append(auth.current_user())
Messages.add('You have requested to join the group')
group.put()
return self.redirect('/groups/%s' % key)
def addressbook_contactlist(group_id):
try:
group_id = int(group_id)
except:
group_id = ALL_CONTACTS
if group_id == ALL_CONTACTS:
qs = ContactGroup.filter().group_by('contact')
group_dict = {'id': -1, 'name': u"Tous"}
else:
qs = ContactGroup.filter(group__id=group_id)
group_dict = Group.get(id=group_id).to_dict()
data = {'contacts': [contact_group.contact.to_dict()
for contact_group in qs],
'group': group_dict}
return json.dumps(data)
def edit(group_id):
"""Úprava specifické skupiny včetně přidávání uživatelů"""
user = getUser()
group = Group.get( group_id )
if not ( user.inRole("master") or group.lector == user.login):
return unauthorized()
# vložení studenta
if request.forms.get("add"):
try:
usr = User.insertStudent( request.forms.get("add"), group_id )
msg("Student %s vložen" % usr.login,"success")
except Exception as e:
msg("Chyba při vkládání studenta - %s " % e,"error")
redirect(request.path)
# odstranění studenta
if request.query.get("remove"):
usr = User.get( request.query.get("remove") )
if not usr:
msg("Student nenalezen","error")
elif usr.remove():
msg("Student %s odstraněn"% usr.login ,"success")
else:
msg("Student nenalezen","error")
redirect(request.path)
form = GroupForm(request.forms.decode(), group)
if request.method == 'POST' and form.validate():
try:
group.update( name = form.name.data )
msg("Skupina aktualizována","success")
except Exception as e:
msg("Chyba při aktualizaci - %s" % e, "error")
redirect(request.path)
return template("groups_edit", {"group" : group, "form": form_renderer(form) } )
def delete(group_id):
"""Smaže skupinu"""
user = getUser()
group = Group.get( group_id )
if not ( user.inRole("master") or group.lector == user.login):
return unauthorized()
answer = request.forms.get("answer")
if answer:
if answer == "Ne": redirect("/groups")
if answer == "Ano":
group.remove()
msg("Skupina smazána","success")
redirect("/groups")
return template("question", {"question":"Skutečně chcete smazat skupinu '%s'" % group.name } )
def save_group(request, group_id):
if request.method == 'POST':
form = GroupForm(request.POST)
if form.is_valid():
try:
group = Group.get(group_id)
except:
return HttpResponseRedirect('/webconf/couchauth/show_groups/')
users = request.POST.getlist('users')
group.update_users(users)
if group.name != form.cleaned_data['name']:
group.name = form.cleaned_data['name']
group.save()
return HttpResponseRedirect('/webconf/couchauth/show_groups/')
def register():
group_name = request.form['group'].strip()
player_name = request.form['player'].strip()
try:
# Perform case-insensitive search.
group = Group.get(fn.Lower(Group.name) == group_name.lower())
except:
group = Group.create(name=group_name)
try:
# Perform case-insensitive search.
player = Player.get(fn.lower(Player.name) == player_name.lower(), group=group)
except Player.DoesNotExist:
player = Player.create(
group=group, name=player_name, order=group.players.count())
return str(player.id)
def join(self, key):
"""Adds the current user to the group's roster."""
group = Group.get(key)
user = auth.User(auth.current_user())
if user.in_group():
Messages.add('You are already in a group')
return self.redirect('/groups/%s' % key)
if user.pending_join():
Messages.add('You have already applied to join a group')
return self.redirect('/groups/%s' % key)
if group.public:
group.members.append(auth.current_user())
Messages.add('You have joined the group')
else:
group.pending_users.append(auth.current_user())
Messages.add('You have requested to join the group')
group.put()
return self.redirect('/groups/%s' % key)
def edit(group_id):
"""Úprava specifické skupiny včetně přidávání uživatelů"""
user = getUser()
group = Group.get(group_id)
if not (user.inRole("master") or group.lector == user.login):
return unauthorized()
# vložení studenta
if request.forms.get("add"):
try:
usr = User.insertStudent(request.forms.get("add"), group_id)
msg("Student %s vložen" % usr.login, "success")
except Exception as e:
msg("Chyba při vkládání studenta - %s " % e, "error")
redirect(request.path)
# odstranění studenta
if request.query.get("remove"):
usr = User.get(request.query.get("remove"))
if not usr:
msg("Student nenalezen", "error")
elif usr.remove():
msg("Student %s odstraněn" % usr.login, "success")
else:
msg("Student nenalezen", "error")
redirect(request.path)
form = GroupForm(request.forms.decode(), group)
if request.method == "POST" and form.validate():
try:
group.update(name=form.name.data)
msg("Skupina aktualizována", "success")
except Exception as e:
msg("Chyba při aktualizaci - %s" % e, "error")
redirect(request.path)
return template("groups_edit", {"group": group, "form": form_renderer(form)})
def delete(group_id):
"""Smaže skupinu"""
user = getUser()
group = Group.get(group_id)
if not (user.inRole("master") or group.lector == user.login):
return unauthorized()
answer = request.forms.get("answer")
if answer:
if answer == "Ne":
redirect("/groups")
if answer == "Ano":
group.remove()
msg("Skupina smazána", "success")
redirect("/groups")
return template("question", {"question": "Skutečně chcete smazat skupinu '%s'" % group.name})
def register():
group_name = request.form['group'].strip()
player_name = request.form['player'].strip()
try:
# Perform case-insensitive search.
group = Group.get(fn.Lower(Group.name) == group_name.lower())
except:
group = Group.create(name=group_name)
try:
# Perform case-insensitive search.
player = Player.get(fn.lower(Player.name) == player_name.lower(),
group=group)
except Player.DoesNotExist:
player = Player.create(group=group,
name=player_name,
order=group.players.count())
return str(player.id)
def send_notification():
"""
send notification to given telegram user
"""
username = request.args.get("username", "")
to_id = request.args.get("to", "")
text = request.args.get("msg", "")
msg_type = request.args.get("type", None) # "HTML" or "Markdown"
if not username:
msg = "required parameter username missing"
raise Error(msg)
if not to_id:
msg = "required parameter to missing"
raise Error(msg)
if not text:
msg = "message can not be blank"
raise Error(msg)
user_obj = User()
user = user_obj.get(username=username)
if not user:
msg = "you dont have permisson to send notification"
raise Error(msg)
to = user_obj.get(username=to_id)
if not to:
group_obj = Group()
to = group_obj.get(group_name=to_id)
if not to:
msg = "invalid to id"
raise Error(msg)
else:
send_msg(my_bot, user["uid"], -to["gid"], text, msg_type)
return jsonify({"ok": 1})
send_msg(my_bot, user["uid"], to["uid"], text, msg_type)
return jsonify({"ok": 1})
def show_group(request, group_id):
try:
group = Group.get(group_id)
except:
return HttpResponseRedirect('/webconf/couchauth/show_groups/')
form = GroupForm(instance=group)
if form.is_valid():
group = Group()
group.name = form.cleaned_data['name']
group.max_loan_days = form.cleaned_data['max_loan_days']
group.save()
form_url = "/webconf/couchauth/save_group/%s/" % group_id
context = { 'form': form,
'form_title': 'Editar Grupo',
'group': group,
'form_url': form_url,
}
return render_to_response('webconf/couchauth/form_group.html',
context,
context_instance=RequestContext(request)
)
def post(self, key):
user = self.getVolunteer(key)
user.pending = self.request.get('volunteer[pending]') == "true"
user.pending_code = self.request.get('volunteer[pending_code]')
user.email = self.request.get('volunteer[email]')
user.first_name = self.request.get('volunteer[first_name]')
user.last_name = self.request.get('volunteer[last_name]')
user.is_pc = self.request.get('volunteer[is_pc]') == "true"
user.is_group_leader = self.request.get(
'volunteer[is_group_leader]') == "true"
user.phone = self.request.get('volunteer[phone]')
group_key = self.request.get('volunteer[group]')
group = Group.get(group_key) if group_key != "" else None
user.setGroup(group)
project_key = self.request.get('volunteer[project]')
project = Project.get(project_key) if project_key != "" else None
user.setProject(project)
user.save()
self.redirect('/admin/volunteers/{}'.format(user.key()), {'error': 1})
def show_group(request, group_id):
try:
group = Group.get(group_id)
except:
return HttpResponseRedirect('/webconf/couchauth/show_groups/')
form = GroupForm(instance=group)
if form.is_valid():
group = Group()
group.name = form.cleaned_data['name']
group.max_loan_days = form.cleaned_data['max_loan_days']
group.save()
form_url = "/webconf/couchauth/save_group/%s/" % group_id
context = {
'form': form,
'form_title': 'Editar Grupo',
'group': group,
'form_url': form_url,
}
return render_to_response('webconf/couchauth/form_group.html',
context,
context_instance=RequestContext(request))
def remove_group(call):
if not is_person(call.message.chat):
return
try:
user = User.get(telegram_id=call.message.chat.id)
if user not in User.select(User).join(Links).join(Group).where(Group.group_name == 'Admins'):
raise Exception("Unauthorized user")
except Exception:
bot.send_message(text=get_unauthorized_user_start_message(), chat_id=call.message.chat.id)
return
links = Links.select(Links).join(Group).where(Group.id == int(call.data.split('_')[1]))
for link in links:
link.delete_instance()
logger.info(f"remove group - {Group.get(id=int(call.data.split('_')[1])).group_name}")
group = Group.get(id=int(call.data.split('_')[1]))
group.delete_instance()
groups = Group.select()
return_str = 'Список групп:\n'
for group in groups:
return_str += group.group_name + '\n'
bot.edit_message_text(text=return_str, chat_id=call.message.chat.id, message_id=call.message.message_id)
User.update(status='').where(User.id == user.id).execute()
def addressbook_add_contact_to_group(group_id, contact_id):
contact = Contact.get(id=int(contact_id))
group = Group.get(id=int(group_id))
data = {'contact': contact.to_dict(),
'group': group.to_dict()}
subst = {'contact': contact.display_name(),
'group': group.display_name()}
if ContactGroup.filter(contact=contact, group=group).count():
dict_return(data, INFO,
u"%(contact)s fait déjà parti du groupe %(group)s." % subst,
message_html=u"<strong>%(contact)s</strong> fait déjà "
u"parti du groupe "
u"<strong>%(group)s</strong>." % subst)
else:
cg = ContactGroup(contact=contact, group=group)
try:
cg.save()
dict_return(data, SUCCESS,
u"%(contact)s a été ajouté au groupe %(group)s." % subst,
message_html=u"<strong>%(contact)s</strong> a été "
u"ajouté au groupe "
u"<strong>%(group)s</strong>." % subst)
except Exception as e:
subst.update({'err': e.message})
dict_return(data, ERROR,
u"Impossible d'ajouter %(contact)s au groupe "
u"%(group)s: %(err)r" % subst,
message_html=u"Impossible d'ajouter "
u"<strong>%(contact)s</strong> au "
u"groupe <strong>%(group)s</strong>:<br />"
u"<em>%(err)r</em>" % subst)
return json.dumps(data)
def download(group_id):
"""Stažení výsledků skupiny ve wis formátu"""
user = getUser()
group = Group.get(group_id)
if not (user.inRole("master") or group.lector == user.login):
return unauthorized()
headers = {}
headers["Content-Type"] = "text/csv"
headers["Content-Disposition"] = 'attachment; filename="%s.csv"' % slug(group.name)
# Formát CSV: 1. ID, 2. jméno, 3. login, 4. body, 5. celk.body, 6. datum, 7. login zadávajícího
# při importu musí být zachováno pořadí sloupců, stačí vyplnit sloupce 3. a 4., případně 6.
date = today()
data = []
results = group.getResults()
for login, points in results.items():
data.append(";;%s;%s;;%s;%s;" % (login, points, date, group.lector))
data = "\n".join(data)
return HTTPResponse(data, **headers)
def get(self, group_key):
# confirm participant id in cookie
c_group_key = ChatTrait.get_group_key(self)
participant_key = ChatTrait.get_participant_key(self)
# get group
group = Group.get(group_key)
# if participant is none or login to another group, create new participant in group
if not participant_key:
participant = Participant()
participant.store(group.key)
participant_key = participant.key
ChatTrait.store_participant_key(self, participant_key)
if c_group_key:
if c_group_key != group_key:
group.participant(Participant.get(participant_key))
ChatTrait.store_group_key(self, group.key)
else:
ChatTrait.store_group_key(self, group.key)
# return response
self.render("chat.html", group_name=group.name)
def addressbook_delete_group(group_id):
data = {}
subst = {}
try:
group = Group.get(id=int(group_id))
contact_groups = ContactGroup.filter(group__id=int(group_id))
except Group.DoesNotExist as e:
subst.update({'err': e.message,
'group': group_id})
dict_return(data, ERROR,
u"Le groupe #%(group)s n'existe pas : %(err)r" % subst,
message_html=u"Le groupe "
u"<strong>%(group)s</strong> n'existe pas.<br />"
u"<em>%(err)r</em>" % subst)
return json.dumps(data)
subst.update({'group': group.display_name()})
try:
[cg.delete_instance() for cg in contact_groups]
group.delete_instance()
dict_return(data, SUCCESS,
u"%(group)s a été supprimé avec succès." % subst,
message_html=u"<strong>%(group)s</strong> "
u"a été supprimé avec succès." % subst)
except Exception as e:
subst.update({'err': e.message})
dict_return(data, ERROR,
u"Impossible de supprimer le groupe %(group)s : %(err)r" % subst,
message_html=u"Impossible de supprimer le groupe "
u"<strong>%(group)s</strong><br />"
u"<em>%(err)r</em>" % subst)
return json.dumps(data)
def get(self, group_key):
# confirm participant id in cookie
c_group_key = ChatTrait.get_group_key(self)
participant_key = ChatTrait.get_participant_key(self)
# get group
group = Group.get(group_key)
# if participant is none or login to another group, create new participant in group
if not participant_key:
participant = Participant()
participant.store(group.key)
participant_key = participant.key
ChatTrait.store_participant_key(self, participant_key)
if c_group_key:
if c_group_key != group_key:
group.participant(Participant.get(participant_key))
ChatTrait.store_group_key(self, group.key)
else:
ChatTrait.store_group_key(self, group.key)
# return response
self.render("chat.html", group_name=group.name)
def download(group_id):
"""Stažení výsledků skupiny ve wis formátu"""
user = getUser()
group = Group.get( group_id )
if not ( user.inRole("master") or group.lector == user.login):
return unauthorized()
headers = {}
headers['Content-Type'] = "text/csv"
headers['Content-Disposition'] = 'attachment; filename="%s.csv"' % slug(group.name)
#Formát CSV: 1. ID, 2. jméno, 3. login, 4. body, 5. celk.body, 6. datum, 7. login zadávajícího
#při importu musí být zachováno pořadí sloupců, stačí vyplnit sloupce 3. a 4., případně 6.
date = today()
data = []
results = group.getResults()
for login, points in results.items():
data.append(";;%s;%s;;%s;%s;" % (login, points, date, group.lector) );
data = "\n".join(data)
return HTTPResponse(data, **headers)
def add_grp(self, grpname):
group = Group.get(Group.name == grpname.name)
ContactGroup.get_or_create(group=group, contact=self.contact)
self.refresh()
def del_grp(self, grp_ct):
group = Group.get(Group.name == grp_ct.group.name)
contactgrp = ContactGroup.select().where(ContactGroup.group == group,
ContactGroup.contact == self.contact).get()
contactgrp.delete_instance()
self.refresh()
def get_group(self, title):
try:
g = Group.get(Group.title == title)
except Group.DoesNotExist:
g = Group.create(title = title)
return g
def get(self, group_key):
group = Group.get(group_key)
chats = group.chats(0, 300)
return self.write({"chats": list(map(lambda c: c.to_dict(), chats))})
def get(self, group_key):
group = Group.get(group_key)
chats = group.chats(0, 300)
return self.write({"chats": list(map(lambda c: c.to_dict(), chats))})
def update_group(self, key):
"""Updates a group with information from the moderation form.
Form Variables:
name: the name of the group
public: true if the group should be joinable by the
public
abandon-project: true if the group moderator wants to abandon the
current project
submission-text: the text to be displayed for the new submission
submission-url: the URL of the new submission
remove-submission: a list of submissions to be removed
remove: a list of users to be removed from the group
owner: the owner of the group
delete: true if the group moderator wants to disband the
group
"""
if not auth.logged_in():
return self.redirect('/groups')
user = auth.current_user()
group = Group.get(key)
if (group.owner.user_id() != user.user_id() and
not auth.user_is_admin()):
Messages.add('Only the owner of the group owner may modify it')
return self.redirect('/groups')
name = self.request.get('name')
public = self.request.get('public') == 'public'
abandon = self.request.get('abandon-project')
sub_text = self.request.get('submission-text')
sub_url = self.request.get('submission-url')
remove_submission = self.request.get_all('remove-submission')
remove = self.request.get_all('remove')
owner = self.request.get('owner')
delete = self.request.get('delete')
if delete:
group.delete()
return self.redirect('/groups')
group.name = name
group.public = public
if abandon:
group.project = None
if sub_text and sub_url:
Submission(text=sub_text, url=sub_url, group=group).put()
for sub in Submission.get(remove_submission):
sub.delete()
pending = list(group.pending_users)
for user in pending:
approve = self.request.get("approve-%s" % user)
if approve == "approve":
group.members.append(user)
group.pending_users.remove(user)
elif approve == "refuse":
group.pending_users.remove(user)
group.owner = auth.user_from_email(owner)
for user in remove:
if auth.user_from_email(user) == group.owner:
Messages.add('Cannot remove the group owner')
return self.redirect('/groups/%s/edit' % key)
else:
group.members.remove(auth.user_from_email(user))
group.put()
return self.redirect('/groups/%s' % key)
def getGroup(self, key):
group = Group.get(key)
self.throw404If(group is None)
return group
def getGroup(self, key):
if key == "new":
return None
group = Group.get(key)
self.throw404If(group is None)
return group
