libreqda 1.2.0__py3-none-any.whl

scripts/edugain/worker_update_edugain_idps.py

@@ -0,0 +1,89 @@
+# imports
+import json
+import datetime
+import os
+
+from taguette import database
+from taguette.database.models import EdugainIdps
+
+dir_path = os.path.dirname(os.path.realpath(__file__))
+conf_path = os.path.dirname(os.path.dirname(dir_path))
+
+# Open edugain idps JSON file
+json_file = f'{dir_path}/edugain_idps.json'
+try:
+    f = open(json_file)
+    idps = json.load(f)
+except:
+    print(f"{json_file} not found")
+    exit()
+
+config = {}
+config_file = os.path.abspath(f'{conf_path}/taguette.conf')
+with open(config_file) as fp:
+    code = compile(fp.read(), config_file, 'exec')
+exec(code, config)
+DBSession = database.connect(config['DATABASE'])
+db = DBSession()
+
+idps_added = 0
+idps_removed = 0
+idps_updated = 0
+
+if idps[0][0]['id'] is not None:
+
+    for idp in idps:
+        idp_id = (db.query(database.EdugainIdps).
+                  filter_by(entityid=idp[0]['entityid']).first())
+
+        if idp_id is None:
+            # Add a new entry
+            new_idp = EdugainIdps()
+            new_idp.id = idp[0]['id']
+            new_idp.entityid = idp[0]['entityid']
+            new_idp.e_displayname = idp[0]['e_displayname']
+            new_idp.regauth = idp[0]['regauth']
+            new_idp.entity_cat = idp[0]['entity_cat']
+            new_idp.eccs_status = idp[0]['eccs_status']
+            new_idp.validator_status = idp[0]['validator_status']
+            new_idp.coco_status = idp[0]['coco_status']
+            new_idp.coco_id = idp[0]['coco_id']
+            new_idp.sirtfi_status = idp[0]['sirtfi_status']
+            if new_idp.entityid.lower().find('inrs'):
+                new_idp.code = 'CAF'
+            else:
+                new_idp.code = idp[0]['code']
+            new_idp.scopes = idp[0]['scopes']
+
+            db.add(new_idp)
+            idps_added += 1
+
+        else:
+            # Update existing entry
+            idp_id.id = idp[0]['id']
+            idp_id.entityid = idp[0]['entityid']
+            idp_id.e_displayname = idp[0]['e_displayname']
+            idp_id.regauth = idp[0]['regauth']
+            idp_id.entity_cat = idp[0]['entity_cat']
+            idp_id.eccs_status = idp[0]['eccs_status']
+            idp_id.validator_status = idp[0]['validator_status']
+            idp_id.coco_status = idp[0]['coco_status']
+            idp_id.coco_id = idp[0]['coco_id']
+            idp_id.sirtfi_status = idp[0]['sirtfi_status']
+            if idp_id.entityid.lower().find('inrs'):
+                idp_id.code = 'CAF'
+            else:
+                idp_id.code = idp[0]['code']
+            idp_id.scopes = idp[0]['scopes']
+            idps_updated += 1
+
+        db.commit()
+
+
+if idps_added != 0 or idps_removed != 0 or idps_updated != 0:
+
+    ct = "["+str(datetime.datetime.now())+"]"
+    print( f"{ct} UPDATE EDUGAIN IDPs => IDPs added: {idps_added}, updated {idps_updated}, removed {idps_removed}" )
+
+# Close File
+f.close()

scripts/edugain/worker_update_edugain_idps.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+SCRIPTPATH="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
+
+curl --fail --silent https://technical.edugain.org/api.php?action=list_entities -H "Accept: application/json" --output "${SCRIPTPATH}/edugain_idps.json"
+
+# Update edugain IDPs local database table (edugain_idps)
+cd "${SCRIPTPATH}/../../"
+poetry run python "${SCRIPTPATH}/worker_update_edugain_idps.py" &>> "${SCRIPTPATH}/worker_update_edugain_idps.log"
+

scripts/make_password_reset_link.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import sys
+import time
+from tornado.web import create_signed_value
+
+from taguette import database
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate a password reset link for manual delivery",
+    )
+    parser.add_argument('config_file', help="Configuration file")
+    parser.add_argument('user_login')
+
+    args = parser.parse_args()
+
+    config = {}
+    config_file = os.path.abspath(args.config_file)
+    with open(config_file) as fp:
+        code = compile(fp.read(), config_file, 'exec')
+    exec(code, config)
+
+    DBSession = database.connect(config['DATABASE'])
+    db = DBSession()
+
+    user = db.query(database.User).get(args.user_login)
+    if user is None:
+        print("No such user: %r" % args.user_login, file=sys.stderr)
+        sys.exit(1)
+
+    if user.disabled:
+        print("WARNING: USER IS DISABLED")
+
+    # Generate a signed token
+    reset_token = '%s|%s|%s' % (
+        int(time.time()),
+        user.login,
+        user.email,
+    )
+    reset_token = create_signed_value(
+        config['SECRET_KEY'],
+        'reset_token',
+        reset_token,
+    )
+    reset_token = reset_token.decode('utf-8')
+    reset_link = '/new_password?reset_token=' + reset_token
+
+    print(reset_link)
+
+
+if __name__ == '__main__':
+    main()

