kitoy/pywallter
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Ajout support serveur MAIL et XMPP

Browse Source
This commit is contained in:
kitoy
2022-08-06 18:22:24 +02:00
parent beb1e65ca7
commit d923a5eb97
44 changed files with 2177 additions and 701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
views/blog.py
View File

@@ -1,12 +1,28 @@
# -*- coding: utf-8 -*-
from flask import Blueprint, escape, render_template, session, redirect, url_for, request, flash, abort
from flask import Blueprint, escape, render_template, session, redirect, url_for, request, flash, abort, Flask
import time
import sqlite3
from markdown import markdown
postit = Blueprint('post-it', __name__, template_folder='templates')
app = Flask( 'pywallter' )
app.config.from_pyfile('config.py')
#### Variables ####################################################################################
DOSSIER_PERSO= app.config['DOSSIER_APP']
extensionimg = app.config['EXT_IMG']
DATABASE = app.config['DATABASE']
##################################################################################################
@postit.route('/post-it/', methods=['GET', 'POST'])
def racine_blog():
@@ -18,7 +34,7 @@ def racine_blog():
#category = request.form['category']
status = request.form['status']
TIME=time.strftime("%A %d %B %Y %H:%M:%S")
conn = sqlite3.connect('base.db') # Connexion la base de donne
conn = sqlite3.connect(DATABASE) # Connexion la base de donne
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""INSERT INTO posts(title, content, time, author, status) VALUES(?, ?, ?, ?, ?)""",
(title, content, TIME, UTILISATEUR, status)) # Insérer des valeurs
@@ -30,7 +46,7 @@ def racine_blog():
conn.close()
return render_template('blog.html', posts=posts)
else:
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT title, content, time, author, status, avatar, nom, prenom, age FROM posts INNER JOIN users ON author = name""")
posts = [dict(title=row[0], content=row[1], time=row[2], author=row[3],
@@ -39,21 +55,21 @@ def racine_blog():
conn.close()
return render_template('blog.html', section='Post-it', posts=posts)
else:
return redirect(url_for('loginlogout.login', _external=True))
return redirect(url_for('loginlogout.login', _external=True), code=401)
@postit.route('/delete/<post>')
def delete(post):
if 'username' in session :
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""DELETE FROM posts WHERE title=?""", (post,))
conn.commit()
conn.close()
return redirect(url_for('post-it.racine_blog'))
else:
return redirect(url_for('loginlogout.login', _external=True)) # sinon on redirige vers login
return redirect(url_for('loginlogout.login', _external=True), code=401) # sinon on redirige vers login
@postit.route('/edit/<post>', methods=['GET', 'POST'])
def edit(post):
@@ -62,7 +78,7 @@ def edit(post):
newtitle = request.form['title']
newcontent = markdown(request.form['content'])
newstatus = request.form['status']
conn = sqlite3.connect('base.db')
conn = sqlite3.connect(DATABASE)
cursor = conn.cursor()
cursor.execute("""UPDATE posts SET title=?, content=?, status=? WHERE title=?""",
(newtitle, newcontent, newstatus, post,))
@@ -70,13 +86,28 @@ def edit(post):
conn.close()
return redirect(url_for('post-it.racine_blog'))
else:
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT title, content FROM posts WHERE title=?""", (post,))
oldpost = (cursor.fetchone())
oldpost = cursor.fetchone()
conn.close()
return render_template('postedit.html',
section='Post-it',
oldpost=oldpost)
else:
return redirect(url_for('loginlogout.login', _external=True)) # sinon on redirige vers login)
return redirect(url_for('loginlogout.login', _external=True), code=401) # sinon on redirige vers login)
@postit.route('/postit/board', methods=['GET'])
def viewsheet():
if 'username' in session:
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT title, content, time, author, status, avatar, nom, prenom, age FROM posts INNER JOIN users ON author = name""")
posts = [dict(title=row[0], content=row[1], time=row[2], author=row[3],
status=row[4], avatar=row[5], nom=row[6], prenom=row[7], age=row[8])
for row in reversed(cursor.fetchall())]
conn.close()
return render_template('board.html', section='Post-it', posts=posts)
else:
return redirect(url_for('loginlogout.login', _external=True), code=401)

46
views/filesupload.py
View File

@@ -1,6 +1,6 @@
# -*- coding: utf-8 -*-
from flask import Blueprint, Flask, request, flash, render_template, url_for, session, redirect, abort, make_response, send_file, escape, flash, abort
from flask import Blueprint, Flask, request, flash, render_template, url_for, session, redirect, abort, make_response, escape, flash, abort, send_file, escape, send_from_directory
from werkzeug.utils import secure_filename
from PIL import Image
import time
@@ -8,15 +8,21 @@ import sqlite3
import os
filesupload = Blueprint('filesupload', __name__, template_folder='templates')
app = Flask( 'pywallter' )
app.config.from_pyfile('config.py')
filesupload = Blueprint('filesupload', __name__, template_folder='templates')
#### Variables ####################################################################################
DOSSIER_PERSO= app.config['DOSSIER_APP']
extensionimg = app.config['EXT_IMG']
DATABASE = app.config['DATABASE']
##################################################################################################
@filesupload.route( '/filesupload/', methods=['GET', 'POST'])
def uploadfiles():
if 'username' in session :
@@ -44,7 +50,8 @@ def uploadfiles():
TIME=time.strftime("%A %d %B %Y %H:%M:%S")
IP=request.environ['REMOTE_ADDR']
CLIENT_PLATFORM=request.headers.get('User-Agent')
LOG=open("log.txt", "a")
log_file=os.path.join(DOSSIER_PERSO, UTILISATEUR, "log.txt")
LOG=open(log_file, "a")
LOG.write (TIME + ' - ' + IP + ' - ' + UTILISATEUR + ' - ' + CLIENT_PLATFORM + '\n' + '---> ' + nom + '\n')
LOG.close()
flash(u'Image envoyée et traitée avec succés', 'succes')
@@ -74,7 +81,7 @@ def uploadfiles():
resp.set_cookie('username', session['username'])
return resp
else :
return redirect(url_for('loginlogout.login', _external=True))
return redirect(url_for('loginlogout.login', _external=True), code=401)
@filesupload.route('/view/')
@@ -98,4 +105,33 @@ def list():
flash(u'Aucun fichier uploadé ! Redirection vers Upload', 'error')
return redirect(url_for('filesupload.uploadfiles', external=True))
else :
return redirect(url_for('loginlogout.login', _external=True))
return redirect(url_for('loginlogout.login', _external=True), code=401)
@filesupload.route('/myfiles/<filename>')
def myfiles(filename):
if 'username' in session :
UTILISATEUR='%s' % escape(session['username'])
return send_from_directory(
os.path.join(DOSSIER_PERSO, UTILISATEUR, 'files'), filename )
else :
return redirect(url_for('loginlogout.login'), code=401)
@filesupload.route('/remove/<nom>')
def remove(nom):
if 'username' in session :
UTILISATEUR='%s' % escape(session['username'])
nom = secure_filename(nom)
if os.path.isfile(DOSSIER_PERSO + UTILISATEUR + '/files/' + nom): # si le fichier existe
os.remove(DOSSIER_PERSO + UTILISATEUR + '/files/' + nom) # on le supprime
return redirect(url_for('filesupload.list', _external=True))
else:
if os.path.isfile(DOSSIER_PERSO + UTILISATEUR + '/images/thumbnails/' + nom): # si le fichier existe
os.remove(DOSSIER_PERSO + UTILISATEUR + '/images/thumbnails/' + nom) # on le supprime
os.remove(DOSSIER_PERSO + UTILISATEUR + '/images/' + nom) # on le supprime
return redirect(url_for('gallery'))
else:
flash(u'Fichier {nom} inexistant.'.format(nom=nom), 'error')
return redirect(url_for('filesupload.list', _external=True)) # sinon on redirige vers la liste, avec un message d'erreur
else :
return redirect(url_for('loginlogout.login'), code=401)

55
views/gallery.py Normal file
View File

@@ -0,0 +1,55 @@
# -*- coding: utf-8 -*-
from flask import Blueprint, Flask, request, flash, render_template, url_for, session, redirect, abort, make_response, send_file, escape, flash, abort, send_file, send_from_directory
from werkzeug.utils import secure_filename
from PIL import Image
import time
import sqlite3
import os
mygallery = Blueprint('mygallery', __name__, template_folder='templates')
app = Flask( 'pywallter' )
app.config.from_pyfile('config.py')
#### Variables ####################################################################################
DOSSIER_PERSO= app.config['DOSSIER_APP']
extensionimg = app.config['EXT_IMG']
DATABASE = app.config['DATABASE']
##################################################################################################
@mygallery.route( '/gallery/')
def gallery():
if 'username' in session :
UTILISATEUR='%s' % escape(session['username'])
THUMBNAILS=DOSSIER_PERSO + UTILISATEUR + '/images/thumbnails/'
fichiers = [fich for fich in os.listdir(THUMBNAILS)]
return render_template('gallery.html',
section='Gallery',
THUMBNAILS=THUMBNAILS,
fichiers=fichiers)
else :
return redirect(url_for('loginlogout.login'), code=401)
@mygallery.route('/myfiles/images/<filename>')
def myimg(filename):
if 'username' in session :
UTILISATEUR='%s' % escape(session['username'])
return send_from_directory(
os.path.join(DOSSIER_PERSO, UTILISATEUR, 'images'), filename )
else :
return redirect(url_for('loginlogout.login'), code=401)
@mygallery.route('/myfiles/images/thumbnails/<filename>')
def mythumbnails(filename):
if 'username' in session :
UTILISATEUR='%s' % escape(session['username'])
return send_from_directory(
os.path.join(DOSSIER_PERSO, UTILISATEUR, 'images/thumbnails'), filename )
else :
return redirect(url_for('loginlogout.login'), code=401)

153
views/inscription.py
View File

@@ -2,71 +2,118 @@ from flask import Blueprint, Flask, request, flash, render_template, url_for, se
from flask_bcrypt import Bcrypt
import sqlite3
import glob, os, sys, time
from tools.utils import email_disp, valid_token_register
from socket import gethostname
app = Flask( 'pywallter' )
app.config.from_pyfile('config.py')
bcrypt = Bcrypt(app)
#### Variables ####################################################################################
#### Variables ##################################################################################
DOSSIER_PERSO= app.config['DOSSIER_APP']
extensionimg = app.config['EXT_IMG']
##################################################################################################
DATABASE = app.config['DATABASE']
MAIL_SERVER = app.config['MAIL_SERVER']
XMMP_SERVER = app.config['XMPP_SERVER']
SETUID = app.config['SETUID']
#################################################################################################
inscription = Blueprint('inscription', __name__, template_folder='templates')
@inscription.route( '/inscription/', methods=['GET','POST'] )
def signin() :
if 'username' in session :
return redirect(url_for('filesupload'))
else :
if request.method == 'POST' :
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
user = request.form['user']
mail = request.form['mail']
passwd = bcrypt.generate_password_hash(request.form['passwd'])
passwdconfirm = request.form['passwdconfirm']
cursor.execute("""SELECT name FROM users WHERE name=?""", (user,))
testuser=cursor.fetchone()
cursor.execute("""SELECT mail FROM users WHERE mail=?""", (mail,))
testmail=cursor.fetchone()
conn.close()
if testuser or testmail:
flash(u'Non d\'utilisateur ou email déjà utilisé, merci d\'en choisir un autre', 'error')
return render_template('inscription.html')
else:
confirmation = bcrypt.check_password_hash(passwd, passwdconfirm)
if confirmation is True:
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""INSERT INTO users(name, mail, passwd) VALUES(?, ?, ?)""", (user, mail, passwd)) # Insérer des valeurs
conn.commit() # Sauvegarder valeurs dans la bdd
cursor.execute("""SELECT name, mail, passwd FROM users""")
users = cursor.fetchall()
for i in users:
i = print('{0} - {1} - {2}'.format(i[0], i[1], i[2]))
conn.close()
userracine = DOSSIER_PERSO + user
userfiles = userracine + '/files'
userimages = userracine + '/images'
userthumbnails = userracine + '/images/thumbnails'
userprofile = userracine + '/profile'
if not os.path.exists(userracine):
os.makedirs(userracine)
os.makedirs(userfiles)
os.makedirs(userimages)
os.makedirs(userthumbnails)
os.makedirs(userprofile)
flash(u'Inscription réalisée avec succés !', 'succes')
return render_template('login.html')
else:
flash(u'Les mots de passe ne sont pas identiques !', 'error')
return render_template('inscription.html')
@inscription.route( '/inscription/<token>', methods=['GET','POST'] )
def signin(token) :
hostname = gethostname()
if app.config['SIGNIN_ENABLE'] and valid_token_register(token):
if 'username' in session :
resp = redirect(url_for('profil.profile', _external=True))
else :
return render_template('inscription.html')
if request.method == 'POST':
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
user = request.form['user']
mail = request.form['mail']+'@'+hostname
passwd = bcrypt.generate_password_hash(request.form['passwd'])
passwdconfirm = request.form['passwdconfirm']
cursor.execute("""SELECT name FROM users WHERE name=?""", (user,))
testuser = cursor.fetchone()
conn.close()
if MAIL_SERVER:
p = run( [ SETUID, 'set_mail_passwd', "'"+mailbox['Mail']+"'", "'"+passwd+"'" ] )
if testuser:
flash(u'Non d\'utilisateur déjà utilisé, merci d\'en choisir un autre', 'error')
resp = render_template('inscription.html',
signin_enable=app.config['SIGNIN_ENABLE'],
hostname=hostname)
elif not(email_disp(mail)) or p.returncode != 0 :
flash(u'Adresse email déjà utilisé, merci d\'en choisir un autre', 'error')
resp = render_template('inscription.html',
signin_enable=app.config['SIGNIN_ENABLE'],
hostname=hostname)
else:
confirmation = bcrypt.check_password_hash(passwd, passwdconfirm)
if confirmation is True:
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""INSERT INTO users(name, mail, passwd) VALUES(?, ?, ?)""", (user, mail, passwd)) # Insérer des valeurs
conn.commit() # Sauvegarder valeurs dans la bdd
if XMMP_SERVER:
tmp = mailbox['mail'].split('@')
p = run( [ SETUID, 'prosodyctl register ', "'"+tmp[0]+"'",
"'"+tmp[1]+"'", "'"+passwd+"'" ])
if p.returncode != 0:
flash(u'Il y a eu un problème lors de la création du compte XMPP !', 'error')
cursor.execute("""SELECT name, mail, passwd FROM users""")
users = cursor.fetchall()
for i in users:
i = print('{0} - {1} - {2}'.format(i[0], i[1], i[2]))
conn.close()
userracine = DOSSIER_PERSO + user
userfiles = userracine + '/files'
userimages = userracine + '/images'
userthumbnails = userracine + '/images/thumbnails'
userprofile = userracine + '/profile'
if not os.path.exists(userracine):
os.makedirs(userracine)
os.makedirs(userfiles)
os.makedirs(userimages)
os.makedirs(userthumbnails)
os.makedirs(userprofile)
fp = open('log.txt', 'x')
fp.close()
# Une fois que tout c'est bien passé pour l'inscription on détruit le jeton.
cursor.execute("""SELECT name, invitations FROM users where Token=?""", (token,))
tmp = cursor.fetchone()
username =tmp[0]
invitations_count=tmp[1] - 1
cursor.execute("""UPDATE users set invitations=?, Token='' where name=?""", (invitations_count, username,))
conn.commit()
flash(u'Inscription réalisée avec succés !', 'succes')
resp = redirect(url_for('loginlogout.login', _external=True))
else:
flash(u'Les mots de passe ne sont pas identiques !', 'error')
resp = render_template('inscription.html',
signin_enable=app.config['SIGNIN_ENABLE'],
hostname=hostname)
else :
resp = render_template('inscription.html',
signin_enable=app.config['SIGNIN_ENABLE'],
token=token, hostname=hostname, base_url=request.base_url)
else:
resp = redirect(url_for('index', _external=True), code=401)
return resp

34
views/loginlogout.py
View File

@@ -3,17 +3,30 @@ import sqlite3
from flask_bcrypt import Bcrypt
app = Flask( 'pywallter' )
app.config.from_pyfile('config.py')
bcrypt = Bcrypt(app)
#### Variables ####################################################################################
bcrypt = Bcrypt(app)
DOSSIER_PERSO= app.config['DOSSIER_APP']
extensionimg = app.config['EXT_IMG']
DATABASE = app.config['DATABASE']
##################################################################################################
loginlogout = Blueprint('loginlogout', __name__, template_folder='templates')
@loginlogout.route( '/login/', methods=['GET','POST'] )
def login() :
if 'username' in session :
return redirect(url_for('filesupload.uploadfiles', _external=True))
resp = redirect(url_for('filesupload.uploadfiles', _external=True))
else :
resp = redirect(url_for('loginlogout.login', _external=True))
if request.method == 'POST' :
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT name, passwd FROM users""")
users = cursor.fetchall()
@@ -25,12 +38,21 @@ def login() :
print ( passwd[2:(len(passwd)-1 )] )
if user[0] == request.form['user'] and bcrypt.check_password_hash(user[1], password) is True:
session['username'] = request.form['user']
return redirect(url_for('profil.profile', _external=True))
return redirect(url_for('loginlogout.login', _external=True))
resp = redirect(url_for('profil.profile', _external=True))
else:
return render_template('accueil.html')
resp = render_template('accueil.html', signin_enable=app.config['SIGNIN_ENABLE'])
return resp
@loginlogout.route( '/logout/' )
def logout():
session.pop('username', None) # Supprimer username de la session s'il s'y trouve
return redirect(url_for('index'))
return redirect(url_for('loginlogout.index'))
@loginlogout.route( '/' )
def index():
if 'username' in session :
return redirect(url_for('profil.profile'))
else :
return redirect(url_for('loginlogout.login', _external=True))

