Пример #1
0
def get_account(user_id: str) -> Optional[User]:
    with open_db() as db:
        row = db.fetchone(
            "SELECT id, email, pass as password FROM accounts WHERE id = ?",
            (user_id, ))

    return User(**row) if row else None
Пример #2
0
def get_user(user_id: str) -> Optional[User]:
    with open_db() as db:
        user = db.fetchone("SELECT id, email FROM accounts WHERE id = ?",
                           (user_id, ))

        if user:
            extensions = db.fetchall(
                "SELECT extension FROM extensions WHERE user = ? AND active = 1",
                (user_id, ))
            wallets = db.fetchall(
                """
                SELECT *, COALESCE((SELECT balance FROM balances WHERE wallet = wallets.id), 0) AS balance_msat
                FROM wallets
                WHERE user = ?
                """,
                (user_id, ),
            )

    return (User(
        **{
            **user,
            **{
                "extensions": [e[0] for e in extensions],
                "wallets": [Wallet(**w) for w in wallets]
            }
        }) if user else None)
Пример #3
0
def index():
    """Main withdraw link page."""

    usr = request.args.get("usr")

    if usr:
        if not len(usr) > 20:
            return redirect(url_for("home"))

    # Get all the data
    with open_db() as db:
        user_wallets = db.fetchall("SELECT * FROM wallets WHERE user = ?",
                                   (usr, ))
        user_ext = db.fetchall("SELECT * FROM extensions WHERE user = ?",
                               (usr, ))
        user_ext = [v[0] for v in user_ext]

    with open_ext_db("withdraw") as withdraw_ext_db:
        user_fau = withdraw_ext_db.fetchall(
            "SELECT * FROM withdraws WHERE usr = ?", (usr, ))

        # If del is selected by user from withdraw page, the withdraw link is to be deleted
        faudel = request.args.get("del")
        if faudel:
            withdraw_ext_db.execute("DELETE FROM withdraws WHERE uni = ?",
                                    (faudel, ))
            user_fau = withdraw_ext_db.fetchall(
                "SELECT * FROM withdraws WHERE usr = ?", (usr, ))

    return render_template("withdraw/index.html",
                           user_wallets=user_wallets,
                           user=usr,
                           user_ext=user_ext,
                           user_fau=user_fau)
Пример #4
0
def create_account() -> User:
    with open_db() as db:
        user_id = uuid4().hex
        db.execute("INSERT INTO accounts (id) VALUES (?)", (user_id, ))

    new_account = get_account(user_id=user_id)
    assert new_account, "Newly created account couldn't be retrieved"

    return new_account
Пример #5
0
def update_user_extension(*, user_id: str, extension: str,
                          active: int) -> None:
    with open_db() as db:
        db.execute(
            """
            INSERT OR REPLACE INTO extensions (user, extension, active)
            VALUES (?, ?, ?)
            """,
            (user_id, extension, active),
        )
Пример #6
0
def delete_wallet_payments_expired(wallet_id: str,
                                   *,
                                   seconds: int = 86400) -> None:
    with open_db() as db:
        db.execute(
            """
            DELETE
            FROM apipayments WHERE wallet = ? AND pending = 1 AND time < strftime('%s', 'now') - ?
            """,
            (wallet_id, seconds),
        )
Пример #7
0
def get_wallet_payment(wallet_id: str, checking_id: str) -> Optional[Payment]:
    with open_db() as db:
        row = db.fetchone(
            """
            SELECT payhash as checking_id, amount, fee, pending, memo, time
            FROM apipayments
            WHERE wallet = ? AND payhash = ?
            """,
            (wallet_id, checking_id),
        )

    return Payment(**row) if row else None
Пример #8
0
def get_wallet(wallet_id: str) -> Optional[Wallet]:
    with open_db() as db:
        row = db.fetchone(
            """
            SELECT *, COALESCE((SELECT balance FROM balances WHERE wallet = wallets.id), 0) AS balance_msat
            FROM wallets
            WHERE id = ?
            """,
            (wallet_id, ),
        )

    return Wallet(**row) if row else None
Пример #9
0
def delete_wallet(*, user_id: str, wallet_id: str) -> None:
    with open_db() as db:
        db.execute(
            """
            UPDATE wallets AS w
            SET
                user = '******' || w.user,
                adminkey = 'del:' || w.adminkey,
                inkey = 'del:' || w.inkey
            WHERE id = ? AND user = ?
            """,
            (wallet_id, user_id),
        )
Пример #10
0
 async def run(awaitable):
     fk = Request(
         "GET",
         "http",
         "/background/pseudo",
         b"",
         Headers([("host", "lnbits.background")]),
         "",
         "1.1",
         send_push_promise=lambda x, h: None,
     )
     async with main_app.request_context(fk):
         g.db = open_db()
         await awaitable
