def test_get_moderate_channels_for_user():
u = User.query.get(1)
channel = Channel(name="test", module=get_module_full_name("mail"), config="{}")
db.session.add(channel)
assert get_moderate_channels_for_user(u) is not None
user = User(id=2, name="test", first_name="utilisateur2", email="*****@*****.**")
db.session.add(user)
assert len(get_moderate_channels_for_user(user)) == 0
a = Authorization(channel_id=1, user_id=2, permission=2)
db.session.add(a)
assert len(get_moderate_channels_for_user(user)) == 1
def index():
# Team06: Export to PDF feature
if request.method == "POST":
action = request.form.get('@action', '')
if action == "export":
post_id = request.form.get("id")
chan_id = request.form.get("template")
return pdf.export(post_id, chan_id)
# end addition
user = User.query.get(session.get("user_id", "")) if session.get(
"logged_in", False) else None
posts = []
flattened_list_pubs = []
# TEAM06: add – pdf
pdf_chans = db.session.query(Channel).filter(
Channel.module == 'superform.plugins.pdf'
)
# end add
chans = []
if user is not None:
setattr(user, 'is_mod', is_moderator(user))
posts = db.session.query(Post).filter(
Post.user_id == session.get("user_id", ""))
chans = get_moderate_channels_for_user(user)
pubs_per_chan = (db.session.query(Publishing).filter(
(Publishing.channel_id == c.id) & (Publishing.state == 0)) for c in
chans)
flattened_list_pubs = [y for x in pubs_per_chan for y in x]
# TEAM06: changes in the render_template, templates
return render_template("index.html", user = user, posts = posts,
channels = chans,
publishings = flattened_list_pubs,
templates = pdf_chans)
def search_publishings() :
'''
Searching in query for publishings with a specific filter
:param no param, except request.form from front-end. This form contains all filters possible for a search
:return: data, JSON containing all data retrieved from queries, based on filters.
'''
data = []
user = User.query.get(session.get("user_id", "")) if session.get("logged_in", False) else None
posts = []
chans = []
flattened_list_pubs = []
if user is not None:
setattr(user, 'is_mod', is_moderator(user))
chans = get_moderate_channels_for_user(user)
pubs_per_chan = (db.session.query(Publishing).filter((Publishing.channel_id == c.id) &
(Publishing.title.like('%'+request.form['subject']+'%')) &
(Publishing.description.like('%' + request.form['body'] + '%')) &
(Publishing.state == 0)) for c in chans)
flattened_list_pubs = [y for x in pubs_per_chan for y in x]
print(str(flattened_list_pubs))
for p in flattened_list_pubs : #request.form['author'] in p.get_author() and
if str(p.channel_id) in request.form.getlist('channels[]'):
row = {}
for c in chans :
if c.id == p.channel_id:
row["channel"] = c.name
row["subject"] = p.title
row["body"] = str(p.description.splitlines())
row["author"] = p.get_author()
row["button"] = url_for('publishings.moderate_publishing',id=p.post_id,idc=p.channel_id)
data.append(row)
return json.dumps(data)
def search():
user_id = session.get('user_id', '') if session.get('logged_in',
False) else -1
l_chan = channels_available_for_user(user_id)
if request.method == 'GET':
return render_template('search.html', l_chan=l_chan, publishing=[])
else:
user = User.query.get(user_id) if session.get("logged_in",
False) else None
print(user)
pattern = request.form.get('search_word')
chan = request.form.getlist('search_chan')
status = request.form.getlist('post_status')
loc = request.form.getlist('search_loc')
date_from = request.form.get('date_from')
date_until = request.form.get('date_until')
search_type = request.form.get('search_type') == 'keyword'
search_table = request.form.get('search_table')
print(search_table)
filter_parameter = make_filter_parameter(user_id, pattern, chan,
status, loc, date_from,
date_until, search_type,
search_table)
search_result = query_maker(filter_parameter)
return render_template(
'search.html',
l_chan=l_chan,
publishing=search_result,
post=True,
moderate_channel=[
x.id for x in get_moderate_channels_for_user(user)
],
search_table=search_table,
user_id=user.id)
def callback():
auth = OneLogin_Saml2_Auth(prepare_saml_request(request),
current_app.config["SAML"])
auth.process_response()
errors = auth.get_errors()
if len(errors) == 0:
auth_attrs = auth.get_attributes()
mappings = current_app.config["SAML"]["attributes"]
attrs = {
key: auth_attrs[mapping][0]
for key, mapping in mappings.items()
}
user = User.query.get(attrs["uid"])
if not user:
user = User(id=attrs["uid"],
name=attrs["sn"],
first_name=attrs["givenName"],
email=attrs["email"])
db.session.add(user)
db.session.commit()
session["logged_in"] = True
session["user_id"] = user.id
session["first_name"] = user.first_name
session["name"] = user.name
session["email"] = user.email
session["admin"] = user.admin
# To do : create function to avoid duplication with pub_page '/moderate'
if user.admin:
chans = get_moderate_channels_for_user(user)
pubs_per_chan = (db.session.query(Publishing).filter(
(Publishing.channel_id == c.id) & (Publishing.state == 0))
for c in chans)
flattened_list_pubs = [y for x in pubs_per_chan for y in x]
session["notification"] = len(flattened_list_pubs)
else:
session["notification"] = 0
# Redirect to desired url
self_url = OneLogin_Saml2_Utils.get_self_url(
prepare_saml_request(request))
if 'RelayState' in request.form and self_url != request.form[
'RelayState']:
return redirect(auth.redirect_to(request.form['RelayState']))
else:
return make_response(", ".join(errors), 500)
return make_response("saml_acs_error", 500)
def index():
user = User.query.get(session.get("user_id", "")) if session.get("logged_in", False) else None
posts = []
flattened_list_pubs = []
if user is not None:
setattr(user, 'is_mod', is_moderator(user))
posts = db.session.query(Post).filter(Post.user_id == session.get("user_id", ""))
chans = get_moderate_channels_for_user(user)
pubs_per_chan = (
db.session.query(Publishing).filter((Publishing.channel_id == c.id) & (Publishing.state == 0)) for c in
chans)
flattened_list_pubs = [y for x in pubs_per_chan for y in x]
return render_template("index.html", user=user, posts=posts, publishings=flattened_list_pubs)
def moderate():
user = User.query.get(session.get("user_id", "")) if session.get(
"logged_in", False) else None
flattened_list_pubs = []
if user is not None:
chans = get_moderate_channels_for_user(user)
pubs_per_chan = (
db.session.query(Publishing).filter((Publishing.channel_id == c.id)
& (Publishing.state == 0))
for c in chans)
flattened_list_pubs = [y for x in pubs_per_chan for y in x]
pubs_per_edit = (
db.session.query(Publishing).filter((Publishing.channel_id == c.id)
& (Publishing.state == 66))
for c in chans)
flattened_list_edit = [y for x in pubs_per_edit for y in x]
flattened_list_pubs += flattened_list_edit
return render_template("moderate.html", publishings=flattened_list_pubs)
def filter_query_accessible_publications(user, table):
"""
A function which returns the different publication permitted by an user.
:param user: a User object representing the current user.
:return: the filter parameters allowing user only seeing publishings he has haccess.
"""
condition = (table.post_id == None) if table == Publishing else (table.id
== None)
user_post = db.session.query(Post).filter(Post.user_id == user.id)
for post in user_post:
condition = condition | (
table.post_id == post.id) if table == Publishing else condition | (
table.id == post.id)
if table == Publishing:
for chan in get_moderate_channels_for_user(user):
condition = condition | (table.channel_id == chan.id)
return condition
def index():
# Team06: Export to PDF feature
if request.method == "POST":
action = request.form.get('@action', '')
if action == "export":
post_id = request.form.get("id")
chan_id = request.form.get("template")
return export(post_id, chan_id)
# end addition
user_id = session.get("user_id", "") if session.get("logged_in",
False) else -1
user = User.query.get(user_id) if session.get("logged_in", False) else None
# TEAM06: add – pdf
pdf_chans = db.session.query(Channel).filter(
Channel.module == 'superform.plugins.pdf')
# end add
posts_var = []
pubs_unvalidated = []
chans = []
if user is not None and user_id != -1:
setattr(user, 'is_mod', is_moderator(user))
chans = get_moderate_channels_for_user(user)
# AJOUTER Post.user_id == user_id dans posts DANS QUERY?
posts_var = db.session.query(Post).filter(
Post.user_id == user_id).order_by(Post.date_created.desc())
for post in posts_var:
publishings_var = db.session.query(Publishing).filter(
Publishing.post_id == post.id).all()
channels_var = set()
for publishing in publishings_var:
channels_var.add(
db.session.query(Channel).filter(
Channel.id == publishing.channel_id).first())
setattr(post, "channels", channels_var)
posts_user = db.session.query(Post).filter(
Post.user_id == user_id).all()
pubs_unvalidated = db.session.query(Publishing).filter(
Publishing.state == State.REFUSED.value).filter(
Publishing.user_id == user_id).order_by(
Publishing.post_id).order_by(Publishing.channel_id).all()
post_ids = [p.id for p in posts_user]
for pub_unvalidated in pubs_unvalidated:
if pub_unvalidated.post_id in post_ids:
size_comment = current_app.config["SIZE_COMMENT"]
channels_var = [
db.session.query(Channel).filter(
Channel.id == pub_unvalidated.channel_id).first()
]
setattr(pub_unvalidated, "channels", channels_var)
last_comment = db.session.query(Comment).filter(
Comment.publishing_id ==
pub_unvalidated.publishing_id).first()
comm = comm_short = last_comment.moderator_comment[:
size_comment]
if len(last_comment.moderator_comment) > size_comment:
comm_short = comm + "..."
comm = last_comment.moderator_comment
setattr(pub_unvalidated, "comment_short", comm_short)
setattr(pub_unvalidated, "comment", comm)
# TEAM06: changes in the render_template, templates
return render_template("index.html",
posts=posts_var[:5],
pubs_unvalidated=pubs_unvalidated,
templates=pdf_chans,
user=user,
channels=chans)
