openwrite 0.10.1__py3-none-any.whl

openwrite/routes/federation.py

@@ -0,0 +1,284 @@
+from flask import Blueprint, render_template, redirect, g, jsonify, request, abort, Response
+from openwrite.utils.models import Blog, User, Like, Post
+from openwrite.utils.helpers import verify_http_signature, send_activity, anonymize
+import json
+import requests
+from datetime import datetime, timezone
+
+federation_bp = Blueprint("federation", __name__) 
+
+@federation_bp.route("/.well-known/webfinger")
+def webfinger():
+    resource = request.args.get("resource")
+    if not resource or not resource.startswith("acct:"):
+        abort(400)
+
+    blogname = resource.split(":")[1].split("@")[0]
+    b_count = g.db.query(Blog).filter_by(name=blogname).count()
+    if not b_count or b_count < 1:
+        abort(404)
+    data = {
+        "subject": f"acct:{blogname}@{g.main_domain}",
+        "links": [{
+            "rel": "self",
+            "type": "application/activity+json",
+            "href": f"https://{g.main_domain}/activity/{blogname}"
+        }]
+    }
+
+    return Response(
+        response=json.dumps(data),
+        status=200,
+        content_type="application/jrd+json"
+    )
+
+@federation_bp.route("/activity/<blog>")
+def activity(blog):
+    b = g.db.query(Blog).filter_by(name=blog).first()
+    if not b:
+        abort(404)
+
+    if b.access == "domain":
+        url = f"https://{blog}.{g.main_domain}"
+    else:
+        url = f"https://{g.main_domain}/b/{blog}"
+
+    published = b.created
+    dt = datetime.strptime(str(published), "%Y-%m-%d %H:%M:%S")
+    dt = dt.replace(tzinfo=timezone.utc)
+    iso = dt.isoformat(timespec="seconds").replace("+00:00", "Z")   
+
+    actor = {
+        "@context": [
+            "https://www.w3.org/ns/activitystreams",
+            "https://w3id.org/security/v1"
+        ],
+        "id": f"https://{g.main_domain}/activity/{blog}",
+        "type": "Person",
+        "preferredUsername": blog,
+        "name": blog,
+        "summary": f"{blog} - Blog on {g.main_domain}",
+        "inbox": f"https://{g.main_domain}/inbox/{blog}",
+        "outbox": f"https://{g.main_domain}/outbox/{blog}",
+        "followers": f"https://{g.main_domain}/followers/{blog}",
+        "published": iso,
+        "manuallyApprovesFollowers": False,
+        "discoverable": True,
+        "indexable": True,
+        "url": url,
+        "publicKey": {
+            "id": f"https://{g.main_domain}/activity/{blog}#main-key",
+            "owner": f"https://{g.main_domain}/activity/{blog}",
+            "publicKeyPem": b.pub_key
+        },
+        "icon": {
+            "type": "Image",
+            "mediaType": "image/png",
+            "url": f"https://{g.main_domain}/static/avatar.png"
+        }
+    }
+
+    return Response(json.dumps(actor), content_type="application/activity+json")
+
+@federation_bp.route("/inbox/<blog>", methods=["POST"])
+def inbox(blog):
+    b = g.db.query(Blog).filter_by(name=blog).first()
+    if not b:
+        abort(404)
+
+    data = request.get_json()
+    if not data:
+        return "Bad Request", 400
+
+    #print(f"""
+    #   Data received:
+
+    #        {data}
+    #""")
+
+    body = request.get_data(as_text=True)
+    sign = verify_http_signature(request.headers, body, blog)
+    if not sign:
+        return "Bad signature", 400
+    if data.get("type") == "Follow":
+        actor = data.get("actor")
+        object_ = data.get("object")
+        id_ = data.get("id")
+
+        if object_ != f"https://{g.main_domain}/activity/{blog}":
+            return "Invalid target", 400
+
+        followers = []
+        if b.followers not in (None, "null", "NULL"):
+            followers = json.loads(b.followers)
+        if actor not in followers:
+            followers.append(actor)
+        b.followers = json.dumps(followers)
+        g.db.commit()
+
+        activity = {
+          "@context": "https://www.w3.org/ns/activitystreams",
+          "id": f"https://{g.main_domain}/activity/{blog}#accept-{id_.split('/')[-1]}",
+          "type": "Accept",
+          "actor": f"https://{g.main_domain}/activity/{blog}",
+          "object": data,
+          "to": [f"{actor}"]
+        }
+        
+        actor_doc = requests.get(actor, headers={"Accept": "application/activity+json"}).json()
+        inbox = actor_doc.get("endpoints", {}).get("sharedInbox", actor)
+
+        from_ = f"https://{g.main_domain}/activity/{blog}"
+        send_activity(activity, b.priv_key, from_, f"{actor}/inbox")
+
+        return "", 202
+
+    elif data.get("type") == "Undo":
+        actor = data.get("actor")
+        object_ = data.get("object")
+        
+        if object_['type'] == "Follow":
+            if object_['object'] != f"https://{g.main_domain}/activity/{blog}":
+                return "Invalid target", 400
+
+            followers = []
+            if b.followers not in (None, "null", "NULL"):
+                followers = json.loads(b.followers)
+            if actor in followers:
+                followers = followers.remove(actor)
+            b.followers = json.dumps(followers)
+            g.db.commit()
+
+        elif object_['type'] == "Like":
+            post_name = object_['object'].split("/")[-1]
+            if object_['object'].split("/")[2] == g.main_domain:
+                blog_name = object_['object'].split("/")[-2]
+            else:
+                blog_name = object_['object'].split("/")[2].split('.')[0]
+            blog = g.db.query(Blog).filter_by(name=blog_name).first()
+            blog_id = blog.id
+            post = g.db.query(Post).filter(Post.blog == blog_id, Post.link == post_name).first()
+            post_id = post.id
+
+            hashed = anonymize(actor)
+            like = g.db.query(Like).filter(Like.blog == blog_id, Like.post == post_id, Like.hash == hashed).first()
+            g.db.delete(like)
+            g.db.commit()
+        
+        return "", 202
+
+    elif data.get("type") == "Like":
+        object_ = data.get("object")
+        actor = data.get("actor")
+        post_name = object_.split("/")[-1]
+        if object_.split("/")[2] == g.main_domain:
+            blog_name = object_.split("/")[-2]
+        else:
+            blog_name = object_.split("/")[2].split('.')[0]
+        blog = g.db.query(Blog).filter_by(name=blog_name).first()
+        blog_id = blog.id
+        post = g.db.query(Post).filter(Post.blog == blog_id, Post.link == post_name).first()
+        post_id = post.id
+
+        hashed = anonymize(actor)
+        like = Like(hash=hashed, blog=blog_id, post=post_id)
+        g.db.add(like)
+        g.db.commit()
+
+    return "", 202
+
+@federation_bp.route("/outbox/<blog>")
+def outbox(blog):
+    page = request.args.get("page")
+    b = g.db.query(Blog).filter_by(name=blog).first()
+    if not b:
+        abort(404)
+
+    p = g.db.query(Post).filter_by(blog=b.id)
+    total = p.count()
+    posts = p.all()
+    first_outbox = {
+      "@context": "https://www.w3.org/ns/activitystreams",
+      "id": f"https://openwrite.io/outbox/{blog}",
+      "type": "OrderedCollection",
+      "totalItems": total,
+      "first": f"https://openwrite.io/outbox/{blog}?page=1"
+    }
+
+    if page not in ("true", "1"):
+        return Response(json.dumps(first_outbox), content_type="application/activity+json")
+
+
+    orderedPosts = []
+    if b.access == "path":
+        url = f"https://{g.main_domain}/b/{blog}"
+    else:
+        url = f"https://{blog}.{g.main_domain}"
+    for post in posts:
+        dt = datetime.strptime(str(post.date), "%Y-%m-%d %H:%M:%S")
+        dt = dt.replace(tzinfo=timezone.utc)
+        iso = dt.isoformat(timespec="seconds").replace("+00:00", "Z")   
+        orderedPosts.append({
+            "id": f"https://{g.main_domain}/activity/{blog}#{post.link}",
+            "type": "Create",
+            "actor": f"https://{g.main_domain}/activity/{blog}",
+            "object": {
+                "id": f"{url}/{post.link}",
+                "type": "Note",
+                "attributedTo": f"https://{g.main_domain}/activity/{blog}",
+                "content": f"<p>{post.title}</p><a href=\"{url}/{post.link}\">{url}/{post.link}</a>",
+                "published": iso
+            },
+            "published": iso,
+            "to": ["https://www.w3.org/ns/activitystreams#Public"]
+        })
+
+    outbox = {
+      "@context": "https://www.w3.org/ns/activitystreams",
+      "id": f"https://openwrite.io/outbox/{blog}?page={page}",
+      "type": "OrderedCollectionPage",
+      "partOf": f"https://{g.main_domain}/outbox/{blog}",
+      "orderedItems": orderedPosts
+    }
+
+    return Response(json.dumps(outbox), content_type="application/activity+json")
+
+@federation_bp.route("/followers/<blog>")
+def followers(blog):
+    page = request.args.get("page")
+    b = g.db.query(Blog).filter_by(name=blog).first()
+    if not b:
+        abort(404)
+
+    followers = []
+    if b.followers not in (None, "null", "NULL"):
+        followers = json.loads(b.followers)
+
+    if page not in ("true", "1"):
+        data = {
+          "@context": "https://www.w3.org/ns/activitystreams",
+          "id": f"https://{g.main_domain}/followers/{blog}",
+          "type": "OrderedCollection",
+          "totalItems": len(followers),
+          "first": {
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "id": f"https://{g.main_domain}/followers/{blog}?page=true",
+            "type": "OrderedCollectionPage",
+            "partOf": f"https://{g.main_domain}.followers/{blog}",
+            "totalItems": len(followers),
+            "orderedItems": followers
+          }
+        }
+
+        return Response(json.dumps(data), content_type="application/activity+json")
+
+    data = {
+      "@context": "https://www.w3.org/ns/activitystreams",
+      "id": f"https://{g.main_domain}/followers/{blog}?page={page}",
+      "type": "OrderedCollectionPage",
+      "totalItems": len(followers),
+      "partOf": f"https://{g.main_domain}/followers/{blog}",
+      "orderedItems": followers
+    }
+
+    return Response(json.dumps(data), content_type="application/activity+json")