26
views/logs.py
View File

@@ -3,13 +3,29 @@ import glob, os, sys
logs = Blueprint('logs', __name__, template_folder='templates')
app = Flask( 'pywallter' )
app.config.from_pyfile('config.py')
#### Variables ####################################################################################
DOSSIER_PERSO= app.config['DOSSIER_APP']
extensionimg = app.config['EXT_IMG']
DATABASE = app.config['DATABASE']
##################################################################################################
@logs.route('/logs/')
def logfile():
if 'username' in session :
with open('log.txt', 'r') as log:
if 'username' in session:
UTILISATEUR='%s'% escape(session['username'])
log_file=os.path.join(DOSSIER_PERSO, UTILISATEUR, "log.txt")
with open(log_file, 'r') as log:
print("on passe ici")
logs=log.readlines()
log.close()
for line in logs:
return render_template('logs.html', section="Logs", logs=logs, line=line)
return render_template('logs.html', section="Logs", logs=logs)
else :
return redirect(url_for('loginlogout.login', _external=True))
return redirect(url_for('loginlogout.login', _external=True), code=401)

225
views/profil.py
View File

@@ -4,6 +4,10 @@ from PIL import Image
import time
import sqlite3
import os
from socket import gethostname
from subprocess import run
from flask_bcrypt import Bcrypt
from tools.utils import email_disp, append_to_log, gen_token
profil = Blueprint('profil', __name__, template_folder='templates')
@@ -13,19 +17,32 @@ app.config.from_pyfile('config.py')
#### Variables ####################################################################################
DOSSIER_PERSO= app.config['DOSSIER_APP']
bcrypt = Bcrypt(app)
DOSSIER_PERSO = app.config['DOSSIER_APP']
extensionimg = app.config['EXT_IMG']
DATABASE = app.config['DATABASE']
MAIL_SERVER = app.config['MAIL_SERVER']
XMPP_SERVER = app.config['XMPP_SERVER']
SETUID = app.config['SETUID']
##################################################################################################
@profil.route( '/parametres/', methods=['GET','POST'] )
def parametres() :
if 'username' in session :
return render_template('parametres.html', section='profil')
else:
return redirect(url_for('loginlogout.login'))
@profil.route('/profil/', methods=['GET','POST'] )
def profile() :
if 'username' in session :
UTILISATEUR='%s' % escape(session['username'])
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT avatar, nom, prenom, age, mail_rescue FROM users WHERE name=?""", (UTILISATEUR,))
tmp = (cursor.fetchone())
@@ -61,7 +78,7 @@ def profile() :
img.tumbnails(resize='80x80')
img.save(filename = DOSSIER_PERSO + UTILISATEUR + '/profile/' + nom)
imagelocation = DOSSIER_PERSO + UTILISATEUR + '/profile/' + nom
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("UPDATE users SET avatar=? WHERE name=?",
(imagelocation, UTILISATEUR))
@@ -71,8 +88,8 @@ def profile() :
flash(u'Image de profil mise à jour', 'succes')
else:
conn = sqlite3.connect('base.db') # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l\'objet "curseur"
cursor.execute("UPDATE users SET nom=?, prenom=?, age=?, mail_rescue=? WHERE name=?",
(profil_user['nom'], profil_user['prenom'], profil_user['age'], profil_user['mail_rescue'],
UTILISATEUR))
@@ -88,4 +105,198 @@ def profile() :
username=UTILISATEUR)
else :
return redirect(url_for('loginlogout.login', _external=True))
return redirect(url_for('loginlogout.login', _external=True), code=401)
@profil.route('/profil/change-password/', methods=['GET','POST'] )
def change_passwd() :
if 'username' in session:
UTILISATEUR='%s' % escape(session['username'])
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT Mail, alias, xmpp FROM users WHERE name=?""", (UTILISATEUR,))
tmp = cursor.fetchone()
mailbox = dict()
mailbox['Mail'] = tmp[0]
mailbox['alias'] = tmp[1]
mailbox['xmpp'] = tmp[2]
if request.method == 'POST' :
if request.form['password'] == request.form['passwd_confirm']:
mail_passwd_change = 0
xmmp_passwd_change = 0
passwd = request.form['password']
if MAIL_SERVER:
p = run( [ SETUID, 'set_mail_passwd', "'"+mailbox['Mail']+"'", "'"+passwd+"'" ] )
mail_passwd_change = p.returncode
if XMMP_SERVER:
tmp = mailbox['mail'].split('@')
p = run( [ SETUID, 'prosodyctl register', "'"+tmp[0]+"'",
"'"+tmp[1]+"'", "'"+passwd+"'" ])
if p.returncode != 0:
flash(u'Il y a eu un problème pour le changement du mot de passe du compte XMPP !', 'error')
if mail_passwd_change == 0:
passwd_bcrypt = bcrypt.generate_password_hash(passwd)
cursor.execute("UPDATE users SET passwd=? WHERE name=?",
(passwd_bcrypt, UTILISATEUR))
conn.commit()
TIME=time.strftime("%A %d %B %Y %H:%M:%S")
IP=request.environ['REMOTE_ADDR']
CLIENT_PLATFORM=request.headers.get('User-Agent')
log=TIME + ' - ' + IP + ' - ' + UTILISATEUR + ' - ' + CLIENT_PLATFORM + '\n' + '---> ' + "Changement du mot de passe" + '\n'
append_to_log(log, UTILISATEUR)
flash(u'Votre mot de passe a été changé', 'succes')
else:
flash(u'Il y eu un problème votre mot de passe n\'a pas été changé', 'error')
can_commit=False
conn.close()
return render_template('mailbox.html',
section="mailbox",
address=mailbox['Mail'],
alias=mailbox['alias'],
username=UTILISATEUR)
else :
return redirect(url_for('loginlogout.login', _external=True), code=401)
@profil.route('/mymailbox/alias', methods=['GET', 'POST'] )
def myalias():
hostname=gethostname()
if 'username' in session:
UTILISATEUR='%s' % escape(session['username'])
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
if request.method == 'POST' and MAIL_SERVER:
if request.form['alias']:
alias = request.form['alias']+'@'+hostname
else:
flash(u'Addresse invalide')
if email_disp(alias):
cursor.execute("""SELECT Mail, alias FROM users where name=?""", (UTILISATEUR,))
tmp = cursor.fetchone()
mail = tmp[0]
if tmp[1]:
alias_list = tmp[1]
aliases = alias_list + "," +alias
else:
aliases = alias
p = run( [ 'set_mail_alias', "'"+mail+"'", "add", "'"+alias+"'" ] )
if p.returncode == 0:
cursor.execute("UPDATE users SET alias=? WHERE name=?",
(aliases, UTILISATEUR))
conn.commit()
TIME=time.strftime("%A %d %B %Y %H:%M:%S")
IP=request.environ['REMOTE_ADDR']
CLIENT_PLATFORM=request.headers.get('User-Agent')
log=TIME + ' - ' + IP + ' - ' + UTILISATEUR + ' - ' + CLIENT_PLATFORM + '\n' + '---> ' + "Ajout de l'alias "+ alias + '\n'
append_to_log(log, UTILISATEUR)
flash(u'Votre alias a été ajouté', 'succes')
else:
flash(u'Adresse indisponible', 'error')
else:
flash(u'Adresse indisponible', 'error')
cursor.execute("""SELECT Mail, alias FROM users WHERE name=?""",
(UTILISATEUR,))
tmp = cursor.fetchone()
mailbox = dict()
mailbox['Mail'] = tmp[0]
if tmp[1]:
mailbox['alias'] = tmp[1].split(',')
else:
mailbox['alias'] = list()
conn.close()
return render_template('myalias.html',
section="mailbox",
email=mailbox['Mail'],
aliases=mailbox['alias'],
hostname=hostname,
Mail_active=MAIL_SERVER
username=UTILISATEUR )
else:
return redirect(url_for('loginlogout.login', _external=True), code=401)
@profil.route('/mymailbox/rmalias/<aliasrm>')
def remove_alias(aliasrm):
if 'username' in session:
if MAIL_SERVER:
UTILISATEUR='%s' % escape(session['username'])
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT Mail, alias FROM users WHERE name=?""", (UTILISATEUR,))
tmp = cursor.fetchone()
mail = tmp[0]
alias_list = tmp[1].split(',')
aliases = ""
for alias in alias_list:
if alias != aliasrm:
if aliases:
aliases = aliases + "," + alias
else:
aliases = alias
p = run( [ 'set_mail_alias', "'"+mail+"'", "del", "'"+alias+"'" ] )
if p.returncode == 0:
cursor.execute("UPDATE users SET alias=? WHERE name=?",
(aliases, UTILISATEUR))
conn.commit()
TIME=time.strftime("%A %d %B %Y %H:%M:%S")
IP=request.environ['REMOTE_ADDR']
CLIENT_PLATFORM=request.headers.get('User-Agent')
log = TIME + ' - ' + IP + ' - ' + UTILISATEUR + ' - ' + CLIENT_PLATFORM + '\n' + '---> ' + "Suppression de l'alias "+ alias + '\n'
append_to_log(log, UTILISATEUR)
flash(u'Votre alias a été supprimé', 'succes')
else:
flash(u'Il y a eu une erreur', 'error')
return redirect(url_for('profil.myalias', _external=True))
else:
return redirect(url_for('loginlogout.login', _external=True), code=401)
@profil.route('/invitation/', methods=['GET'])
def invitation():
if 'username' in session:
UTILISATEUR='%s' % escape(session['username'])
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
cursor.execute("""SELECT Token, invitations FROM users WHERE name=?""", (UTILISATEUR,))
tmp = cursor.fetchone()
print (tmp)
token = tmp[0]
invitations_count = tmp[1]
conn.close()
base_url = request.base_url
base_url = base_url.replace("/invitation/", "inscription")
return render_template('invitation.html',
section='Profil',
token=token,
nb_invitation=invitations_count,
base_url=base_url)
else:
return redirect(url_for('loginlogout.login', _external=True), code=401)
@profil.route('/gen_token/', methods=['GET'])
def generate_token():
if 'username' in session:
UTILISATEUR='%s' % escape(session['username'])
conn = sqlite3.connect(DATABASE) # Connexion à la base de donnée
cursor = conn.cursor() # Création de l'objet "curseur"
token = gen_token()
cursor.execute("UPDATE users SET Token=? WHERE name=?",
(token, UTILISATEUR))
conn.commit()
conn.close()
return redirect(url_for('profil.invitation', _external=True))
else:
return redirect(url_for('loginlogout.login', _external=True), code=401)