def create_user(request, template='user/create.html'):
client = Utils.getDiscourseClient()
d = {}
d['sso_links'] = sso_links
d['form'] = LoginForm()
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
try:
password_validation.validate_password(request.POST['password'])
except ValidationError as errs:
messages.error(request, 'Das hat nicht geklappt: Folgende Fehler sind aufgetreten:')
for err in errs:
messages.error(request, err)
else:
item = form.save()
item.set_password(item.password)
Utils.create_discourse_user(item)
basicgroup = Utils.get_or_create_basic_group()
basicgroup.user_set.add(item)
logger.info("User "+item.username+" wurde erfolgreich angelegt.")
messages.success(request, 'Dein Account wurde erfolgreich angelegt. Er muss nun freigeschaltet werden. Dann kannst du dich einloggen.')
return redirect('/')
else:
messages.error(request, 'Das hat nicht geklappt. Dein Account wurde nicht angelegt.')
d['form'] = form
return render(request, template, d)
#return JsonResponse(data={'form': d['form'].as_p(), 'token': get_token(request)}, success=False)
d['user_list'] = User.objects.all()
return render(request, template, d)
def import_dgroups(request):
client = Utils.getDiscourseClient()
groupsDict = client.groups()
for groupDict in groupsDict:
# gruppe in da erzeugen falls noch nicht vorhanden
groupObj, created = dGroup.objects.get_or_create(
discourse_group_id=groupDict['id'])
if groupDict['automatic'] & (groupDict['name'] != "vertrauensstufe_0"):
groupObj.delete()
else:
print("import: " + str(groupDict['id']) + " : " +
groupDict['name'])
if created:
print("created")
for key in groupDict:
if key != "id":
setattr(groupObj, key, groupDict[key])
groupObj.create_date = datetime.datetime.now()
else:
print("already exists") #TODO: Discourse group aktualisieren ?
#groupObj.update_date = datetime.datetime.now()
groupObj.discourse_group_id = groupDict['id']
groupObj.save()
Utils.import_dgroup_members(groupDict['name'], groupObj.id)
return JsonResponse()
def activate_user(request, user_id):
#TODO: check authorisation ? Nö darf jede aus dem Staff
user = User.objects.get(id=user_id)
user.is_active = True
user.last_login = datetime.datetime.now()
user.save()
print(user.__dict__)
# soll auch passieren damit man auch in discourse sieht wer deaktiviert ist
# TODO: lieber discourse_user (das ist ne id) nehmen? dann aber daten overhead ?
try:
client = Utils.getDiscourseClient()
p = user.participant
dUser = client.user_all(user_id=p.discourse_user)
print(dUser['id'])
except:
messages.error(request, "Der Benutzer "+user.username+" scheint nicht sinvoll mit discourse verknüpft zu sein, ist jetzt nur im backend aktiviert")
print ("Der Benutzer "+user.username+" scheint nicht sinvoll mit discourse verknüpft zu sein, ist jetzt nur im backend aktiviert")
return redirect('user-list')
try: client.activate(dUser['id'])
except:
messages.error(request, "Der Benutzer "+user.username+" scheinbar bereits aktiviert ?.")
print("scheinbar bereits aktiviert")
try: client.unsuspend(dUser['id'])
except: print("scheinbar nicht gesperrt")
return redirect('user-list')
def test_crud(self):
# Create new instance
print("start group-create")
#groupsDict = client.groups()
#print(groupsDict)
response = self.client.post(reverse('group-create'), {"name":"djangotest"})
#print(response)
#self.assertContains(response, '"success": true')
#Read from Discourse
client = Utils.getDiscourseClient()
try:
discGroups = client.groups()
assertCG = False;
for group in discGroups:
if group['name'] == "djangotest": assertCG = True
self.assertTrue(assertCG)
except: self.fail("Gruppe ist nicht in Discourse angekommen")
# Read instance
items = dGroup.objects.all()
self.failUnlessEqual(items.count(), 1)
item = items[0]
response = self.client.get(reverse('group-details', kwargs={'id': item.id}))
self.failUnlessEqual(response.status_code, 200)
# Delete instance
response = self.client.post(reverse('group-delete', kwargs={'id': item.id}), {})
items = dGroup.objects.all()
self.failUnlessEqual(items.count(), 0)
def create_discourse_user(request, user_id):
user = get_object_or_404(User, pk=user_id)
try: p = user.participant
except: logger.info("User "+user.username+" wird in discourse neu angelegt. Er scheint vorher nicht dort existiert zu haben kein Participatn gefunden.")
else:
client = Utils.getDiscourseClient()
try: userDetails = client.user_all(user_id=p.discourse_user)
except:
logger.info("User "+user.username+" wird wird in discourse neu angelegt. Participant existierte zwar, er scheint aber trotzdem nicht in discourse zu existieren.")
user.participant.delete()
else:
messages.error(request, "Der Benutzer "+user.username+" scheint doch zu existieren. (discourse.id:"+p.discourse_user+" da.id:"+ +" user_id) Die Verbindung zu Discourse besteht bereits, der Benutzer existiert auch dort. Es scheint eine anderer Fehler vorzuliegen. Wende dich bitte an einen Admin und poste diesen Text.")
return redirect('user-details', id=user_id)
Utils.create_discourse_user(user)
basicgroup = Utils.get_or_create_basic_group()
basicgroup.user_set.add(user)
return redirect('user-details', id=user_id)
def set_basic_group(request):
basicgroup = Utils.get_or_create_basic_group()
print(basicgroup)
users = User.objects.all().exclude(groups__id=1)
print(users)
for user in users:
basicgroup.user_set.add(user)
return JsonResponse()
def testpd(request):
client = Utils.getDiscourseClient()
#client.groups()
#result = client.watch_topic(57, username="******", notification_level=3)
result = client.watch_category(5, "heiner")
print(result)
print(request.method)
print(request)
return JsonResponse()
def change_password(request, template='user/change_password.html'):
d = {}
d['form'] = ChangePasswordForm()
d['sso_links'] = sso_links
d['ignore_sso_link'] = 'change_password'
d['theuser'] = request.user
if request.method == 'POST':
if not request.user.is_authenticated:
user = authenticate(request, username=request.POST['username'], password=request.POST['password'])
if user is None:
logger.info("User "+request.POST['username']+" kann Passwort nicht ändern: Entweder exitiert der Benutzer nicht oder das alte Passwort ist falsch")
messages.error(request, 'Fehler: Deine Zugangsdaten sind falsch. Entweder exitiert der Benutzer nicht oder das alte Passwort ist falsch.')
return render(request, template, d)
else: user = request.user
Utils.change_password(request, user, request.POST['new_password'], request.POST['repeat_new_password'])
return render(request, template, d)
def change_user_password(request, user_id, template='user/change_user_password.html'):
d = {}
d['form'] = ChangePasswordForm()
d['sso_links'] = sso_links
d['ignore_sso_link'] = 'change_password'
d['user_id'] = user_id;
d['theuser'] = other_user = User.objects.get(id=user_id)
print("theotheruser")
print(other_user)
print(user_id)
if request.method == 'POST':
ou_dep = other_user.participant.department
u_dep = request.user.participant.department
if ( request.user.is_staff and ((ou_dep is None) or (u_dep == ou_dep)) or request.user.is_superuser) :
Utils.change_password(request, other_user, request.POST['new_password'], request.POST['repeat_new_password'])
else:
messages.error("keine Berechtigung")
return redirect('user/'+other_user_id)
return render(request, template, d)
def import_users(request):
client = Utils.getDiscourseClient()
usersDict = client.users()
for userDict in usersDict:
userObj, created = User.objects.get_or_create(
username=userDict['username'])
print(userDict)
#print(created)
if 'suspended_at' in userDict:
userObj.is_active = False
userObj.save()
if created:
# wenn der benutzer per login erzeugt wurde muss er hier aktualisiert werden
userDetails = client.user_all(user_id=userDict['id'])
ssoDetails = userDetails['single_sign_on_record']
if ssoDetails != None:
print(ssoDetails['external_email'])
userObj.email = ssoDetails['external_email']
for key in userDict:
if key != "id":
setattr(userObj, key, userDict[key])
if not userDetails['active']:
userObj.is_active = False
userObj.save()
else:
None
#TODO overwrite Userdata in Discourse
#print("TODO")
try:
p = userObj.participant
except:
p = Participant(user=userObj)
p.discourse_user = discourse_user = userDict['id']
p.save()
print(userDict)
print("-")
print(userObj.__dict__)
print("-")
return JsonResponse()
def group_delete(request, id):
item = dGroup.objects.get(pk=id)
if item.members.count() < 2 or request.user.is_superuser:
client = Utils.getDiscourseClient()
try:
groupDict = client.delete_group(item.discourse_group_id)
except:
messages.error(request, item.name)
messages.error(
request,
' Discourse Fehler: Die Gruppe kann nicht gelöscht werden. ')
messages.error(request, sys.exc_info()[1])
print("Error:", sys.exc_info()[0])
else:
item.delete()
return redirect('group-list')
def fix_users_email(request):
users = User.objects.all().filter(email="")
for user in users:
print(user.username)
client = Utils.getDiscourseClient()
try:
dUser = client.user(username=user.username)
except:
print("Der Benutzer " + user.username +
" scheint nicht sinvoll mit discourse verknüpft zu sein")
else:
emails = client.user_emails(user.username)
user.email = emails['email']
print(emails['email'])
user.save()
return JsonResponse()
def group_create(request, template='group/create.html'):
#TODO: ersteller ist automatisch groupadmin ?
d = {}
d['form'] = GroupForm()
#print("group_create")
if request.method == 'POST':
form = GroupForm(request.POST)
if form.is_valid():
item = form.save()
#print(item.__dict__)
client = Utils.getDiscourseClient()
try:
groupDict = client.create_group(name=item.name)
except:
item.delete()
messages.error(
request,
'Discourse Fehler: Der Gruppenname entspricht nicht den Anforderungen. '
)
messages.error(request, sys.exc_info()[1])
print("Error:", sys.exc_info()[0])
else:
item.discourse_group_id = groupDict['basic_group']['id']
item.save()
ug, create = User_Groups.objects.get_or_create(
user_id=request.user.id, group_id=item.id)
ug.rights = 1
try:
client.add_user_to_group(
ug.group.discourse_group_id,
ug.user.participant.discourse_user)
except:
ug.delete()
messages.error(
request,
'Das hat nicht geklappt: Benutzer kann nicht zu dieser Gruppe hinzugefügt werden'
)
print(groupDict)
return redirect('group-list')
else:
d['form'] = form
messages.error(request,
'Es ist eine Fehler im Formular aufgetreten ')
return render(request, template, d)
def delete_user_from_group(request, user_id, group_id):
if (User_Groups.isGroupAdmin(
user_id=request.user.id,
group_id=group_id)) or request.user.is_superuser:
ug = User_Groups.objects.get(user_id=user_id, group_id=group_id)
client = Utils.getDiscourseClient()
try:
client.delete_group_member(ug.group.discourse_group_id,
ug.user.participant.discourse_user)
except Exception as err:
messages.error(
request,
safestring.mark_safe(
'Benutzer kann nicht von dieser Gruppe gelöscht werden. Grund: <br/> '
+ format(err)))
else:
ug.delete()
return redirect('user-details', id=user_id)
def add_user_to_group(request, user_id, group_id):
if (User_Groups.isGroupAdmin(
user_id=request.user.id,
group_id=group_id)) or request.user.is_superuser:
#messages.error(request, 'Alles okay')
ug, create = User_Groups.objects.get_or_create(user_id=user_id,
group_id=group_id)
client = Utils.getDiscourseClient()
try:
client.add_user_to_group(ug.group.discourse_group_id,
ug.user.participant.discourse_user)
except Exception as err:
ug.delete()
messages.error(
request,
safestring.mark_safe(
'Benutzer kann nicht zu dieser Gruppe hinzugefügt werden. Grund: <br> '
+ format(err)))
return redirect('user-details', id=user_id)
def deactivate_user(request, user_id, info=None):
#TODO: check authorisation ? Nö darf jede aus dem Staff
user = User.objects.get(id=user_id)
user.is_active = False
user.save()
try:
client = Utils.getDiscourseClient()
p = user.participant
dUser = client.user_all(user_id=p.discourse_user)
except:
messages.error(request, "Der Benutzer "+user.username+" scheint nicht sinvoll mit discourse verknüpft zu sein, ist jetzt nur im backend deaktiviert")
print ("Der Benutzer "+user.username+" scheint nicht sinvoll mit discourse verknüpft zu sein")
else:
try: client.deactivate(dUser['id'])
except: print("scheinbar nicht aktiviert")
try:
if info is None : info = "Gesperrt von user "+request.user.username
client.suspend(dUser['id'],365000,info)
except: print("scheinbar bereits gesperrt")
return redirect('user-list')
def user_details(request, id, template='user/details.html'):
d = {}
user = item = get_object_or_404(User, pk=id)
d['user_groups'] = item.dgroup_set.all()
d['admin_groups'] = dGroup.objects.all().filter(user_groups__rights=1, user_groups__user_id=request.user.id).exclude(id__in=d['user_groups'])
if request.user.is_superuser :
d['all_groups'] = dGroup.objects.all()
else:
d['all_groups'] = False
d['form'] = HasDiscoGroups()
if request.method == 'POST':
print(request.POST)
form = HasDiscoGroups(request.POST, instance=item)
print(serializers.serialize('json', [ item, ]))
if form.is_valid():
print(form.cleaned_data)
item = form.save()
#form.save_m2m()
return JsonResponse(data={'form': UserForm(instance=item).as_p(), 'token': get_token(request)})
else:
d['form'] = form
return JsonResponse(data={'form': d['form'].as_p(), 'token': get_token(request)}, success=False)
d['other_user'] = User.objects.get(pk=id)
# check connection to discourse
client = Utils.getDiscourseClient()
try:
p = user.participant
dUserDetails = client.user_all(user_id=p.discourse_user)
except:
d['dUser_exists'] = False
else:
d['dUser_exists'] = True
return render(request, template, d)
def testisvaliduser(request, template='user/tivu.html'):
print("testisvaliduser")
d = {}
d['form'] = LoginForm()
if request.method == 'POST':
print(request.POST['username'])
try:
password_validation.validate_password(request.POST['password'])
except ValidationError as errs:
messages.error(
request,
'Das hat nicht geklappt: Folgende Fehler sind aufgetreten:')
for err in errs:
messages.error(request, err)
print(err)
else:
print("has a good password")
print("and is a validPhpUser :"******"_______")
return render(request, template, d)
def import_dgroup(request, groupname, da_group_id):
limit = request.GET.get("limit") if request.GET.get("limit") else 1000
offset = request.GET.get("offset") if request.GET.get("offset") else 0
client = Utils.getDiscourseClient()
Utils.import_dgroup_members(groupname, da_group_id, limit, offset)
return JsonResponse()
def discourse_sso(request, template='user/sso_login.html'):
#print("discourse_sso")
d = {}
d['sso_links'] = sso_links
if hasattr(settings, 'FORCE_DISCOURSE_ADMIN_URL'):
d['force_url'] = settings.FORCE_DISCOURSE_ADMIN_URL
else:
d['force_url'] = False
#sso und sig per get oder post auslesen
d["sso"] = payload = request.GET.get('sso')
#if d["sso"] == None : d["sso"] = payload = request.POST['sso']
d["sig"] = signature = request.GET.get('sig')
#if d["sig"] == None : d["sig"] = signature = request.POST['sig']
#wenn kein sso vorhanden zurück zum sso client leiten
if d["sso"] == None:
return redirect(settings.DISCOURSE_BASE_URL)
d['form'] = LoginForm()
if request.method == 'POST':
#print("post anfrage")
#print(request.POST['username'])
user = authenticate(request,
username=request.POST['username'],
password=request.POST['password'])
# checken ob stattdessen ein Php Benutzer besteht
if hasattr(settings, 'PHP_LOGIN_CHECK_URI'):
if User.objects.filter(username=request.POST['username']).exists():
the_user = User.objects.get(username=request.POST['username'])
last_login = the_user.last_login
else:
last_login = None
if last_login is None: #nur einmal migrieren
if user is None:
logger.info("User " + request.POST['username'] +
" is not authenticated by python try php")
if Utils.isValidPhpUser(username=request.POST['username'],
password=request.POST['password']):
user = Utils.migrateUser(
username=request.POST['username'],
password=request.POST['password'])
# wenn Benutzer valide sso validierung mit gruppen ausliefern
if user is not None:
#print("User ist vorhanden")
user.last_login = datetime.datetime.now()
user.save()
Utils.watchImportantTopic(request, user.username)
#print(user.__dict__)
#groups = user.dgroup_set.all()
#groupstr = ', '.join(map(str, list(groups)))
# if hasattr(settings, 'DISCOURSE_INTERN_SSO_EMAIL') :
# user.email = '%s@%s' % (user.id, settings.DISCOURSE_INTERN_SSO_EMAIL)
#print(user.__dict__)
nonce = sso.sso_validate(payload, signature,
settings.DISCOURSE_SSO_KEY)
url = sso.sso_redirect_url(
nonce, settings.DISCOURSE_SSO_KEY, user.email,
user.participant.id,
user.username) #, add_groups=groupstr, groups=groupstr)
return redirect(settings.DISCOURSE_BASE_URL + url)
else:
messages.error(
request,
'Das hat nicht geklappt: Benutzername oder Passwort ist falsch oder dein Account ist nicht freigeschaltet.'
)
else:
print("get anfrage")
return render(request, template, d)