6 |
7 |
8 |
11 | A simple, self-hosted service to keep track of your personal library.
12 |
13 | 🗒️Explore the docs »
14 |
15 |
16 | 💻View Demo |
17 | 🐞Report Bug |
18 | ✨Request Feature |
19 | 👷Service status
20 |
28 |
29 |
30 | > [!IMPORTANT]
31 | > * This project is under **active** development.
32 | > * Expect bugs and breaking changes.
33 |
34 | ## ✨Features
35 | * Easily look up books by title or isbn. Powered by [OpenLibrary](https://openlibrary.org/)
36 | * Add books to predefined lists, reading, already read and to be read.
37 | * Keep track of what page you are on with your current book.
38 | * Have a public profile of your library available to all.
39 | * Rate you read books with 0.5-5 stars.
40 | * Take short notes and quotes on the books you read.
41 | * Automatically share your progress to Mastodon.
42 |
43 | ## 🖥 Install
44 | BookLogr is made to be self-hosted and run on your own hardware.
45 |
46 | See [how to install with Docker](https://github.com/Mozzo1000/booklogr/wiki/Install-with-Docker) to get started.
47 |
48 | ## 🛠️Development
49 | See [development instructions](https://github.com/Mozzo1000/booklogr/wiki/Development) on the wiki to get started.
50 |
51 | ## 🙌Contributing
52 | All contributions are welcome!
53 |
54 | ## 🧾License
55 | This project is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for the full license text.
--------------------------------------------------------------------------------
/api/README.md:
--------------------------------------------------------------------------------
1 | # minimal-reading-api
--------------------------------------------------------------------------------
/api/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask
2 | from flask_jwt_extended import JWTManager, jwt_required
3 | from flask_cors import CORS
4 | from api.config import Config
5 | from flask_migrate import Migrate
6 | from api.models import db, ma
7 | from api.routes.books import books_endpoint
8 | from api.routes.profiles import profiles_endpoint
9 | from api.routes.notes import notes_endpoint
10 | from api.routes.tasks import tasks_endpoint
11 | from api.routes.files import files_endpoint
12 | from api.routes.settings import settings_endpoint
13 | from flasgger import Swagger
14 | from api.auth.auth_route import auth_endpoint
15 | from api.auth.user_route import user_endpoint
16 |
17 | app = Flask(__name__)
18 | CORS(app)
19 |
20 | app.config.from_object(Config)
21 | swagger = Swagger(app)
22 |
23 | db.init_app(app)
24 | ma.init_app(app)
25 | migrate = Migrate(app, db)
26 | jwt = JWTManager(app)
27 |
28 | app.register_blueprint(books_endpoint)
29 | app.register_blueprint(profiles_endpoint)
30 | app.register_blueprint(notes_endpoint)
31 | app.register_blueprint(tasks_endpoint)
32 | app.register_blueprint(files_endpoint)
33 | app.register_blueprint(settings_endpoint)
34 |
35 | app.register_blueprint(auth_endpoint)
36 | app.register_blueprint(user_endpoint)
37 |
38 | @app.route("/")
39 | def index():
40 | return {
41 | "name": "minimal-reading-api",
42 | "version": "1.0.0"
43 | }
--------------------------------------------------------------------------------
/api/auth/decorators.py:
--------------------------------------------------------------------------------
1 | from flask_jwt_extended import verify_jwt_in_request, get_jwt
2 | from flask import jsonify
3 | from functools import wraps
4 |
5 | def require_role(role):
6 | def wrapper(fn):
7 | @wraps(fn)
8 | def decorator(*args, **kwargs):
9 | verify_jwt_in_request()
10 | claims = get_jwt()
11 | if claims["role"] == role:
12 | return fn(*args, **kwargs)
13 | else:
14 | return jsonify({'error': 'Permission denied', 'message': 'You do not have the required permission.'}), 403
15 | return decorator
16 | return wrapper
17 |
18 | def disable_route(value=False):
19 | def wrapper(fn):
20 | @wraps(fn)
21 | def decorator(*args, **kwargs):
22 | print(value)
23 | if value.lower() in ["true", "yes", "y"]:
24 | return fn(*args, **kwargs)
25 | else:
26 | return jsonify({'error': 'Route disabled', 'message': 'This route has been disabled by the administrator.'}), 403
27 | return decorator
28 | return wrapper
--------------------------------------------------------------------------------
/api/auth/models.py:
--------------------------------------------------------------------------------
1 | from flask_sqlalchemy import SQLAlchemy
2 | from flask_marshmallow import Marshmallow, fields
3 | import uuid
4 | from werkzeug.security import generate_password_hash, check_password_hash
5 | from api.models import db, ma
6 |
7 | class Verification(db.Model):
8 | __tablename__ = "verification"
9 | id = db.Column(db.Integer, primary_key=True)
10 | user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
11 | status = db.Column(db.String, default="unverified")
12 | code = db.Column(db.String, nullable=True)
13 | code_valid_until = db.Column(db.DateTime, nullable=True)
14 |
15 | def save_to_db(self):
16 | db.session.add(self)
17 | db.session.commit()
18 |
19 | class VerificationSchema(ma.SQLAlchemyAutoSchema):
20 | class Meta:
21 | model = Verification
22 | fields = ("status",)
23 |
24 |
25 | class User(db.Model):
26 | __tablename__ = 'users'
27 | id = db.Column(db.Integer, primary_key=True)
28 | email = db.Column(db.String, nullable=False, unique=True)
29 | name = db.Column(db.String, nullable=False)
30 | password = db.Column(db.String, nullable=False)
31 | role = db.Column(db.String, default="user")
32 | status = db.Column(db.String, default="active")
33 | verification = db.relationship("Verification", uselist=False, backref="verification")
34 |
35 |
36 | def save_to_db(self):
37 | db.session.add(self)
38 | db.session.commit()
39 |
40 | @classmethod
41 | def find_by_email(cls, email):
42 | return cls.query.filter_by(email=email).first()
43 |
44 | @staticmethod
45 | def generate_hash(password):
46 | return generate_password_hash(password)
47 |
48 | @staticmethod
49 | def verify_hash(password, hash):
50 | return check_password_hash(hash, password)
51 |
52 | class UserSchema(ma.SQLAlchemyAutoSchema):
53 | verification = ma.Nested(VerificationSchema())
54 | class Meta:
55 | model = User
56 | fields = ("id", "name", "email", "role", "status", "verification")
57 |
58 | class RevokedTokenModel(db.Model):
59 | __tablename__ = 'revoked_tokens'
60 |
61 | id = db.Column(db.Integer, primary_key=True)
62 | jti = db.Column(db.String(120))
63 |
64 | def add(self):
65 | db.session.add(self)
66 | db.session.commit()
67 |
68 | @classmethod
69 | def is_jti_blacklisted(cls, jti):
70 | query = cls.query.filter_by(jti=jti).first()
71 | return bool(query)
--------------------------------------------------------------------------------
/api/auth/user_route.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint, jsonify
2 | from api.auth.models import User, UserSchema
3 | from api.auth.decorators import require_role
4 | from flask_jwt_extended import jwt_required, get_jwt_identity
5 |
6 | user_endpoint = Blueprint('user_endpoint', __name__)
7 |
8 | @user_endpoint.route("/v1/users/me", methods=["GET"])
9 | @jwt_required()
10 | def get_logged_in_user():
11 | user_schema = UserSchema(many=False)
12 | user = User.query.filter_by(email=get_jwt_identity()).first()
13 | return jsonify(user_schema.dump(user))
14 |
15 |
16 | @user_endpoint.route('/v1/users', methods=["GET"])
17 | @require_role("internal_admin")
18 | def get_all_users():
19 | user_schema = UserSchema(many=True)
20 | users = User.query.all()
21 | return jsonify(user_schema.dump(users))
--------------------------------------------------------------------------------
/api/config.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | class Config:
4 | CSRF_ENABLED = True
5 | SECRET_KEY = os.environ.get("AUTH_SECRET_KEY", "this-really-needs-to-be-changed")
6 | SQLALCHEMY_TRACK_MODIFICATIONS = False
7 | SQLALCHEMY_DATABASE_URI = os.environ.get("DATABASE_URL", "postgresql://admin:password@localhost/booklogr")
8 | SWAGGER = {
9 | "openapi": "3.0.0",
10 | "info": {
11 | "title": "BookLogr API",
12 | "description": "API for accessing BookLogr",
13 | "contact": {
14 | "url": "https://github.com/mozzo1000/booklogr",
15 | },
16 | "version": "1.0.0"
17 | },
18 | "components": {
19 | "securitySchemes": {
20 | "bearerAuth": {
21 | "type": "http",
22 | "scheme": "bearer",
23 | "bearerFormat": "JWT" # optional, arbitrary value for documentation purposes
24 | }
25 | }
26 |
27 | },
28 | "specs_route": "/docs"
29 | }
--------------------------------------------------------------------------------
/api/decorators.py:
--------------------------------------------------------------------------------
1 | from flask import jsonify, request
2 | from functools import wraps
3 |
4 | def required_params(*args):
5 | """Decorator factory to check request data for POST requests and return
6 | an error if required parameters are missing."""
7 | required = list(args)
8 |
9 | def decorator(fn):
10 | """Decorator that checks for the required parameters"""
11 |
12 | @wraps(fn)
13 | def wrapper(*args, **kwargs):
14 | missing = [r for r in required if r not in request.get_json()]
15 | if missing:
16 | response = {
17 | "status": "error",
18 | "message": "Request JSON is missing some required params",
19 | "missing": missing
20 | }
21 | return jsonify(response), 400
22 | return fn(*args, **kwargs)
23 | return wrapper
24 | return decorator
--------------------------------------------------------------------------------
/api/models.py:
--------------------------------------------------------------------------------
1 | from flask_sqlalchemy import SQLAlchemy
2 | from flask_marshmallow import Marshmallow, fields
3 | import uuid
4 | from werkzeug.security import generate_password_hash, check_password_hash
5 | from marshmallow import post_dump
6 | db = SQLAlchemy()
7 | ma = Marshmallow()
8 |
9 | class Files(db.Model):
10 | __tablename__ = "files"
11 | id = db.Column(db.Integer, primary_key=True)
12 | filename = db.Column(db.String)
13 | owner_id = db.Column(db.Integer)
14 | created_at = db.Column(db.DateTime, server_default=db.func.now())
15 |
16 | class FilesSchema(ma.SQLAlchemyAutoSchema):
17 | class Meta:
18 | model = Files
19 | fields = ("id", "filename", "created_at",)
20 |
21 | class Tasks(db.Model):
22 | __tablename__ = "tasks"
23 | id = db.Column(db.Integer, primary_key=True)
24 | type = db.Column(db.String)
25 | data = db.Column(db.String)
26 | status = db.Column(db.String, default="fresh")
27 | worker = db.Column(db.String, nullable=True)
28 | created_on = db.Column(db.DateTime, server_default=db.func.now())
29 | updated_on = db.Column(db.DateTime, nullable=True)
30 | created_by = db.Column(db.Integer)
31 |
32 | def save_to_db(self):
33 | db.session.add(self)
34 | db.session.commit()
35 |
36 | class TasksSchema(ma.SQLAlchemyAutoSchema):
37 | class Meta:
38 | model = Tasks
39 |
40 |
41 | class Notes(db.Model):
42 | __tablename__ = "notes"
43 | id = db.Column(db.Integer, primary_key=True)
44 | book_id = db.Column(db.Integer, db.ForeignKey("books.id"))
45 | content = db.Column(db.String, nullable=False)
46 | quote_page = db.Column(db.Integer, nullable=True)
47 | visibility = db.Column(db.String, default="hidden")
48 | created_on = db.Column(db.DateTime, server_default=db.func.now())
49 |
50 | def save_to_db(self):
51 | db.session.add(self)
52 | db.session.commit()
53 |
54 | def delete(self):
55 | db.session.delete(self)
56 | db.session.commit()
57 |
58 | class NotesSchema(ma.SQLAlchemyAutoSchema):
59 | class Meta:
60 | model = Notes
61 |
62 | class NotesPublicOnlySchema(ma.SQLAlchemyAutoSchema):
63 | class Meta:
64 | model = Notes
65 |
66 | SKIP_VALUES = set([None])
67 |
68 | @post_dump
69 | def remove_hidden_notes(self, data, **kwargs):
70 | if data["visibility"] == "hidden":
71 | return
72 | else:
73 | return {
74 | key: value for key, value in data.items()
75 | if value not in self.SKIP_VALUES
76 | }
77 |
78 |
79 | class Profile(db.Model):
80 | __tablename__ = "profiles"
81 | id = db.Column(db.Integer, primary_key=True)
82 | display_name = db.Column(db.String, unique=True)
83 | visibility = db.Column(db.String, default="hidden")
84 | owner_id = db.Column(db.Integer, unique=True)
85 | books = db.relationship("Books", backref='profiles')
86 |
87 | def save_to_db(self):
88 | db.session.add(self)
89 | db.session.commit()
90 |
91 | class Books(db.Model):
92 | __tablename__ = "books"
93 | id = db.Column(db.Integer, primary_key=True)
94 | title = db.Column(db.String)
95 | isbn = db.Column(db.String)
96 | description = db.Column(db.String)
97 | author = db.Column(db.String)
98 | reading_status = db.Column(db.String)
99 | current_page = db.Column(db.Integer)
100 | total_pages = db.Column(db.Integer)
101 | rating = db.Column(db.Numeric(precision=3, scale=2), nullable=True)
102 | owner_id = db.Column(db.Integer, db.ForeignKey("profiles.owner_id"))
103 | notes = db.relationship("Notes", backref="books")
104 |
105 | def save_to_db(self):
106 | db.session.add(self)
107 | db.session.commit()
108 |
109 | def delete(self):
110 | db.session.delete(self)
111 | db.session.commit()
112 |
113 | class BooksSchema(ma.SQLAlchemyAutoSchema):
114 | num_notes = ma.Method("get_num_notes")
115 | class Meta:
116 | model = Books
117 |
118 | def get_num_notes(self, obj):
119 | query = Notes.query.filter(Notes.book_id==obj.id).count()
120 | if query:
121 | return query
122 | else:
123 | return 0
124 |
125 | class BooksPublicOnlySchema(ma.SQLAlchemyAutoSchema):
126 | notes = ma.Nested(NotesPublicOnlySchema(many=True))
127 | num_notes = ma.Method("get_num_notes")
128 | class Meta:
129 | model = Books
130 |
131 | def get_num_notes(self, obj):
132 | query = Notes.query.filter(Notes.book_id==obj.id, Notes.visibility=="public").count()
133 | if query:
134 | return query
135 | else:
136 | return 0
137 |
138 | class ProfileSchema(ma.SQLAlchemyAutoSchema):
139 | books = ma.List(ma.Nested(BooksPublicOnlySchema(only=("author", "description", "current_page", "total_pages", "reading_status", "title", "isbn", "rating", "notes", "num_notes"))))
140 | num_books_read = ma.Method("get_num_books_read")
141 | num_books_reading = ma.Method("get_num_books_currently_reading")
142 | num_books_tbr = ma.Method("get_num_books_to_be_read")
143 |
144 |
145 | def get_num_books_read(self, obj):
146 | query = Books.query.filter(Books.owner_id==obj.owner_id, Books.reading_status=="Read").count()
147 | if query:
148 | return query
149 | else:
150 | return None
151 |
152 | def get_num_books_currently_reading(self, obj):
153 | query = Books.query.filter(Books.owner_id==obj.owner_id, Books.reading_status=="Currently reading").count()
154 | if query:
155 | return query
156 | else:
157 | return None
158 |
159 | def get_num_books_to_be_read(self, obj):
160 | query = Books.query.filter(Books.owner_id==obj.owner_id, Books.reading_status=="To be read").count()
161 | if query:
162 | return query
163 | else:
164 | return None
165 |
166 | class Meta:
167 | model = Profile()
168 | fields = ("id", "display_name", "visibility", "books", "num_books_read", "num_books_reading", "num_books_tbr",)
169 |
170 |
171 | class UserSettings(db.Model):
172 | __tablename__ = "user_settings"
173 | id = db.Column(db.Integer, primary_key=True)
174 | owner_id = db.Column(db.Integer, unique=True)
175 | send_book_events = db.Column(db.Boolean, default=False)
176 | mastodon_url = db.Column(db.String, nullable=True)
177 | mastodon_access_token = db.Column(db.String, nullable=True)
178 | created_at = db.Column(db.DateTime, server_default=db.func.now())
179 | updated_on = db.Column(db.DateTime, nullable=True)
180 |
181 | def save_to_db(self):
182 | db.session.add(self)
183 | db.session.commit()
184 |
185 | class UserSettingsSchema(ma.SQLAlchemyAutoSchema):
186 | class Meta:
187 | model = UserSettings
--------------------------------------------------------------------------------
/api/routes/files.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint, send_from_directory, jsonify
2 | from flask_jwt_extended import jwt_required, get_jwt
3 | from api.models import Files, FilesSchema
4 | import os
5 |
6 | files_endpoint = Blueprint('files', __name__)
7 |
8 | @files_endpoint.route("/v1/files/Book title: {props.data?.title}
63 |ISBN: {props.isbn}
64 |{props.text}
14 |You can request a copy of all your data. Once the request has finished, the data will be displayed in the "Available exports" table for you to download.
41 |
13 | Add your books to lists depending on if you have read them, are 17 | currently reading or want to read.
18 |Let your friends see what kind of exciting book you are currently reading and have read in the past
24 |
27 | 
32 | With search and catalog powered by OpenLibrary, there are millions of books in our catalog with more added each day.
36 |Run BookLogr on your own hardware and have complete control over your data
58 |
}
19 | />
20 | by {props.author}
25 | 26 | {props.showReadingStatusBadge && 27 |{props.rating}
62 |How many stars would you like to give {props.title}?
80 |There does not seem to be any books in this list. Use the search to find a book and add it to your list.
88 |See guide for how to connect your Mastodon account to BookLogr.
71 |
25 | BookLogr
26 | {props.notes}
15 |}
108 | />
109 | {data.name}
113 | {data.isbn} 114 | 115 |Try searching for a different title or isbn.
128 |Search powered by OpenLibrary
144 | } 145 |{
I am on page
64 |out of {props.totalPages}
66 | 67 |![]({"/medal.svg"})
86 | On finishing reading {props.title}
89 | 90 |Rate this book
93 |A display name will be used on your profile page that lists all your books. A profile page can be private or public. Display name and visibility of the profile page can be changed at any time.
23 |Your display name will also be used for a link to your profile page if you have set it to public.
24 |Why don't you start by adding some of your favorites books to your lists? It's super simple!
114 | 115 |}
67 | />
68 | by {data?.author_name?.[0] ||
{description ||
75 | Pages
76 | {loading ? (
77 |
ISBN {id}
83 |Track your reading progress and share your library with friends using BookLogr.
29 |
35 | This is a demo of BookLogr
45 |Some features are disabled.
46 |To login use,
48 |A verification code has been sent to {maskEmail(email)}
53 | } 54 | 71 || Title | 29 |Author | 30 |Description | 31 |ISBN | 32 |Reading status | 33 |Total pages | 34 |Current page | 35 |Rating | 36 |
|---|---|---|---|---|---|---|---|
| {{ item.title }} | 40 |{{ item.author }} | 41 |{{ item.description }} | 42 |{{ item.isbn }} | 43 |{{ item.reading_status }} | 44 |{{ item.total_pages }} | 45 |{{ item.current_page }} | 46 |{{ item.rating }} | 47 |