Пример #11
0
def get_wallet_for_key(key: str,
                       key_type: str = "invoice") -> Optional[Wallet]:
    with open_db() as db:
        check_field = "adminkey" if key_type == "admin" else "inkey"
        row = db.fetchone(
            f"""
            SELECT *, COALESCE((SELECT balance FROM balances WHERE wallet = wallets.id), 0) AS balance_msat
            FROM wallets
            WHERE {check_field} = ?
            """,
            (key, ),
        )

    return Wallet(**row) if row else None
Пример #12
0
def create_wallet(*,
                  user_id: str,
                  wallet_name: Optional[str] = None) -> Wallet:
    with open_db() as db:
        wallet_id = uuid4().hex
        db.execute(
            """
            INSERT INTO wallets (id, name, user, adminkey, inkey)
            VALUES (?, ?, ?, ?, ?)
            """,
            (wallet_id, wallet_name
             or DEFAULT_WALLET_NAME, user_id, uuid4().hex, uuid4().hex),
        )

    return get_wallet(wallet_id=wallet_id)
Пример #13
0
def create_payment(*,
                   wallet_id: str,
                   checking_id: str,
                   amount: str,
                   memo: str,
                   fee: int = 0,
                   pending: bool = True) -> Payment:
    with open_db() as db:
        db.execute(
            """
            INSERT INTO apipayments (wallet, payhash, amount, pending, memo, fee)
            VALUES (?, ?, ?, ?, ?, ?)
            """,
            (wallet_id, checking_id, amount, int(pending), memo, fee),
        )

    return get_wallet_payment(wallet_id, checking_id)
Пример #14
0
def create_wallet(*,
                  user_id: str,
                  wallet_name: Optional[str] = None) -> Wallet:
    with open_db() as db:
        wallet_id = uuid4().hex
        db.execute(
            """
            INSERT INTO wallets (id, name, user, adminkey, inkey)
            VALUES (?, ?, ?, ?, ?)
            """,
            (wallet_id, wallet_name
             or DEFAULT_WALLET_NAME, user_id, uuid4().hex, uuid4().hex),
        )

    new_wallet = get_wallet(wallet_id=wallet_id)
    assert new_wallet, "Newly created wallet couldn't be retrieved"

    return new_wallet
Пример #15
0
def get_wallet_for_key(key: str,
                       key_type: str = "invoice") -> Optional[Wallet]:
    with open_db() as db:
        row = db.fetchone(
            """
            SELECT *, COALESCE((SELECT balance FROM balances WHERE wallet = wallets.id), 0) AS balance_msat
            FROM wallets
            WHERE adminkey = ? OR inkey = ?
            """,
            (key, key),
        )

        if not row:
            return None

        if key_type == "admin" and row["adminkey"] != key:
            return None

        return Wallet(**row)
Пример #16
0
def create_payment(*,
                   wallet_id: str,
                   checking_id: str,
                   amount: int,
                   memo: str,
                   fee: int = 0,
                   pending: bool = True) -> Payment:
    with open_db() as db:
        db.execute(
            """
            INSERT INTO apipayments (wallet, payhash, amount, pending, memo, fee)
            VALUES (?, ?, ?, ?, ?, ?)
            """,
            (wallet_id, checking_id, amount, int(pending), memo, fee),
        )

    new_payment = get_wallet_payment(wallet_id, checking_id)
    assert new_payment, "Newly created payment couldn't be retrieved"

    return new_payment
Пример #17
0
def get_wallet_payments(wallet_id: str,
                        *,
                        include_all_pending: bool = False) -> List[Payment]:
    with open_db() as db:
        if include_all_pending:
            clause = "pending = 1"
        else:
            clause = "((amount > 0 AND pending = 0) OR amount < 0)"

        rows = db.fetchall(
            f"""
            SELECT payhash as checking_id, amount, fee, pending, memo, time
            FROM apipayments
            WHERE wallet = ? AND {clause}
            ORDER BY time DESC
            """,
            (wallet_id, ),
        )

    return [Payment(**row) for row in rows]