scripts/make_theme.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+import os
+import shutil
+import sys
+from pathlib import Path
+import sass
+
+script_dir = Path(__file__).parent
+project_root = script_dir.parent
+static_dir = project_root / "taguette" / "static"
+templates_dir = project_root / "taguette" / "templates"
+
+
+def get_theme_dir(theme_name):
+    return static_dir / "scss" / "themes" / theme_name
+
+
+def get_template_dir(theme_name):
+    return templates_dir / "alt_templates" / theme_name
+
+
+def get_assets_dir(theme_name):
+    return static_dir / "alt_templates" / theme_name
+
+
+def compile_scss(theme_name):
+    theme_dir = get_theme_dir(theme_name)
+    scss_input = theme_dir / "theme.scss"
+    css_output = theme_dir / "theme.css"
+    
+    if not scss_input.exists():
+        print(f"Error: input SCSS not found: {scss_input}")
+        sys.exit(1)
+    
+    css_output.parent.mkdir(exist_ok=True)
+    
+    try:
+        css, src_map = sass.compile(
+            filename=str(scss_input),
+            output_style="compressed",
+            source_map_filename=str(css_output) + ".map"
+        )
+
+        with open(css_output, "w") as f:
+            f.write(css)
+        
+        with open(str(css_output) + ".map", "w") as f:
+            f.write(src_map)
+
+        print(f"Successfully compiled {scss_input} to {css_output}")
+
+    except sass.CompileError as e:
+        print(f"SCSS compilation error: {e}")
+        sys.exit(1)
+
+    except Exception as e:
+        print(f"SCSS can't write {e}")
+
+
+def copy_default_theme(destination_theme_name):
+    from_theme_dir = get_theme_dir("default")
+    to_theme_dir = get_theme_dir(destination_theme_name)
+    shutil.copytree(from_theme_dir, to_theme_dir, dirs_exist_ok=True)
+    return destination_theme_name
+
+
+def create_directories(theme_name):
+    theme_dir = get_theme_dir(theme_name)
+    template_dir = get_template_dir(theme_name)
+    assets_dir = get_assets_dir(theme_name)
+    if not os.path.exists(theme_dir):
+        os.makedirs(theme_dir, exist_ok=True)
+        copy_default_theme(theme_name)
+        print(f"Theme directory created : {theme_dir}")
+    else:
+        print(f"Theme directory already exists : {theme_dir}")
+
+    if not os.path.exists(template_dir):
+        os.makedirs(template_dir, exist_ok=True)
+        print(f"Templates directory created : {template_dir}")
+    else:
+        print(f"Templates directory already exists : {template_dir}")
+
+    if not os.path.exists(assets_dir):
+        os.makedirs(assets_dir, exist_ok=True)
+        print(f"Assets directory created : {assets_dir}")
+    else:
+        print(f"Assets directory already exists : {assets_dir}")
+
+
+def main():
+    theme = sys.argv[1] if len(sys.argv) > 1 else "default"
+    create_directories(theme)
+    compile_scss(theme)
+
+
+if __name__ == "__main__":
+    main()

scripts/new_db_revision.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+if [ "$#" != 1 ]; then
+    echo "Usage: new_db_revision.sh \"message\"" >&2
+    exit 2
+fi
+
+alembic -x db=sqlite:///$HOME/.local/share/taguette/taguette.sqlite3 revision --autogenerate -m "${1}"