openwrite/routes/main.py

@@ -0,0 +1,96 @@
+from flask import Blueprint, render_template, redirect, request, make_response, g
+import os
+import json
+import datetime
+import requests
+from openwrite.utils.models import Post, Blog, Home, Settings
+import time
+from openwrite import start_time
+
+from sqlalchemy import desc
+
+main_bp = Blueprint("main", __name__)
+
+@main_bp.route("/")
+def index():
+    if g.mode == "multi":
+        home = g.db.query(Home).filter_by(name="hometext").all()
+        return render_template('index.html', home=home)
+
+    elif g.mode == "single":
+        blog = g.db.query(Blog).filter_by(name="default").first()
+        posts = g.db.query(Post).filter_by(blog=blog.id).all()
+        return render_template('blog.html', blog=blog, posts=posts)
+
+@main_bp.route("/set-lang/<lang_code>")
+def set_lang(lang_code):
+    if lang_code not in g.alltrans:
+        return redirect("/")
+    resp = make_response(redirect(request.referrer or "/"))
+    resp.set_cookie("lang", lang_code, max_age=60*60*24*365)
+    return resp
+
+@main_bp.route("/instances")
+def instances():
+    if g.mode == "single":
+        return redirect("/")
+    instances = ["https://openwrite.io"]  
+    instances_data = []
+
+    for i in instances:
+        try:
+            response = requests.get(f"{i}/.well-known/openwrite")
+            response.raise_for_status()
+            data = response.json()
+            uptime = str(datetime.timedelta(seconds=data['uptime']))
+            instances_data.append({
+                "name": data['name'],
+                "url": i,
+                "users": data['users'],
+                "uptime": uptime,
+                "version": data['version'],
+                "blogs": data['blogs'],
+                "register": data['register'],
+                "media": data['media']
+            })
+        except Exception:
+            continue
+
+    return render_template("instances.html", instances=instances_data)
+
+@main_bp.route("/discover")
+def discover():
+    if g.mode == "single":
+        return redirect("/")
+    posts = g.db.query(Post).filter_by(feed=1).order_by(desc(Post.id)).all()
+    for p in posts:
+        b = g.db.query(Blog).filter_by(id=p.blog).first()
+        if not b:
+            continue
+        if b.access == "path":
+            url = f"https://{os.getenv('DOMAIN')}/b/{b.name}/{p.link}"
+        elif b.access == "domain":
+            url = f"https://{b.name}.{os.getenv('DOMAIN')}/{p.link}"
+        else:
+            url = "#"
+        p.url = url
+        p.blogname = b.title
+
+    return render_template("discover.html", posts=posts)
+
+@main_bp.route('/.well-known/openwrite')
+def show_instance():
+    from openwrite.utils.models import Blog, User 
+    import time
+    blog_count = g.db.query(Blog).count()
+    user_count = g.db.query(User).count()
+    return {
+        "version": os.getenv("VERSION"),
+        "blogs": blog_count,
+        "users": user_count,
+        "uptime": int(time.time() - int(start_time)),
+        "name": os.getenv("DOMAIN"),
+        "register": os.getenv("SELF_REGISTER"),
+        "media": os.getenv("MEDIA_UPLOAD")
+    }
+

