web-apihelper-quart 0.0.1__py3-none-any.whl

web_apihelper_quart/s1.py

@@ -0,0 +1,389 @@
+# app.py
+import asyncio
+import pyodbc
+from quart import Quart, request, jsonify
+from quart_cors import cors
+
+app = Quart(__name__)
+app = cors(app, allow_origin="*")
+def get_connection_string():
+    server = r'.\SQLEXPRESS'
+    database = 'Session1'
+    installed = pyodbc.drivers()
+    preferred = [
+        '{ODBC Driver 18 for SQL Server}',
+        '{ODBC Driver 17 for SQL Server}',
+        '{SQL Server Native Client 11.0}',
+        '{SQL Server}'
+    ]
+    driver = next((d for d in preferred if d in installed or d.strip('{}') in installed), '{SQL Server}')
+    return f"Driver={driver};Server={server};Database={database};Trusted_Connection=yes;Encrypt=no;"
+
+DB_CONNECTION_STRING = get_connection_string()
+
+
+async def get_db_connection():
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(None, lambda: pyodbc.connect(DB_CONNECTION_STRING))
+
+
+def model_to_dict(cursor, row):
+    d = {}
+    for idx, col in enumerate(cursor.description):
+        d[col[0]] = row[idx]
+    return d
+
+
+async def fetch_all(query, params=None):
+    conn = await get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute(query, params or ())
+        rows = cursor.fetchall()
+        return [model_to_dict(cursor, row) for row in rows]
+    finally:
+        cursor.close()
+        conn.close()
+
+
+async def fetch_one(query, params=None):
+    conn = await get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute(query, params or ())
+        row = cursor.fetchone()
+        return model_to_dict(cursor, row) if row else None
+    finally:
+        cursor.close()
+        conn.close()
+
+
+async def execute_query(query, params=None, fetch_last_id=False):
+    conn = await get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute(query, params or ())
+        if fetch_last_id:
+            cursor.execute("SELECT @@IDENTITY AS last_id;")
+            last_id = cursor.fetchone()[0]
+            conn.commit()
+            return last_id
+        conn.commit()
+        return True
+    except Exception as e:
+        conn.rollback()
+        print(f"Database Error: {e}")
+        return None
+    finally:
+        cursor.close()
+        conn.close()
+
+
+async def generate_asset_sn(department_id, asset_group_id):
+    dd = str(department_id).zfill(2)
+    gg = str(asset_group_id).zfill(2)
+
+    prefix = f"{dd}/{gg}/"
+
+    query = """
+            SELECT TOP 1 AssetSN
+            FROM Assets
+            WHERE AssetSN LIKE ?
+            ORDER BY AssetSN DESC \
+            """
+    last_sn_row = await fetch_one(query, (f"{prefix}%",))
+
+    if last_sn_row and last_sn_row['AssetSN']:
+        last_number_part = last_sn_row['AssetSN'].split('/')[-1]
+        next_number = int(last_number_part) + 1
+    else:
+        next_number = 1
+
+    nnnn = str(next_number).zfill(4)
+
+    return f"{prefix}{nnnn}"
+
+@app.route("/departments", methods=["GET"])
+async def get_departments():
+    departments = await fetch_all("SELECT ID, Name FROM Departments ORDER BY Name")
+    return jsonify(departments)
+
+
+@app.route("/asset-groups", methods=["GET"])
+async def get_asset_groups():
+    asset_groups = await fetch_all("SELECT ID, Name FROM AssetGroups ORDER BY Name")
+    return jsonify(asset_groups)
+
+
+@app.route("/locations", methods=["GET"])
+async def get_locations():
+    department_id = request.args.get('department_id', type=int)
+    if department_id:
+        query = """
+            SELECT l.ID, l.Name 
+            FROM Locations l
+            JOIN DepartmentLocations dl ON l.ID = dl.LocationID
+            WHERE dl.DepartmentID = ? 
+            ORDER BY l.Name
+        """
+        locations = await fetch_all(query, (department_id,))
+    else:
+        query = "SELECT ID, Name FROM Locations ORDER BY Name"
+        locations = await fetch_all(query)
+    return jsonify(locations)
+
+
+@app.route("/employees", methods=["GET"])
+async def get_employees():
+    query = "SELECT ID, FirstName + ' ' + LastName AS FullName FROM Employees ORDER BY FullName"
+    employees = await fetch_all(query)
+    return jsonify(employees)
+
+
+@app.route("/assets", methods=["GET"])
+async def get_assets():
+    base_query = """
+                 SELECT a.ID, \
+                        a.AssetSN, \
+                        a.AssetName, \
+                        d.Name as DepartmentName
+                 FROM Assets a
+                          JOIN DepartmentLocations dl ON a.DepartmentLocationID = dl.ID
+                          JOIN Departments d ON dl.DepartmentID = d.ID
+                          JOIN AssetGroups ag ON a.AssetGroupID = ag.ID \
+                 """
+
+    conditions = []
+    params = []
+
+    search = request.args.get('search')
+    if search:
+        conditions.append("(a.AssetName LIKE ? OR a.AssetSN LIKE ?)")
+        params.extend([f"%{search}%", f"%{search}%"])
+
+    department_id = request.args.get('department_id', type=int)
+    if department_id:
+        conditions.append("d.ID = ?")
+        params.append(department_id)
+
+    asset_group_id = request.args.get('asset_group_id', type=int)
+    if asset_group_id:
+        conditions.append("ag.ID = ?")
+        params.append(asset_group_id)
+
+    start_date = request.args.get('warranty_start_date')
+    end_date = request.args.get('warranty_end_date')
+    if start_date and end_date:
+        conditions.append("a.WarrantyDate BETWEEN ? AND ?")
+        params.extend([start_date, end_date])
+
+    if conditions:
+        base_query += " WHERE " + " AND ".join(conditions)
+
+    base_query += " ORDER BY a.ID DESC"
+
+    assets = await fetch_all(base_query, tuple(params))
+    return jsonify(assets)
+
+
+@app.route("/assets/<int:asset_id>", methods=["GET"])
+async def get_asset_details(asset_id):
+    query = """
+            SELECT a.ID, \
+                   a.AssetName, \
+                   a.AssetSN, \
+                   a.Description, \
+                   a.WarrantyDate, \
+                   dl.DepartmentID, \
+                   dl.LocationID, \
+                   a.AssetGroupID, \
+                   a.EmployeeID AS AccountablePartyID
+            FROM Assets a
+                     JOIN DepartmentLocations dl ON a.DepartmentLocationID = dl.ID
+            WHERE a.ID = ? \
+            """
+    asset = await fetch_one(query, (asset_id,))
+
+    if not asset:
+        return jsonify({"error": "Asset not found"}), 404
+
+    photos_query = "SELECT ID, AssetPhoto FROM AssetPhotos WHERE AssetID = ?"
+    photos = await fetch_all(photos_query, (asset_id,))
+    asset['Photos'] = photos
+
+    return jsonify(asset)
+
+@app.route("/assets", methods=["POST"])
+async def create_asset():
+    data = await request.get_json()
+    if not data:
+        return jsonify({"error": "No data provided"}), 400
+
+    required_fields = ['AssetName', 'DepartmentID', 'LocationID', 'AssetGroupID', 'EmployeeID', 'WarrantyDate']
+
+    missing = [f for f in required_fields if f not in data or data[f] is None]
+    if missing:
+        print(f"Missing fields: {missing}")
+        return jsonify({"error": f"Missing fields: {', '.join(missing)}"}), 400
+
+    dl_query = "SELECT ID FROM DepartmentLocations WHERE DepartmentID = ? AND LocationID = ?"
+    dl_row = await fetch_one(dl_query, (data['DepartmentID'], data['LocationID']))
+    if not dl_row:
+        return jsonify({"error": "This location is not assigned to the selected department"}), 400
+    department_location_id = dl_row['ID']
+
+    dup_check = "SELECT ID FROM Assets WHERE AssetName = ? AND DepartmentLocationID = ?"
+    if await fetch_one(dup_check, (data['AssetName'], department_location_id)):
+        return jsonify({"error": "Asset with this name already exists at this location"}), 409
+
+    asset_sn = await generate_asset_sn(data['DepartmentID'], data['AssetGroupID'])
+
+    insert_query = """
+                   INSERT INTO Assets (AssetSN, AssetName, DepartmentLocationID, EmployeeID, AssetGroupID, Description, \
+                                       WarrantyDate)
+                   VALUES (?, ?, ?, ?, ?, ?, ?) \
+                   """
+    params = (
+        asset_sn,
+        data['AssetName'],
+        department_location_id,
+        data['EmployeeID'],
+        data['AssetGroupID'],
+        data.get('Description', ''),
+        data['WarrantyDate']
+    )
+
+    new_id = await execute_query(insert_query, params, fetch_last_id=True)
+    if new_id:
+        return jsonify({"message": "Created", "id": new_id, "assetSN": asset_sn}), 201
+    return jsonify({"error": "Database insert failed"}), 500
+
+@app.route("/assets/<int:asset_id>", methods=["PUT"])
+async def update_asset(asset_id):
+    data = await request.get_json()
+    if not data:
+        return jsonify({"error": "Invalid input"}), 400
+
+    existing_asset = await fetch_one("SELECT * FROM Assets WHERE ID = ?", (asset_id,))
+    if not existing_asset:
+        return jsonify({"error": "Asset not found"}), 404
+
+    dl_query = "SELECT ID FROM DepartmentLocations WHERE DepartmentID = ? AND LocationID = ?"
+    dl_row = await fetch_one(dl_query, (data['DepartmentID'], data['LocationID']))
+    if not dl_row:
+        return jsonify({"error": "Invalid Department/Location combination"}), 400
+    department_location_id = dl_row['ID']
+
+    dup_check_query = "SELECT ID FROM Assets WHERE AssetName = ? AND DepartmentLocationID = ? AND ID != ?"
+    duplicate = await fetch_one(dup_check_query, (data['AssetName'], department_location_id, asset_id))
+    if duplicate:
+        return jsonify({"error": "An asset with this name already exists at this location"}), 409
+
+    update_query = """
+                   UPDATE Assets \
+                   SET AssetName            = ?, \
+                       DepartmentLocationID = ?, \
+                       EmployeeID           = ?, \
+                       AssetGroupID         = ?, \
+                       Description          = ?, \
+                       WarrantyDate         = ?
+                   WHERE ID = ? \
+                   """
+    params = (
+        data['AssetName'],
+        department_location_id,
+        data['EmployeeID'],
+        data['AssetGroupID'],
+        data.get('Description', ''),
+        data['WarrantyDate'],
+        asset_id
+    )
+
+    result = await execute_query(update_query, params)
+
+    if result:
+        return jsonify({"message": "Asset updated successfully"}), 200
+    else:
+        return jsonify({"error": "Failed to update asset"}), 500
+
+
+@app.route("/assets/<int:asset_id>/transfer", methods=["POST"])
+async def transfer_asset(asset_id):
+    data = await request.get_json()
+    if not data or 'DestinationDepartmentID' not in data or 'DestinationLocationID' not in data:
+        return jsonify({"error": "Destination Department and Location are required"}), 400
+
+    current_asset_query = """
+                          SELECT a.AssetSN, a.AssetGroupID, a.DepartmentLocationID
+                          FROM Assets a
+                          WHERE a.ID = ? \
+                          """
+    current_asset = await fetch_one(current_asset_query, (asset_id,))
+    if not current_asset:
+        return jsonify({"error": "Asset not found"}), 404
+
+    from_dl_id = current_asset['DepartmentLocationID']
+    from_asset_sn = current_asset['AssetSN']
+    asset_group_id = current_asset['AssetGroupID']
+
+    to_department_id = data['DestinationDepartmentID']
+    to_location_id = data['DestinationLocationID']
+
+    to_dl_query = "SELECT ID FROM DepartmentLocations WHERE DepartmentID = ? AND LocationID = ?"
+    to_dl_row = await fetch_one(to_dl_query, (to_department_id, to_location_id))
+    if not to_dl_row:
+        return jsonify({"error": "Invalid destination Department/Location combination"}), 400
+    to_dl_id = to_dl_row['ID']
+
+    new_asset_sn = await generate_asset_sn(to_department_id, asset_group_id)
+
+    log_query = """
+                INSERT INTO AssetTransferLogs (AssetID, TransferDate, FromDepartmentLocationID, ToDepartmentLocationID, \
+                                               FromAssetSN, ToAssetSN)
+                VALUES (?, GETDATE(), ?, ?, ?, ?) \
+                """
+    await execute_query(log_query, (asset_id, from_dl_id, to_dl_id, from_asset_sn, new_asset_sn))
+
+    update_asset_query = """
+                         UPDATE Assets
+                         SET DepartmentLocationID = ?, \
+                             AssetSN              = ?
+                         WHERE ID = ? \
+                         """
+    await execute_query(update_asset_query, (to_dl_id, new_asset_sn, asset_id))
+
+    return jsonify({
+        "message": "Asset transferred successfully",
+        "newAssetSN": new_asset_sn
+    }), 200
+
+
+
+@app.route("/assets/<int:asset_id>/history", methods=["GET"])
+async def get_transfer_history(asset_id):
+    query = """
+            SELECT atl.TransferDate, \
+                   d_from.Name     AS OldDepartment, \
+                   atl.FromAssetSN AS OldAssetSN, \
+                   d_to.Name       AS NewDepartment, \
+                   atl.ToAssetSN   AS NewAssetSN
+            FROM AssetTransferLogs atl
+                     -- Join for 'From' Department
+                     JOIN DepartmentLocations dl_from ON atl.FromDepartmentLocationID = dl_from.ID
+                     JOIN Departments d_from ON dl_from.DepartmentID = d_from.ID
+                -- Join for 'To' Department
+                     JOIN DepartmentLocations dl_to ON atl.ToDepartmentLocationID = dl_to.ID
+                     JOIN Departments d_to ON dl_to.DepartmentID = d_to.ID
+            WHERE atl.AssetID = ?
+            ORDER BY atl.TransferDate DESC \
+            """
+    history = await fetch_all(query, (asset_id,))
+
+    if not history:
+        return jsonify([]), 200
+
+    return jsonify(history)
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000, debug=True)