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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 load_user(user_id): try: return UserController(user_id, ignore_context=True).get(id=user_id, is_active=True) except NotFound: pass
def before_request(): if current_user.is_authenticated: UserController(current_user.id).update( {"id": current_user.id}, {"last_seen": datetime.utcnow()})
def load_user(user_id): return UserController(user_id, ignore_context=True).get(id=user_id, is_active=True)