openwrite/routes/upload.py

@@ -0,0 +1,81 @@
+from flask import Blueprint, request, jsonify, g, send_from_directory, abort
+from openwrite.utils.models import User
+from werkzeug.utils import secure_filename
+from PIL import Image
+import os
+import hashlib
+import requests
+
+upload_bp = Blueprint("upload", __name__)
+
+UPLOAD_ENABLED = os.getenv("MEDIA_UPLOAD", "no") == "yes"
+STORAGE_BACKEND = os.getenv("UPLOAD_STORAGE", "local")
+BUNNY_API_KEY = os.getenv("BUNNY_API_KEY")
+BUNNY_ZONE = os.getenv("BUNNY_STORAGE_ZONE")
+BUNNY_URL = os.getenv("BUNNY_STORAGE_URL")
+LOCAL_UPLOAD_DIR = os.getenv("UPLOAD_PATH", "uploads")
+ALLOWED_EXTENSIONS = {"png", "jpg", "jpeg", "gif", "webp"}
+
+@upload_bp.route("/upload_image", methods=["POST"])
+def upload_image():
+    if not UPLOAD_ENABLED:
+        return jsonify({"error": g.trans['uploads_disabled']}), 403
+
+    if 'file' not in request.files:
+        return jsonify({"error": g.trans['no_file']}), 400
+
+    if g.user is None:
+        return jsonify({"error": "unauthorized"}), 403
+
+    file = request.files['file']
+    filename = file.filename
+    if "." not in filename:
+        return jsonify({"error": g.trans['invalid_filename']}), 400
+
+    extension = filename.rsplit('.', 1)[1].lower()
+    if extension not in ALLOWED_EXTENSIONS:
+        return jsonify({"error": g.trans['unsupported_filetype']}), 400
+
+    try:
+        img = Image.open(file.stream)
+        img.verify()
+    except Exception:
+        return jsonify({"error": g.trans['not_image']}), 400
+
+    file.stream.seek(0)
+    user = g.db.query(User).filter_by(id=g.user).first()
+
+    m = hashlib.md5()
+    m.update(filename.encode() + user.username.encode())
+    filename = f"{user.username}_{m.hexdigest()}.{extension}"
+
+    if STORAGE_BACKEND == "bunny":
+        url = f"https://storage.bunnycdn.com/{BUNNY_ZONE}/{filename}"
+        headers = {
+            "AccessKey": BUNNY_API_KEY,
+            "Content-Type": "application/octet-stream",
+            "accept": "application/json"
+        }
+        response = requests.put(url, headers=headers, data=file)
+        if response.ok:
+            return jsonify({"url": f"{BUNNY_URL}{filename}"})
+        else:
+            return jsonify({"error": g.trans['upload_failed'], "detail": response.text}), 500
+
+    elif STORAGE_BACKEND == "local":
+        os.makedirs(LOCAL_UPLOAD_DIR, exist_ok=True)
+        filepath = os.path.join(LOCAL_UPLOAD_DIR, filename)
+        file.save(filepath)
+        return jsonify({"url": f"/uploads/{filename}"})
+
+    return jsonify({"error": g.trans['upload_failed']}), 500
+
+@upload_bp.route("/uploads/<file>")
+def get_file(file):
+    filename = secure_filename(file)
+    filepath = os.path.join(LOCAL_UPLOAD_DIR, filename)
+
+    if not os.path.isfile(filepath):
+        abort(404)
+
+    return send_from_directory(LOCAL_UPLOAD_DIR, filename)