scripts/register_user.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+
+import argparse
+import asyncio
+import os
+import random
+import string
+import sys
+
+from taguette import database
+from taguette import validate
+
+
+PASSWORD_CHARS = string.ascii_letters + string.digits + '#%&-.?~'
+PASSWORD_LENGTH = 14
+
+
+async def main():
+    parser = argparse.ArgumentParser(
+        description="Register a new user",
+    )
+    parser.add_argument('config_file', help="Configuration file")
+    parser.add_argument('login')
+    parser.add_argument(
+        '--email',
+        help="User's email address (optional)",
+        action='store',
+    )
+
+    args = parser.parse_args()
+
+    config = {}
+    config_file = os.path.abspath(args.config_file)
+    with open(config_file) as fp:
+        code = compile(fp.read(), config_file, 'exec')
+    exec(code, config)
+
+    DBSession = database.connect(config['DATABASE'])
+    db = DBSession()
+
+    user = db.query(database.User).get(args.login)
+    if user is not None:
+        print("User exists: %s" % args.login, file=sys.stderr)
+        sys.exit(1)
+
+    # Validate input
+    login = validate.fix_user_login(args.login, new=True)
+    if args.email:
+        email = args.email
+        validate.user_email(email)
+    else:
+        email = None
+    print("email: %r" % email)
+
+    # Generate password
+    password = ''.join(random.choices(PASSWORD_CHARS, k=PASSWORD_LENGTH))
+
+    # Create user
+    user = database.User(
+        login=login,
+        email=email,
+    )
+    await user.set_password(password)
+    db.add(user)
+    db.commit()
+
+    print(
+        (
+            "New user created:\n    login: {login}\n"
+            + "    password: {password}"
+        ).format(login=login, password=password)
+    )
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

scripts/update_pot.sh

@@ -0,0 +1,33 @@
+#!/bin/sh
+
+set -eu
+
+cd "$(dirname "$(dirname "$0")")"
+pybabel extract -F scripts/babelrc -k _f -c TRANSLATORS: -s -o po/main.pot $(find taguette -name '*.py' -o -name '*.html')
+pybabel extract -F scripts/babelrc -c TRANSLATORS: -s -o po/javascript.pot $(find taguette -name '*.js')
+
+LOCALES=$(ls po/main_*.po 2>/dev/null | sed 's/.*main_\(.*\)\.po/\1/' | sort -u || echo "")
+
+if [ -z "$LOCALES" ]; then
+    echo "No existing .po files found. Skipping update."
+    exit 0
+fi
+
+echo ""
+echo "Found locales: $LOCALES"
+
+# Update main catalogue
+echo ""
+echo "Updating main catalogue..."
+for locale in $LOCALES; do
+    echo "  - $locale"
+    pybabel update -i po/main.pot -l $locale -o po/main_${locale}.po --no-fuzzy-matching
+done
+
+# Update javascript catalogue
+echo ""
+echo "Updating javascript catalogue..."
+for locale in $LOCALES; do
+    echo "  - $locale"
+    pybabel update -i po/javascript.pot -l $locale -o po/javascript_${locale}.po --no-fuzzy-matching
+done

scripts/update_translations.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+set -eu
+
+cd "$(dirname "$(dirname "$0")")"
+find po -name 'main_*.po' | while read fin; do
+    loc=$(echo $fin | sed 's/^po\/main_//' | sed 's/\.po$//')
+    dir=taguette/l10n/$loc/LC_MESSAGES
+    mkdir -p $dir
+    pybabel compile -i $fin -o $dir/taguette_main.mo
+done
+find po -name 'javascript_*.po' | while read fin; do
+    loc=$(echo $fin | sed 's/^po\/javascript_//' | sed 's/\.po$//')
+    dir=taguette/l10n/$loc/LC_MESSAGES
+    mkdir -p $dir
+    pybabel compile -i $fin -o $dir/taguette_javascript.mo
+done