Пример #18
0
def ticket():
    """."""
    thehash = request.args.get("hash")
    unireg = request.args.get("unireg")

    #Double check the payment has cleared
    with open_db() as db:
        payment = db.fetchall("SELECT * FROM apipayments WHERE payhash = ?",
                              (thehash, ))

        if not payment:
            return jsonify({
                "status": "ERROR",
                "reason": "NO RECORD OF PAYMENT"
            }), 400

        if payment[0][4] == 1:
            return jsonify({"status": "ERROR", "reason": "NOT PAID"}), 400

    #Update databases
    with open_ext_db("events") as events_ext_db:
        user_ev = events_ext_db.fetchall(
            "SELECT * FROM events WHERE unireg = ?", (unireg, ))
        updatesold = user_ev[0][9] + 1
        events_ext_db.execute("UPDATE events SET sold = ? WHERE unireg = ?", (
            updatesold,
            unireg,
        ))
        events_ext_db.execute("UPDATE eventssold SET paid = 1 WHERE hash = ?",
                              (thehash, ))
        eventssold = events_ext_db.fetchall(
            "SELECT * FROM eventssold WHERE hash = ?", (thehash, ))
        if not eventssold:
            return jsonify({
                "status": "ERROR",
                "reason": "NO TICKET RECORD"
            }), 200

    return render_template("events/ticket.html",
                           name=eventssold[0][3],
                           ticket=thehash)
Пример #19
0
def get_wallet_payments(wallet_id: str,
                        *,
                        complete: bool = False,
                        pending: bool = False,
                        outgoing: bool = False,
                        incoming: bool = False) -> List[Payment]:
    """
    Filters payments to be returned by complete | pending | outgoing | incoming.
    """

    clause = ""
    if complete and pending:
        clause += ""
    elif complete:
        clause += "AND ((amount > 0 AND pending = 0) OR amount < 0)"
    elif pending:
        clause += "AND pending = 1"
    else:
        raise TypeError("at least one of [complete, pending] must be True.")

    if outgoing and incoming:
        clause += ""
    elif outgoing:
        clause += "AND amount < 0"
    elif incoming:
        clause += "AND amount > 0"
    else:
        raise TypeError("at least one of [outgoing, incoming] must be True.")

    with open_db() as db:
        rows = db.fetchall(
            f"""
            SELECT payhash as checking_id, amount, fee, pending, memo, time
            FROM apipayments
            WHERE wallet = ? {clause}
            ORDER BY time DESC
            """,
            (wallet_id, ),
        )

    return [Payment(**row) for row in rows]
Пример #20
0
def index():
    """Main events link page."""
    usr = request.args.get("usr")

    if usr:
        if not len(usr) > 20:
            return redirect(url_for("home"))

    # Get all the data
    with open_db() as db:
        user_wallets = db.fetchall("SELECT * FROM wallets WHERE user = ?",
                                   (usr, ))
        user_ext = db.fetchall(
            "SELECT extension FROM extensions WHERE user = ? AND active = 1",
            (usr, ))
        user_ext = [v[0] for v in user_ext]

    with open_ext_db("events") as events_ext_db:
        user_ev = events_ext_db.fetchall("SELECT * FROM events WHERE usr = ?",
                                         (usr, ))

        # If del is selected by user from events page, the event link is to be deleted
        evdel = request.args.get("del")
        if evdel:
            user_ev = events_ext_db.fetchall(
                "SELECT * FROM events WHERE uni = ?", (evdel, ))
            events_ext_db.execute("DELETE FROM events WHERE uni = ?",
                                  (evdel, ))
            if user_ev[0][9] > 0:
                events_ext_db.execute("DELETE FROM eventssold WHERE uni = ?",
                                      (user_ev[0][12], ))
            user_ev = events_ext_db.fetchall(
                "SELECT * FROM events WHERE usr = ?", (usr, ))
    print(user_ext)

    return render_template("events/index.html",
                           user_wallets=user_wallets,
                           user=usr,
                           user_ext=user_ext,
                           user_ev=user_ev)
Пример #21
0
def create():
    """."""

    data = request.json
    tit = data["tit"]
    wal = data["wal"]
    cldate = data["cldate"]
    notickets = data["notickets"]
    prtick = data["prtickets"]
    usr = data["usr"]
    descr = data["descr"]
    wall = wal.split("-")

    # Form validation
    if (not tit.replace(" ", "").isalnum() or wal == "" or int(notickets) < 0
            or int(prtick) < 0):
        return jsonify({"ERROR": "FORM ERROR"}), 401

    # If id that means its a link being edited, delete the record first
    if "id" in data:
        unid = data["id"].split("-")
        uni = unid[1]
        unireg = unid[2]
        with open_ext_db("events") as events_ext_db:
            events_ext_db.execute("DELETE FROM events WHERE uni = ?",
                                  (unid[1], ))
    else:
        uni = uuid.uuid4().hex
        unireg = uuid.uuid4().hex

    with open_db() as dbb:
        user_wallets = dbb.fetchall(
            "SELECT * FROM wallets WHERE user = ? AND id = ?", (
                usr,
                wall[1],
            ))
    if not user_wallets:
        return jsonify({"ERROR": "NO WALLET USER"}), 401

    with open_db() as db:
        user_ext = db.fetchall("SELECT * FROM extensions WHERE user = ?",
                               (usr, ))
        user_ext = [v[0] for v in user_ext]

    # Add to DB
    with open_ext_db("events") as events_ext_db:
        events_ext_db.execute(
            """
            INSERT OR IGNORE INTO events
            (usr, wal, walnme, walinvkey, uni, tit, cldate, notickets, prtick, descr, unireg)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """,
            (
                usr,
                wall[1],
                user_wallets[0][1],
                user_wallets[0][4],
                uni,
                tit,
                cldate,
                notickets,
                prtick,
                descr,
                unireg,
            ),
        )

        user_ev = events_ext_db.fetchall("SELECT * FROM events WHERE usr = ?",
                                         (usr, ))

        if not user_ev:
            return jsonify({"ERROR": "NO WALLET USER"}), 401

    return render_template("events/index.html",
                           user_wallets=user_wallets,
                           user=usr,
                           user_ext=user_ext,
                           user_ev=user_ev)
