def validate(self):
ucontr = UserController()
validated = super().validate()
if ucontr.read(nickname=self.nickname.data).count():
self.nickname.errors.append("Nickname already taken")
validated = False
if self.nickname.data != User.make_valid_nickname(self.nickname.data):
self.nickname.errors.append(
lazy_gettext(
"This nickname has invalid characters. "
"Please use letters, numbers, dots and underscores only."))
validated = False
return validated
def wrapper(*args, **kwargs):
if request.authorization:
ucontr = UserController()
try:
user = ucontr.get(nickname=request.authorization.username)
except NotFound:
raise Forbidden("Couldn't authenticate your user")
if not ucontr.check_password(user, request.authorization.password):
raise Forbidden("Couldn't authenticate your user")
if not user.is_active:
raise Forbidden("User is deactivated")
login_user_bundle(user)
if current_user.is_authenticated:
return func(*args, **kwargs)
raise Unauthorized()
def fetch_asyncio(user_id=None, feed_id=None):
"Crawl the feeds with asyncio."
import asyncio
with application.app_context():
from newspipe.crawler import default_crawler
filters = {}
filters["is_active"] = True
filters["automatic_crawling"] = True
if None is not user_id:
filters["id"] = user_id
users = UserController().read(**filters).all()
try:
feed_id = int(feed_id)
except:
feed_id = None
loop = asyncio.get_event_loop()
queue = asyncio.Queue(maxsize=3, loop=loop)
producer_coro = default_crawler.retrieve_feed(queue, users, feed_id)
consumer_coro = default_crawler.insert_articles(queue, 1)
logger.info("Starting crawler.")
start = datetime.now()
loop.run_until_complete(asyncio.gather(producer_coro, consumer_coro))
end = datetime.now()
loop.close()
logger.info("Crawler finished in {} seconds.".format(
(end - start).seconds))
def delete_user(user_id=None):
"Delete the user with the id specified in the command line."
try:
user = UserController().delete(user_id)
print("User {} deleted".format(user.nickname))
except Exception as e:
print(e)
def confirm_account(token=None):
"""
Confirm the account of a user.
"""
user_contr = UserController()
user, nickname = None, None
if token != "":
nickname = confirm_token(token)
if nickname:
user = user_contr.read(nickname=nickname).first()
if user is not None:
user_contr.update({"id": user.id}, {"is_active": True})
flash(gettext("Your account has been confirmed."), "success")
else:
flash(gettext("Impossible to confirm this account."), "danger")
return redirect(url_for("login"))
def export():
"""
Export feeds to OPML.
"""
include_disabled = request.args.get("includedisabled", "") == "on"
include_private = request.args.get("includeprivate", "") == "on"
include_exceeded_error_count = (request.args.get(
"includeexceedederrorcount", "") == "on")
filter = {}
if not include_disabled:
filter["enabled"] = True
if not include_private:
filter["private"] = False
if not include_exceeded_error_count:
filter["error_count__lt"] = application.config["DEFAULT_MAX_ERROR"]
user = UserController(current_user.id).get(id=current_user.id)
feeds = FeedController(current_user.id).read(**filter)
categories = {
cat.id: cat.dump()
for cat in CategoryController(user.id).read()
}
response = make_response(
render_template(
"opml.xml",
user=user,
feeds=feeds,
categories=categories,
now=datetime.now(),
))
response.headers["Content-Type"] = "application/xml"
response.headers["Content-Disposition"] = "attachment; filename=feeds.opml"
return response
def delete_account():
"""
Delete the account of the user (with all its data).
"""
UserController(current_user.id).delete(current_user.id)
flash(gettext("Your account has been deleted."), "success")
return redirect(url_for("logout"))
def signup():
if not application.config["SELF_REGISTRATION"]:
flash(gettext("Self-registration is disabled."), "warning")
return redirect(url_for("home"))
if current_user.is_authenticated:
return redirect(url_for("home"))
form = SignupForm()
if form.validate_on_submit():
user = UserController().create(
nickname=form.nickname.data,
pwdhash=generate_password_hash(form.password.data),
)
# Send the confirmation email
try:
notifications.new_account_notification(user, form.email.data)
except Exception as error:
flash(
gettext("Problem while sending activation email: %(error)s",
error=error),
"danger",
)
return redirect(url_for("home"))
flash(
gettext("Your account has been created. "
"Check your mail to confirm it."),
"success",
)
return redirect(url_for("home"))
return render_template("signup.html", form=form)
def validate(self):
validated = super().validate()
ucontr = UserController()
try:
user = ucontr.get(nickname=self.nickmane.data)
except NotFound:
self.nickmane.errors.append("Wrong nickname")
validated = False
else:
if not user.is_active:
self.nickmane.errors.append("Account not active")
validated = False
if not ucontr.check_password(user, self.password.data):
self.password.errors.append("Wrong password")
validated = False
self.user = user
return validated
def user_stream(per_page, nickname=None):
"""
Display the stream of a user (list of articles of public feed).
"""
user_contr = UserController()
user = user_contr.get(nickname=nickname)
if not user.is_public_profile:
if current_user.is_authenticated and current_user.id == user.id:
flash(gettext("You must set your profile to public."), "info")
return redirect(url_for("user.profile"))
category_id = int(request.args.get("category_id", 0))
category = CategoryController().read(id=category_id).first()
# Load the public feeds
filters = {}
filters["private"] = False
if category_id:
filters["category_id"] = category_id
feeds = FeedController().read(**filters).all()
# Re-initializes the filters to load the articles
filters = {}
filters["feed_id__in"] = [feed.id for feed in feeds]
if category:
filters["category_id"] = category_id
articles = ArticleController(user.id).read_ordered(**filters)
# Server-side pagination
page, per_page, offset = get_page_args(per_page_parameter="per_page")
pagination = Pagination(
page=page,
total=articles.count(),
css_framework="bootstrap4",
search=False,
record_name="articles",
per_page=per_page,
)
return render_template(
"user_stream.html",
user=user,
articles=articles.offset(offset).limit(per_page),
category=category,
pagination=pagination,
)
def profile():
"""
Edit the profile of the currently logged user.
"""
user_contr = UserController(current_user.id)
user = user_contr.get(id=current_user.id)
form = ProfileForm()
if request.method == "POST":
if form.validate():
try:
user_contr.update(
{"id": current_user.id},
{
"nickname": form.nickname.data,
"password": form.password.data,
"automatic_crawling": form.automatic_crawling.data,
"is_public_profile": form.is_public_profile.data,
"bio": form.bio.data,
"webpage": form.webpage.data,
"twitter": form.twitter.data,
},
)
except Exception as error:
flash(
gettext(
"Problem while updating your profile: "
"%(error)s",
error=error),
"danger",
)
else:
flash(
gettext("User %(nick)s successfully updated",
nick=user.nickname),
"success",
)
return redirect(url_for("user.profile"))
else:
return render_template("profile.html", user=user, form=form)
if request.method == "GET":
form = ProfileForm(obj=user)
return render_template("profile.html", user=user, form=form)
def create_admin(nickname, password):
"Will create an admin user."
admin = {
"is_admin": True,
"is_api": True,
"is_active": True,
"nickname": nickname,
"pwdhash": generate_password_hash(password),
}
with application.app_context():
UserController(ignore_context=True).create(**admin)
def user_form(user_id=None):
if user_id is not None:
user = UserController().get(id=user_id)
form = UserForm(obj=user)
message = gettext("Edit the user <i>%(nick)s</i>", nick=user.nickname)
else:
form = UserForm()
message = gettext("Add a new user")
return render_template("/admin/create_user.html",
form=form,
message=message)
def db_create():
"Will create the database from conf parameters."
admin = {
"is_admin": True,
"is_api": True,
"is_active": True,
"nickname": "admin",
"pwdhash": generate_password_hash(os.environ.get("ADMIN_PASSWORD", "password")),
}
with application.app_context():
db.create_all()
UserController(ignore_context=True).create(**admin)
def profile_public(nickname=None):
"""
Display the public profile of the user.
"""
category_id = int(request.args.get("category_id", 0))
user_contr = UserController()
user = user_contr.get(nickname=nickname)
if not user.is_public_profile:
if current_user.is_authenticated and current_user.id == user.id:
flash(gettext("You must set your profile to public."), "info")
return redirect(url_for("user.profile"))
filters = {}
filters["private"] = False
if category_id:
filters["category_id"] = category_id
feeds = FeedController(user.id).read(**filters)
return render_template("profile_public.html",
user=user,
feeds=feeds,
selected_category_id=category_id)
def toggle_user(user_id=None):
"""
Enable or disable the account of a user.
"""
ucontr = UserController()
user = ucontr.get(id=user_id)
user_changed = ucontr.update({"id": user_id},
{"is_active": not user.is_active})
if not user_changed:
flash(gettext("This user does not exist."), "danger")
return redirect(url_for("admin.dashboard"))
else:
act_txt = "activated" if user.is_active else "desactivated"
message = gettext(
"User %(nickname)s successfully %(is_active)s",
nickname=user.nickname,
is_active=act_txt,
)
flash(message, "success")
return redirect(url_for("admin.dashboard"))
def delete_inactive_users(last_seen):
"Delete inactive users (inactivity is given in parameter and specified in number of months)."
filter = {}
filter["last_seen__lt"] = date.today() - relativedelta(months=last_seen)
users = UserController().read(**filter)
for user in users:
db.session.delete(user)
try:
print("Deleting user {}...".format(user.nickname))
db.session.commit()
except:
db.session.rollback()
print("Inactive users deleted.")
def dashboard():
last_cons, now = {}, datetime.utcnow()
users = list(UserController().read().order_by("id"))
form = InformationMessageForm()
for user in users:
last_cons[user.id] = format_timedelta(now - user.last_seen)
return render_template(
"admin/dashboard.html",
now=datetime.utcnow(),
last_cons=last_cons,
users=users,
current_user=current_user,
form=form,
)
def disable_inactive_users(last_seen):
"Disable inactive users (inactivity is given in parameter and specified in number of months)."
filter = {}
filter["last_seen__lt"] = date.today() - relativedelta(months=last_seen)
users = UserController().read(**filter)
for user in users:
user.is_active = False
user.is_public_profile = False
user.automatic_crawling = False
try:
print("Updating user {}...".format(user.nickname))
db.session.commit()
except:
db.session.rollback()
print("Inactive users disabled.")
def export():
"""
Export articles to JSON.
"""
user = UserController(current_user.id).get(id=current_user.id)
try:
json_result = export_json(user)
except Exception:
flash(gettext("Error when exporting articles."), "danger")
return redirect(redirect_url())
response = make_response(json_result)
response.mimetype = "application/json"
response.headers[
"Content-Disposition"] = "attachment; filename=account.json"
return response
def delete_user(user_id=None):
"""
Delete a user (with all its data).
"""
try:
user = UserController().delete(user_id)
flash(
gettext("User %(nick)s successfully deleted", nick=user.nickname),
"success")
except Exception as error:
flash(
gettext(
"An error occurred while trying to delete a user: %(error)s",
error=error,
),
"danger",
)
return redirect(url_for("admin.dashboard"))
def about_more():
version = __version__.split("-")
if len(version) == 1:
newspipe_version = version[0]
version_url = "https://git.sr.ht/~cedric/newspipe/refs/{}".format(
version[0])
else:
newspipe_version = "{} - {}".format(version[0], version[2][1:])
version_url = "https://git.sr.ht/~cedric/newspipe/commit/{}".format(
version[2][1:])
return render_template(
"about_more.html",
newspipe_version=newspipe_version,
version_url=version_url,
registration=[
application.config["SELF_REGISTRATION"] and "Open" or "Closed"
][0],
python_version="{}.{}.{}".format(*sys.version_info[:3]),
nb_users=UserController().read().count(),
)
def process_user_form(user_id=None):
"""
Create or edit a user.
"""
form = UserForm()
user_contr = UserController()
if not form.validate():
return render_template(
"/admin/create_user.html",
form=form,
message=gettext("Some errors were found"),
)
if user_id is not None:
# Edit a user
user_contr.update(
{"id": user_id},
{
"nickname": form.nickname.data,
"password": form.password.data,
"automatic_crawling": form.automatic_crawling.data,
},
)
user = user_contr.get(id=user_id)
flash(
gettext("User %(nick)s successfully updated", nick=user.nickname),
"success")
else:
# Create a new user (by the admin)
user = user_contr.create(
nickname=form.nickname.data,
password=form.password.data,
automatic_crawling=form.automatic_crawling.data,
is_admin=False,
is_active=True,
)
flash(
gettext("User %(nick)s successfully created", nick=user.nickname),
"success")
return redirect(url_for("admin.user_form", user_id=user.id))
def load_user(user_id):
try:
return UserController(user_id, ignore_context=True).get(id=user_id,
is_active=True)
except NotFound:
pass
def load_user(user_id):
return UserController(user_id, ignore_context=True).get(id=user_id,
is_active=True)
def login_user_bundle(user):
login_user(user)
identity_changed.send(current_app, identity=Identity(user.id))
session_identity_loader()
UserController(user.id).update({"id": user.id},
{"last_seen": datetime.utcnow()})
def before_request():
if current_user.is_authenticated:
UserController(current_user.id).update(
{"id": current_user.id}, {"last_seen": datetime.utcnow()})