Initial dolor3v backend

.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.db
+.env
+instance/
+storage/
+app.app_context
+core

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN python -c "
+import os
+os.environ['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///dolor.db'
+from app import app
+from models import db
+with app.app_context():
+    db.create_all()
+    print('DB initialized')
+"
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

add_balance.py

@@ -0,0 +1,8 @@
+from app import app
+from models import db, User
+
+with app.app_context():
+    u = User.query.filter_by(email="dolor@test.com").first()
+    u.balance = 10000.0
+    db.session.commit()
+    print(f"Balance set to {u.balance} for {u.account_number}")

admin.py

@@ -0,0 +1,35 @@
+from flask import Flask, request, jsonify
+from flask_sqlalchemy import SQLAlchemy
+from flask_cors import CORS
+
+app = Flask(__name__)
+app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///admin.db"
+db = SQLAlchemy(app)
+CORS(app)
+
+class Admin(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(100), nullable=False)
+    password = db.Column(db.String(100), nullable=False)
+
+@app.route("/login", methods=["POST"])
+def login():
+    data = request.get_json()
+    admin = Admin.query.filter_by(username=data["username"], password=data["password"]).first()
+    if admin:
+        return jsonify({"token": "login successful"})
+    return jsonify({"message": "Invalid credentials"})
+
+@app.route("/users", methods=["GET"])
+def users():
+    users = User.query.all()
+    return jsonify([{"id": user.id, "name": user.name, "email": user.email, "account_number": user.account_number, "balance": user.balance} for user in users])
+
+@app.route("/transactions", methods=["GET"])
+def transactions():
+    transactions = Transaction.query.all()
+    return jsonify([{"id": transaction.id, "sender_account_number": transaction.sender_account_number, "recipient_account_number": transaction.recipient_account_number, "amount": transaction.amount} for transaction in transactions])
+
+if __name__ == "__main__":
+    app.run(debug=True)
+

ai_review.py

@@ -0,0 +1,35 @@
+def ai_review_transaction(sender, recipient, amount, is_external):
+    reasons = []
+    decision = "approve"
+
+    # Rule 1: Amount exceeds balance by 80%
+    if amount > sender.balance * 0.8:
+        reasons.append("amount exceeds 80% of balance")
+        decision = "hold"
+
+    # Rule 2: Large transaction
+    if amount > 10000:
+        reasons.append("large transaction above 10,000")
+        decision = "hold"
+
+    # Rule 3: External transfers over 5000 are suspicious
+    if is_external and amount > 5000:
+        reasons.append("high-value external transfer")
+        decision = "hold"
+
+    # Rule 4: Round large numbers externally (common fraud pattern)
+    if is_external and amount >= 1000 and amount % 100 == 0:
+        reasons.append("round-number external transfer flagged for review")
+        decision = "hold"
+
+    # Rule 5: Very small amounts (potential test/probe transactions)
+    if amount < 1:
+        reasons.append("suspiciously small amount")
+        decision = "hold"
+
+    if decision == "approve":
+        reason = "Transaction looks normal"
+    else:
+        reason = "; ".join(reasons)
+
+    return decision, reason

app.py

@@ -0,0 +1,33 @@
+import os
+from flask import Flask, jsonify
+from database import init_db, create_tables
+from endpoints import register, login, transfer, external_transfer, balance, history, alerts, jwt
+from flask_cors import CORS
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DB_PATH = os.path.join(BASE_DIR, 'dolor.db')
+
+app = Flask(__name__)
+app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{DB_PATH}"
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+app.config["JWT_SECRET_KEY"] = "dolor3v-secret-2026"
+
+init_db(app)
+jwt.init_app(app)
+CORS(app)
+
+app.add_url_rule("/register", "register", register, methods=["POST"])
+app.add_url_rule("/login", "login", login, methods=["POST"])
+app.add_url_rule("/transfer", "transfer", transfer, methods=["POST"])
+app.add_url_rule("/external-transfer", "external_transfer", external_transfer, methods=["POST"])
+app.add_url_rule("/balance", "balance", balance, methods=["GET"])
+app.add_url_rule("/history", "history", history, methods=["GET"])
+app.add_url_rule("/alerts", "alerts", alerts, methods=["GET"])
+
+@app.route("/health")
+def health():
+    return jsonify({"status": "ok", "app": "dolor3v", "version": "1.0.0"})
+
+if __name__ == "__main__":
+    create_tables(app)
+    app.run(host="0.0.0.0", port=7860, debug=False)

database.py

@@ -0,0 +1,9 @@
+from models import db
+
+def init_db(app):
+    db.init_app(app)
+
+def create_tables(app):
+    with app.app_context():
+        db.create_all()
+        print("Tables created!")

debug_login.py

@@ -0,0 +1,12 @@
+from app import app
+from models import db, User
+from werkzeug.security import check_password_hash
+
+with app.app_context():
+    print("DB URI:", app.config["SQLALCHEMY_DATABASE_URI"])
+    users = User.query.all()
+    print("Users in DB:", len(users))
+    for u in users:
+        print(f"  email={u.email} password_hash={u.password[:30]}...")
+        result = check_password_hash(u.password, "1234")
+        print(f"  password check for '1234': {result}")

endpoints.py

@@ -0,0 +1,157 @@
+from flask import request, jsonify
+from models import db, User, Transaction, Alert
+from flask_jwt_extended import JWTManager, jwt_required, create_access_token, get_jwt_identity
+from werkzeug.security import generate_password_hash, check_password_hash
+from datetime import datetime
+from ai_review import ai_review_transaction
+import random, string, uuid
+
+jwt = JWTManager()
+
+def generate_account_number():
+    while True:
+        number = "ACC" + "".join(random.choices(string.digits, k=10))
+        if not User.query.filter_by(account_number=number).first():
+            return number
+
+def create_alert(account_number, message):
+    alert = Alert(account_number=account_number, message=message)
+    db.session.add(alert)
+
+def register():
+    data = request.get_json()
+    if User.query.filter_by(email=data["email"]).first():
+        return jsonify({"message": "Email already exists"}), 400
+    user = User(
+        name=data["name"],
+        email=data["email"],
+        password=generate_password_hash(data["password"]),
+        account_number=generate_account_number(),
+    )
+    db.session.add(user)
+    db.session.commit()
+    create_alert(user.account_number, f"Welcome to dolor3v, {user.name}! Your account {user.account_number} is ready.")
+    db.session.commit()
+    return jsonify({"message": "User registered successfully", "account_number": user.account_number})
+
+def login():
+    data = request.get_json()
+    user = User.query.filter_by(email=data["email"]).first()
+    if not user or not check_password_hash(user.password, data["password"]):
+        return jsonify({"message": "Invalid credentials"}), 401
+    access_token = create_access_token(identity=user.account_number)
+    return jsonify({"access_token": access_token, "account_number": user.account_number})
+
+@jwt_required()
+def transfer():
+    data = request.get_json()
+    sender_acc = get_jwt_identity()
+    sender = User.query.filter_by(account_number=sender_acc).first()
+    recipient = User.query.filter_by(account_number=data["recipient_account_number"]).first()
+    if not sender or not recipient:
+        return jsonify({"message": "Invalid account numbers"}), 404
+    if sender.account_number == recipient.account_number:
+        return jsonify({"message": "Cannot transfer to same account"}), 400
+    amount = float(data["amount"])
+    if sender.balance < amount:
+        return jsonify({"message": "Insufficient funds"}), 400
+
+    decision, reason = ai_review_transaction(sender, recipient, amount, False)
+    status = "pending" if decision == "hold" else "completed"
+
+    if status == "completed":
+        sender.balance -= amount
+        recipient.balance += amount
+
+    t = Transaction(
+        sender_account_number=sender.account_number,
+        recipient_account_number=recipient.account_number,
+        amount=amount,
+        status=status,
+        is_external=False,
+        reference=str(uuid.uuid4())[:8].upper(),
+        ai_review=reason,
+    )
+    db.session.add(t)
+    create_alert(sender.account_number, f"Transfer of {amount} to {recipient.account_number} — {status}. Ref: {t.reference}")
+    create_alert(recipient.account_number, f"You received {amount} from {sender.account_number}. Ref: {t.reference}")
+    db.session.commit()
+    return jsonify({"message": f"Transfer {status}", "reference": t.reference, "ai_review": reason})
+
+@jwt_required()
+def external_transfer():
+    data = request.get_json()
+    sender_acc = get_jwt_identity()
+    sender = User.query.filter_by(account_number=sender_acc).first()
+    if not sender:
+        return jsonify({"message": "User not found"}), 404
+    amount = float(data["amount"])
+    if sender.balance < amount:
+        return jsonify({"message": "Insufficient funds"}), 400
+
+    bank_name = data.get("bank_name", "External Bank")
+    recipient_name = data.get("recipient_name", "Unknown")
+
+    decision, reason = ai_review_transaction(sender, recipient_name, amount, True)
+    status = "pending" if decision == "hold" else "processing"
+
+    if status == "processing":
+        sender.balance -= amount
+
+    ref = str(uuid.uuid4())[:8].upper()
+    t = Transaction(
+        sender_account_number=sender.account_number,
+        recipient_account_number=f"EXT:{bank_name}:{data.get('recipient_account')}",
+        amount=amount,
+        status=status,
+        is_external=True,
+        reference=ref,
+        ai_review=reason,
+    )
+    db.session.add(t)
+    create_alert(sender.account_number, f"External transfer of {amount} to {recipient_name} at {bank_name} — {status}. Ref: {ref}")
+    db.session.commit()
+    return jsonify({"message": f"External transfer {status}", "reference": ref, "ai_review": reason})
+
+@jwt_required()
+def balance():
+    account_number = get_jwt_identity()
+    user = User.query.filter_by(account_number=account_number).first()
+    if not user:
+        return jsonify({"message": "Invalid account number"}), 404
+    return jsonify({"balance": user.balance, "account_number": user.account_number})
+
+@jwt_required()
+def history():
+    account_number = get_jwt_identity()
+    txns = Transaction.query.filter(
+        (Transaction.sender_account_number == account_number) |
+        (Transaction.recipient_account_number == account_number)
+    ).order_by(Transaction.timestamp.desc()).all()
+
+    result = []
+    for t in txns:
+        result.append({
+            "id": t.id,
+            "type": "sent" if t.sender_account_number == account_number else "received",
+            "amount": t.amount,
+            "sender": t.sender_account_number,
+            "recipient": t.recipient_account_number,
+            "status": t.status,
+            "reference": t.reference,
+            "is_external": t.is_external,
+            "ai_review": t.ai_review,
+            "timestamp": t.timestamp.isoformat(),
+        })
+    return jsonify({"transactions": result})
+
+@jwt_required()
+def alerts():
+    account_number = get_jwt_identity()
+    unread = Alert.query.filter_by(account_number=account_number, read=False)\
+        .order_by(Alert.timestamp.desc()).all()
+    result = [{"id": a.id, "message": a.message, "timestamp": a.timestamp.isoformat()} for a in unread]
+    for a in unread:
+        a.read = True
+    db.session.commit()
+    return jsonify({"alerts": result})

find_db_name.py

@@ -0,0 +1,7 @@
+from app import app
+
+def main():
+    print(app.config['SQLALCHEMY_DATABASE_URI'])
+
+if __name__ == "__main__":
+    main()

fix_user.py

@@ -0,0 +1,8 @@
+from app import app
+from models import db, User
+
+with app.app_context():
+    u = User.query.filter_by(email="dolor@test.com").first()
+    db.session.delete(u)
+    db.session.commit()
+    print("Deleted old user")

init_db.py

@@ -0,0 +1,3 @@
+from app import app
+from database import create_tables
+create_tables(app)

models.py

@@ -0,0 +1,30 @@
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime
+
+db = SQLAlchemy()
+
+class User(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(100), nullable=False)
+    email = db.Column(db.String(100), nullable=False, unique=True)
+    password = db.Column(db.String(100), nullable=False)
+    account_number = db.Column(db.String(20), nullable=False, unique=True)
+    balance = db.Column(db.Float, nullable=False, default=0.0)
+
+class Transaction(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    sender_account_number = db.Column(db.String(20), nullable=False)
+    recipient_account_number = db.Column(db.String(20), nullable=False)
+    amount = db.Column(db.Float, nullable=False)
+    status = db.Column(db.String(20), nullable=False, default="completed")
+    is_external = db.Column(db.Boolean, default=False)
+    reference = db.Column(db.String(50), nullable=True)
+    ai_review = db.Column(db.String(500), nullable=True)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+
+class Alert(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    account_number = db.Column(db.String(20), nullable=False)
+    message = db.Column(db.String(500), nullable=False)
+    read = db.Column(db.Boolean, default=False)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)

requirements.txt

@@ -0,0 +1,5 @@
+flask
+flask-sqlalchemy
+flask-cors
+flask-jwt-extended
+werkzeug

reset.py

@@ -0,0 +1,17 @@
+import os, sqlite3
+from app import app
+from models import db
+
+db_path = '/data/data/com.termux/files/home/dolor.db'
+
+# Delete old db
+if os.path.exists(db_path):
+    os.remove(db_path)
+    print("Deleted old DB")
+
+# Create fresh with all tables
+with app.app_context():
+    db.create_all()
+    from sqlalchemy import inspect
+    tables = inspect(db.engine).get_table_names()
+    print("Tables created:", tables)

verify_db.py

@@ -0,0 +1,7 @@
+from app import app
+from sqlalchemy import inspect
+
+with app.app_context():
+    from models import db
+    inspector = inspect(db.engine)
+    print("Tables:", inspector.get_table_names())