def new_issue(request):
logger_info.info(info_load_log_message(request))
form = IssueForm(request.POST)
context = {}
if request.POST:
if form.is_valid():
create = Issue(
Autor=request.user,
Title=form.cleaned_data['Title'],
UserRequest=form.cleaned_data['UserRequest'],
).save()
if create is None:
issue = Issue.objects.filter(
Title=form.cleaned_data['Title']
).filter(
Autor=request.user
).filter(
UserRequest=form.cleaned_data['UserRequest']
)[0]
return redirect(
reverse(
'view_issue',
kwargs={
'issue': issue.slug,
}
),
permanent=True
)
else:
context['error'] = _('save_error')
context['form'] = form
return render(request, 'issues/send_issue.html', context)
def reopen_issue(request, issue):
try:
issue = Issue.objects.filter(slug=issue)[0]
if request.user == issue.Autor or request.user.is_staff or request.user.is_superuser:
logger_info.info(info_load_log_message(request))
if issue.Status == 'close':
issue.update(
Status="open",
)
return redirect(
reverse(
'view_issue',
kwargs={
'issue': issue.slug,
}
),
permanent=True
)
else:
return redirect(
reverse('list_issue'),
permanent=True
)
except:
return redirect(
reverse('list_issue'),
permanent=True
)
def display_topic(request, cat, topic):
"""display category's topic list
:param request: object contain context of request
:type request: object
:param cat: slug of categorie
:type cat: slug
:param topic: slug of topic
:type topic: slug
:var cat: get the the selected category
:var thr: get the first message of the topic
:var post: get lit of related post of thr
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
try:
cat = models.ForumCat.objects.filter(slug=cat)[0]
try:
thr = models.ForumTopic.objects.get(slug=topic)
post = models.ForumPost.objects.filter(TopicParent=thr)
return render(request, "forum/topic.html", {"cat": cat, "topic": thr, "posts": post, "reply": PostForm()})
except:
return display_cat(request, cat)
except:
return display_all(request)
def reply_topic(request, cat, topic):
"""save new reply
:param request: object contain context of request
:type request: object
:param cat: slug of categorie
:type cat: slug
:var topic: topic slug
:type topic: slug
:var form: form for topic reply
:var top: get the new topic
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
form = PostForm(request.POST)
top = models.ForumTopic.objects.get(slug=topic)
if form.is_valid():
models.ForumPost(TopicParent=top, Autor=request.user, Message=form.cleaned_data["Message"]).save()
models.ForumTopic.objects.filter(slug=topic).update(LastReply=timezone.now())
return redirect(request.META["HTTP_REFERER"], permanent=True)
else:
if top.CatParent:
return redirect(reverse("topic_cat", kwargs={"cat": cat.slug, "topic": topic.slug}), permanent=True)
else:
return display_all(request)
def edit_topic(request, cat, topic):
"""display process for edit topic
:param request: object contain context of request
:type request: object
:param cat: slug of categorie
:type cat: slug
:param topic: slug of topic
:type topic: slug
:var cat: select category by slug
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
try:
cat = models.ForumCat.objects.get(slug=cat)
wrong_cat = 0
except:
wrong_cat = 1
try:
models.ForumTopic.objects.get(slug=topic)
wrong_topic = 0
except:
wrong_topic = 1
if not wrong_cat and not wrong_topic and request.method == "POST":
form = TopicForm(request.POST)
if form.is_valid():
update = models.ForumTopic.objects.filter(slug=topic).update(
Title=form.cleaned_data["Title"],
Autor=request.user,
slug=slugify(form.cleaned_data["Title"]),
Message=form.cleaned_data["Message"],
LastModified=timezone.now(),
)
if update is not None:
topic = (
models.ForumTopic.objects.filter(Title=form.cleaned_data["Title"])
.filter(Autor=request.user)
.filter(Message=form.cleaned_data["Message"])
)
return redirect(reverse("topic_cat", kwargs={"cat": cat.slug, "topic": topic[0].slug}), permanent=True)
else:
context = {"cat": cat, "error": _("thread_fail"), "form": form}
else:
top = models.ForumTopic.objects.get(slug=topic)
form = TopicForm({"Title": top.Title, "Message": top.Message})
context = {"cat": cat, "form": form}
elif wrong_cat and wrong_topic:
return redirect(reverse("forum"), permanent=True)
elif wrong_cat:
top = models.ForumTopic.objects.get(slug=topic)
return redirect(reverse("edit_topic", kwargs={"cat": top.CatParent.slug, "topic": top.slug}), permanent=True)
elif wrong_topic:
return redirect(reverse("cat", kwargs={"cat": cat}), permanent=True)
else:
top = models.ForumTopic.objects.get(slug=topic)
topic = {"Title": top.Title, "Message": top.Message}
form = TopicForm(topic)
context = {"cat": cat, "form": form, "edit": 1}
return render(request, "forum/create_topic.html", context)
def display_all(request):
"""display forum's category
:param request: object contain context of request
:type request: object
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
return render(request, "forum/home.html", {"cat": models.ForumCat.objects.all().order_by("Name")})
def ldap_display(request, order, letter):
logger_info.info(l_fct.info_load_log_message(request))
errors = []
alphabet = string.ascii_lowercase
if letter != 'all' and letter not in alphabet:
l = 'a'
elif letter == 'all':
l = ''
else:
l = letter
c = connect_to_ldap(request.session)
if c.bind():
logger_info.info(l_fct.info_login_ldap_log_message(request))
c.search(
search_base='ou=paris,ou=people,dc=42,dc=fr',
search_filter='(uid={}*)'.format(l),
search_scope=ldap3.SUBTREE,
attributes=[
'uid',
'givenName',
'jpegPhoto',
'mobile',
'sn',
]
)
annuaire = []
for r in c.response:
annuaire.append(
{
'avatar': base64.b64encode(r['attributes']['jpegPhoto'][0]) if 'jpegPhoto' in r[
'attributes'] else '',
'uid': r['attributes']['uid'][0],
'givenName': r['attributes']['givenName'][0],
'mobile': r['attributes']['mobile'][0] if 'mobile' in r['attributes'] else '',
'sn': r['attributes']['sn'][0],
}
)
c.unbind()
annuaire.sort(
key=itemgetter('uid'), reverse=True if order == 'reverse' else False)
else:
logger_error.info(l_fct.error_ldap_log_message(request, "bind"))
errors['unknow'] = _("bind_error")
return render(
request,
"ldap42/ldap_display.html",
{
'alphabet': alphabet,
'annuaire': annuaire,
'form': LdapForm(),
'letter': letter,
'order': order,
}
)
def index(request):
"""display the issues about the user connected
:param request: object contain context of request
:type request: object
:var issues: contain issues to display
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
if request.user.is_superuser or request.user.is_staff:
issues = Issue.objects.all()
else:
issues = Issue.objects.filter(Autor=request.user)
return render(request, 'issues/home.html', {'issues': issues})
def display(request):
"""display contact form
:param request: object contain context of request
:type request: object
:var errors: dict of process error
:var success: dict of success process
:var dump: dump to request.POST for set email whaen user log
:var form: contain struct of contact form
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
errors = {}
success = {}
if request.method == 'POST':
dump = request.POST.copy()
if 'email' not in dump:
dump.appendlist('email', request.user.email)
form = ContactForm(dump)
if form.is_valid():
try:
admins = []
for admin in settings.ADMINS:
admins.append(admin[1])
send_mail(
form.cleaned_data['subject'],
form.cleaned_data['message'],
form.cleaned_data['email'],
admins
)
success['message'] = _('contact_success')
logger_info.info(_("contact_success") + request.user.username)
except:
errors['message'] = _('contact_fail')
logger_error.error(_("contact_fail") + request.user.username)
else:
if not request.POST['subject']:
errors['subject'] = _('contact_must_contain_subject')
if not request.POST['message']:
errors['message'] = _('contact_must_contain_message')
if not request.user.is_authenticated() and not request.POST['email']:
errors['email'] = _('contact_must_contain_email')
return render(
request,
'contact/contact.html', {
'formcontact': ContactForm(request.POST),
'errors': errors,
'success': success
}
)
def index(request):
"""display select logs
:param request: object contain context of request
:type request: object
:return: HTTPResponse
"""
if not request.user.is_superuser:
return redirect(request.META['HTTP_REFERER'] if 'HTTP_REFERER' in request.META else reverse('home'))
else:
logger_info.info(info_load_log_message(request))
return render(
request,
'logs/index.html', {
'type_log': [k for k, v in settings.LOGGING['handlers'].items() if k is not 'console'],
}
)
def create_topic(request, cat):
"""create new topic
:param request: object contain context of request
:type request: object
:param cat: slug of categorie
:type cat: slug
:var cat: categorie object selected by slug
:var form: form for create topic
:var errors: dict of process error
:var create: new topic
:var topic: get the new topic
:var context: define the context for display page
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
cat = models.ForumCat.objects.get(slug=cat)
form = TopicForm(request.POST)
error = {}
if request.method == "POST":
if form.is_valid():
try:
create = models.ForumTopic(
CatParent=cat,
Title=form.cleaned_data["Title"],
Autor=request.user,
Message=form.cleaned_data["Message"],
).save()
if create is None:
topic = (
models.ForumTopic.objects.filter(Title=form.cleaned_data["Title"])
.filter(Autor=request.user)
.filter(Message=form.cleaned_data["Message"])[0]
)
return redirect(reverse("topic_cat", kwargs={"cat": cat.slug, "topic": topic.slug}), permanent=True)
except:
logger_error.error(_("save_topic"))
error["save_topic"] = _("topic_fail")
else:
if not request.POST["Title"]:
error["no_title"] = _("topic_must_contain_title")
if not request.POST["Message"]:
error["no_title"] = _("topic_must_contain_message")
context = {"cat": cat, "form": form, "error": error}
return render(request, "forum/create_topic.html", context)
def display_cat(request, cat):
"""display category's topic list
:param request: object contain context of request
:type request: object
:param cat: slug of categorie
:type cat: slug
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
try:
cat = models.ForumCat.objects.get(slug=cat)
last_mod = (
models.ForumTopic.objects.filter(CatParent=cat).order_by("LastReply").order_by("CreateDate").reverse()
)
return render(request, "forum/cat.html", {"cat": cat, "last_mod": last_mod})
except:
return display_all(request)
def view_issue(request, issue):
try:
issue = Issue.objects.get(slug=issue)
if request.user == issue.Autor or request.user.is_staff or request.user.is_superuser:
logger_info.info(info_load_log_message(request))
context = {
'issue': issue,
}
return render(request, 'issues/issue.html', context)
else:
return redirect(
reverse('list_issue'),
permanent=True
)
except:
return redirect(
reverse('list_issue'),
permanent=True
)
def edit_post(request, cat, topic, post):
"""display process for edit post
:param request: object contain context of request
:type request: object
:param cat: slug of categorie
:type cat: slug
:var topic: topic slug
:type topic: slug
:var errors: dict of process error
:var cat: select cat by slug
:var form: form for edit post
:var update: select post to update and update him
:var post_sel: get the post
:var context: define the context for display topic
:return: HTTPResponse
"""
error = {}
logger_info.info(info_load_log_message(request))
cat = models.ForumCat.objects.get(slug=cat)
if request.POST:
form = PostForm(request.POST)
if request.POST["Message"] is not None and form.is_valid():
try:
update = models.ForumPost.objects.filter(pk=post).update(
Message=form.cleaned_data["Message"], LastModified=timezone.now()
)
if update is not None:
return redirect(reverse("topic_cat", kwargs={"cat": cat.slug, "topic": topic}), permanent=True)
except:
return display_topic(request, cat, topic)
else:
post_sel = models.ForumPost.objects.get(pk=post)
error["Message"] = _("post_must_contain_message")
else:
post_sel = models.ForumPost.objects.get(pk=post)
return render(
request,
"forum/edit_post.html",
{"cat": cat, "topic": topic, "post": post, "error": error, "form": PostForm({"Message": post_sel.Message})},
)
def respond_issue(request, issue):
SelectIssue = Issue.objects.get(slug=issue)
if (request.user.is_staff or request.user.is_superuser) is True:
logger_info.info(info_load_log_message(request))
context = {}
if request.POST:
form = AdminResponseIssueForm(request.POST)
if form.is_valid():
Issue.objects.filter(
slug=issue
).update(
Assign=User.objects.get(username=form.cleaned_data['assign']),
Answer=form.cleaned_data['answer'],
Status=form.cleaned_data['status'],
LastActivity=datetime.datetime.now()
)
return redirect(
request.META['HTTP_REFERER'],
permanent=True
)
else:
context['error'] = _('update_error')
form = AdminResponseIssueForm(
{
'assign': SelectIssue.Assign,
'status': SelectIssue.Status,
'answer': SelectIssue.Answer,
}
)
context['form'] = form
context['issue'] = SelectIssue
return render(request, 'issues/issue_admin_response.html', context)
else:
return redirect(
reverse(
'view_issue', kwargs={
'issue': SelectIssue.slug
}
),
permanent=True
)
def login_ldap(request):
logger_info.info(l_fct.info_load_log_message(request))
if request.user.is_authenticated():
logger_error.error(l_fct.error_load_log_message(request))
return redirect(reverse('home'))
else:
errors = {}
form = LdapForm(request.POST)
if request.method == 'POST':
request.session['ldap_log'] = request.POST
c = connect_to_ldap(request.session)
if c.bind():
logger_info.info(l_fct.info_login_ldap_log_message(request))
c.search(
search_base='ou=people,dc=42,dc=fr',
search_filter='(uid={})'.format(request.POST['login']),
search_scope=ldap3.SUBTREE,
attributes=[
'uid',
'givenName',
'mobile',
'sn',
'alias'
]
)
u = User.objects.filter(
username=c.response[0]['attributes']['uid'][0])
if len(u) == 0:
create_user(
request,
c.response[0]['attributes']['uid'][0],
c.response[0]['attributes']['alias'][0],
request.POST['password'],
c.response[0]['attributes']['givenName'][0],
c.response[0]['attributes']['sn'][0],
)
else:
if not hashers.check_password(request.POST['password'], u[0].password):
u[0].set_password(request.POST['password'])
u[0].save()
user = authenticate(
username=request.POST['login'],
password=request.POST['password'],
)
if user is not None:
if user.is_active:
login(request, user)
userlang = UserLang.objects.get(user=request.user)
logger_info.info(
l_fct.info_login_class_log_message(request))
translation.activate(userlang.lang)
request.session[
translation.LANGUAGE_SESSION_KEY] = userlang.lang
redir = reverse('home')
if 'next' in request.GET and request.GET['next'] != reverse('login'):
redir = request.GET['next']
return redirect(
redir,
permanent=True
)
else:
logger_error.error(
l_fct.error_login_log_message(request))
errors['unknow'] = _("authenticate error")
else:
logger_error.error(
l_fct.error_login_wrong_password_log_message(request))
errors['pass'] = _("error_wrong_password")
c.unbind()
else:
logger_error.info(
l_fct.error_ldap_log_message(request, "bind"))
errors['unknow'] = _("bind_error")
else:
form = LdapForm()
return render(
request,
"ldap42/loginldap.html",
{
'form': form,
'errors': errors,
}
)
def display_log(request, log_type):
"""parse and display selected log
:param request: object contain context of request
:type request: object
!param log_tyoe: log type to display
:typer log_type: string
:return: HTTPResponse
"""
logger_info.info(info_load_log_message(request))
if not request.user.is_superuser:
return redirect(request.META['HTTP_REFERER'] if 'HTTP_REFERER' in request.META else reverse('home'))
else:
if log_type in settings.LOGGING['handlers'].keys() and log_type != 'console':
type_format = settings.LOGGING['handlers'][log_type]['formatter']
log = []
try:
file = open('logs/' + log_type + '.log')
for ligne in file:
split_ligne = ligne.split(' :: ')
if type_format == 'simple':
split_ligne[0] = split_ligne[0].replace(
'[', '').replace(']', '').split(' ')
split_ligne[1] = split_ligne[
1].replace('\n', '').split(' par ')
add = True
elif type_format == 'verbose':
try:
split_ligne[0] = split_ligne[0].replace(
'[', '').replace(']', '').split(' ')
split_ligne[1] = split_ligne[1].replace(
':', '.').replace('[', '').replace(']', '').split(' ')
split_ligne[2] = split_ligne[
2].replace('\n', '').split(' par ')
add = True
except:
add = False
elif type_format == 'complet':
try:
split_ligne[0] = split_ligne[
0].replace('[', '').replace(']', '')
split_ligne[1] = split_ligne[1].replace(
'[', '').replace(']', '').split(' ')
split_ligne[2] = split_ligne[2].replace(
':', '.').replace('[', '').replace(']', '').split(' ')
split_ligne[3] = split_ligne[
3].replace('\n', '').split(' par ')
split_ligne.append(split_ligne[2])
split_ligne[2] = split_ligne[3]
split_ligne[3] = split_ligne[4]
split_ligne.remove(split_ligne[4])
add = True
except:
add = False
if add:
log.append((len(split_ligne), split_ligne))
if len(log) > 1:
log.reverse()
except:
logger_error.error('error_load_log_{}'.format(log_type))
return render(
request,
'logs/display_log.html', {
'type_format': type_format,
'all_type_log': [k for k, v in settings.LOGGING['handlers'].items() if k is not 'console'],
'type_log': log_type,
'len': len(log),
'log': log,
}
)
else:
return redirect(reverse('list_logs'))