Пример #22
0
 async def run():
     async with main_app.request_context(fk):
         with open_db() as g.db:  # type: ignore
             await func(*args)
Пример #23
0
def create_account() -> User:
    with open_db() as db:
        user_id = uuid4().hex
        db.execute("INSERT INTO accounts (id) VALUES (?)", (user_id, ))

    return get_account(user_id=user_id)
Пример #24
0
def create():
    """."""

    data = request.json
    amt = data["amt"]
    tit = data["tit"]
    wal = data["wal"]
    minamt = data["minamt"]
    maxamt = data["maxamt"]
    tme = data["tme"]
    uniq = data["uniq"]
    usr = data["usr"]
    wall = wal.split("-")

    # Form validation
    if (int(amt) < 0 or not tit.replace(" ", "").isalnum() or wal == ""
            or int(minamt) < 0 or int(maxamt) < 0 or int(minamt) > int(maxamt)
            or int(tme) < 0):
        return jsonify({"ERROR": "FORM ERROR"}), 401

    # If id that means its a link being edited, delet the record first
    if "id" in data:
        unid = data["id"].split("-")
        uni = unid[1]
        with open_ext_db("withdraw") as withdraw_ext_db:
            withdraw_ext_db.execute("DELETE FROM withdraws WHERE uni = ?",
                                    (unid[1], ))
    else:
        uni = uuid.uuid4().hex

    # Randomiser for random QR option
    rand = ""
    if uniq > 0:
        for x in range(0, int(amt)):
            rand += uuid.uuid4().hex[0:5] + ","
    else:
        rand = uuid.uuid4().hex[0:5] + ","

    with open_db() as dbb:
        user_wallets = dbb.fetchall(
            "SELECT * FROM wallets WHERE user = ? AND id = ?", (
                usr,
                wall[1],
            ))
    if not user_wallets:
        return jsonify({"ERROR": "NO WALLET USER"}), 401

    # Get time
    dt = datetime.now()
    seconds = dt.timestamp()

    with open_db() as db:
        user_ext = db.fetchall("SELECT * FROM extensions WHERE user = ?",
                               (usr, ))
        user_ext = [v[0] for v in user_ext]

    # Add to DB
    with open_ext_db("withdraw") as withdraw_ext_db:
        withdraw_ext_db.execute(
            """
            INSERT OR IGNORE INTO withdraws
            (usr, wal, walnme, adm, uni, tit, maxamt, minamt, spent, inc, tme, uniq, withdrawals, tmestmp, rand)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """,
            (
                usr,
                wall[1],
                user_wallets[0][1],
                user_wallets[0][3],
                uni,
                tit,
                maxamt,
                minamt,
                0,
                amt,
                tme,
                uniq,
                0,
                seconds,
                rand,
            ),
        )

        user_fau = withdraw_ext_db.fetchall(
            "SELECT * FROM withdraws WHERE usr = ?", (usr, ))

        if not user_fau:
            return jsonify({"ERROR": "NO WALLET USER"}), 401

    return render_template("withdraw/index.html",
                           user_wallets=user_wallets,
                           user=usr,
                           user_ext=user_ext,
                           user_fau=user_fau)
Пример #25
0
def migrate():
    with open_db() as db:
        m001_initial(db)
Пример #26
0
def delete_payment(checking_id: str) -> None:
    with open_db() as db:
        db.execute("DELETE FROM apipayments WHERE payhash = ?",
                   (checking_id, ))
Пример #27
0
def update_payment_status(checking_id: str, pending: bool) -> None:
    with open_db() as db:
        db.execute("UPDATE apipayments SET pending = ? WHERE payhash = ?", (
            int(pending),
            checking_id,
        ))