scripts/validate.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+
+import argparse
+import logging
+import os
+import pkg_resources
+from sqlalchemy.orm.exc import ObjectDeletedError
+import sys
+import tornado.locale
+
+from taguette import database, validate, convert
+
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+
+    parser = argparse.ArgumentParser(
+        description="Run validation on an existing database",
+    )
+    parser.add_argument('config_file', help="Configuration file")
+    parser.add_argument('--users', action='store_true',
+                        help="Validate users")
+    parser.add_argument('--projects', action='store_true',
+                        help="Validate project metadata")
+    parser.add_argument('--documents', action='store_true',
+                        help="Validate documents")
+    parser.add_argument('--tags', action='store_true',
+                        help="Validate tags")
+
+    args = parser.parse_args()
+
+    config = {}
+    config_file = os.path.abspath(args.config_file)
+    with open(config_file) as fp:
+        code = compile(fp.read(), config_file, 'exec')
+    exec(code, config)
+
+    DBSession = database.connect(config['DATABASE'])
+    db = DBSession()
+
+    errors = 0
+
+    def check(func, *args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except validate.InvalidFormat:
+            return False
+
+    if args.users:
+        d = pkg_resources.resource_filename('taguette', 'l10n')
+        tornado.locale.load_gettext_translations(d, 'taguette_main')
+
+        for user in db.query(database.User):
+            if not check(validate.user_login, user.login):
+                errors += 1
+                print("Invalid user login: %r" % user.login)
+            if user.email and not check(validate.user_email, user.email):
+                errors += 1
+                print("Invalid user email for %r: %r" % (
+                    user.login,
+                    user.email,
+                ))
+            if (
+                user.language
+                and user.language not in tornado.locale.get_supported_locales()
+            ):
+                errors += 1
+                print("User locale unsupported for %r: %r" % (
+                    user.login,
+                    user.language,
+                ))
+
+    if args.projects:
+        for project in db.query(database.Project):
+            if not check(validate.project_name, project.name):
+                errors += 1
+                print("Invalid project name: %r" % project.name)
+            if not check(validate.description, project.description):
+                errors += 1
+                print("Invalid project description for %d (%r): %r" % (
+                    project.id,
+                    project.name,
+                    project.description,
+                ))
+
+    if args.documents:
+        for document in db.query(database.Document):
+            if not check(validate.document_name, document.name):
+                errors += 1
+                print("Invalid document name for %r: %r" % (
+                    document.id,
+                    document.name,
+                ))
+            if not check(validate.description, document.description):
+                errors += 1
+                print("Invalid document description for %d (%r): %r" % (
+                    document.id,
+                    document.name,
+                    document.description,
+                ))
+            if not check(validate.filename, document.filename):
+                errors += 1
+                print("Invalid document filename for %d (%r): %r" % (
+                    document.id,
+                    document.name,
+                    document.filename,
+                ))
+            try:
+                contents = document.contents
+            except ObjectDeletedError:
+                # The document was deleted since we started iterating
+                pass
+            else:
+                if not convert.is_html_safe(contents):
+                    errors += 1
+                    print("Invalid document contents for %d (%r)" % (
+                        document.id,
+                        document.name,
+                    ))
+
+    if args.tags:
+        for tag in db.query(database.Tag):
+            if not check(validate.tag_path, tag.path):
+                errors += 1
+                print("Invalid tag path for %d: %r" % (tag.id, tag.path))
+            if not check(validate.description, tag.description):
+                errors += 1
+                print("Invalid tag description for %d (%r): %r" % (
+                    tag.id,
+                    tag.path,
+                    tag.description
+                ))
+
+    print("%d errors found" % errors)
+    if errors:
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

scripts/wipe_and_disable_user.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+from sqlalchemy.orm import joinedload
+import sys
+
+from taguette import database
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Wipe user data and disable it",
+    )
+    parser.add_argument('config_file', help="Configuration file")
+    parser.add_argument('user_login')
+    parser.add_argument(
+        '--delete-projects',
+        action='store_true',
+        help="If projects exist, delete them rather than bailing out",
+    )
+
+    args = parser.parse_args()
+
+    config = {}
+    config_file = os.path.abspath(args.config_file)
+    with open(config_file) as fp:
+        code = compile(fp.read(), config_file, 'exec')
+    exec(code, config)
+
+    DBSession = database.connect(config['DATABASE'])
+    db = DBSession()
+
+    user = (
+        db.query(database.User)
+        .options(
+            joinedload(database.User.project_memberships)
+            .options(joinedload(database.ProjectMember.project))
+        )
+        .get(args.user_login)
+    )
+    if user is None:
+        print("No such user: %r" % args.user_login, file=sys.stderr)
+        sys.exit(1)
+
+    if user.disabled:
+        print("User is already disabled")
+        sys.exit(3)
+
+    if not args.delete_projects:
+        sole_admin = False
+
+        for membership in user.project_memberships:
+            project = membership.project
+
+            # Check if that project has other members
+            if not any(
+                member.user_login != user.login
+                for member in project.members
+            ):
+                sole_admin = True
+                print("User is sole member of project %d %r" % (
+                    project.id, project.name,
+                ))
+
+        if sole_admin:
+            sys.exit(1)
+
+    else:
+        for membership in user.project_memberships:
+            project = membership.project
+
+            # Check if that project has other members
+            if not any(
+                member.user_login != user.login
+                for member in project.members
+            ):
+                print("Deleting project %d %r" % (project.id, project.name))
+                db.delete(project)
+
+    user.project_memberships.clear()
+    user.hashed_password = ''
+    user.language = None
+    user.email = None
+    user.disabled = True
+    db.commit()
+
+
+if __name__ == '__main__':
+    main()

taguette/__init__.py

@@ -0,0 +1,13 @@
+__version__ = '1.1.3'
+
+
+from gettext import NullTranslations
+trans = NullTranslations()
+del NullTranslations
+
+
+_exact_version = __version__
+
+
+def exact_version():
+    return _exact_version