Gecko [ myeducation.co.th ]

Name	Size	Permission
.vscode	[ DIR ]	drwxr-xr-x
__pycache__	[ DIR ]	drwxr-xr-x
explore	[ DIR ]	drwxr-xr-x
mara1_model	[ DIR ]	drwxr-xr-x
nltk_data	[ DIR ]	drwxr-xr-x
pythainlp_data	[ DIR ]	drwxr-xr-x
runs	[ DIR ]	drwxr-xr-x
venv	[ DIR ]	drwxr-xr-x
yolo8	[ DIR ]	drwxr-xr-x
. htaccess	417 B	-rwxr-xr-x
.htaccess	197 B	-rwxr-xr-x
app.log	66 B	-rwxr-xr-x
app.py	16.16 KB	-rwxr-xr-x
app.wsgi	568 B	-rwxr-xr-x
blog_ttt_website.py	5.07 KB	-rwxr-xr-x
config.py	485 B	-rwxr-xr-x
content_content_image_ram.py	11.07 KB	-rw-r--r--
content_main_ram.py	15.99 KB	-rw-r--r--
detect.py	8.16 KB	-rwxr-xr-x
explore.py	11.4 KB	-rw-r--r--
json_logfile.json	18 B	-rwxr-xr-x
keywords.json	203 B	-rw-r--r--
locations.json	299 B	-rw-r--r--
read_virus_files_php.py	2.6 KB	-rwxr-xr-x
table.csv	56.2 KB	-rw-r--r--
travel.py	6.89 KB	-rw-r--r--
travel_action.py	10.72 KB	-rw-r--r--
travel_mara1.py	12.6 KB	-rw-r--r--
travel_nltk_base.py	5.21 KB	-rw-r--r--
travel_pythainlp.py	9.37 KB	-rw-r--r--
udo systemctl daemon-reload	1.07 KB	-rwxr-xr-x
udo systemctl restart apache2	1.25 KB	-rwxr-xr-x
your_flask_service.log	1.07 KB	-rwxr-xr-x

Code Editor : content_main_ram.py

# /var/www/afra/py.afaa.website/content_main_ram.py
# python3 content_main_ram.py

from flask import Flask, jsonify, request
from flask_cors import CORS
import mysql.connector
import re
from config import DB_CONFIG_RAM
from datetime import timedelta
import urllib.parse  # สำหรับ quote / unquote

app = Flask(__name__)
CORS(app)

def query_db(query, params=None, commit=False):
    """
    ฟังก์ชันช่วยในการรันคำสั่ง SQL
    โดยรับ query (string) และ params (tuple หรือ list)
    ถ้า commit=True จะบันทึกการเปลี่ยนแปลง (สำหรับ INSERT, UPDATE, DELETE)
    ส่งผลลัพธ์กลับมาเป็น list ของ dictionary (สำหรับ SELECT)
    """
    with mysql.connector.connect(**DB_CONFIG_RAM) as conn:
        with conn.cursor(dictionary=True) as cursor:
            if params:
                cursor.execute(query, params)
            else:
                cursor.execute(query)
            if commit:
                conn.commit()
                return cursor.rowcount  # ส่งคืนจำนวนแถวที่ได้รับผลกระทบ
            return cursor.fetchall()

def serialize_result(result):
    """
    ฟังก์ชันช่วยแปลงข้อมูลที่ไม่สามารถ serialize เป็น JSON ได้ (เช่น timedelta)
    และถอดรหัส (urldecode) สำหรับฟิลด์ Home_Sub, Home_Short, Home_Detail
    โดยให้ '+' ถูกแทนด้วย space เพื่อให้สตริงอ่านง่าย
    """
    for row in result:
        for key, value in row.items():
            # ถ้าเป็น timedelta ให้แปลงเป็น string
            if isinstance(value, timedelta):
                row[key] = str(value)

# ถอดรหัส (urldecode) โดยใช้ unquote_plus เพื่อแทนที่ '+' ด้วยช่องว่าง
        if row.get('Home_Short') is not None:
            row['Home_Short'] = urllib.parse.unquote_plus(row['Home_Short'])
        if row.get('Home_Detail') is not None:
            row['Home_Detail'] = urllib.parse.unquote_plus(row['Home_Detail'])
        # หากต้องการทำ Home_Sub เช่นกัน (กรณีเก็บเป็น urlencoded) ก็สามารถเพิ่มได้
        # if row.get('Home_Sub') is not None:
        #     row['Home_Sub'] = urllib.parse.unquote_plus(row['Home_Sub'])

return result

def get_base_query():
    """
    ฟังก์ชันแยกสำหรับสร้าง base_query พื้นฐานสำหรับ SELECT
    """
    return """
    SELECT 
       home.Home_ID,
       home.Member_ID,
       home.Home_Date,
       home.Home_Time,
       home.Home_Visitors,
       home.Home_Sub,
       home.Home_Short,
       home.Home_Detail,
       home.Home_Category,
       home.StatusHome_ID
    FROM home
    WHERE home.StatusHome_ID != 3
      AND home.StatusShowPage_ID = 28
    """

@app.route('/api/content/view', methods=['GET'])
def get_main_content():
    """
    ดึงข้อมูลจากตาราง home เฉพาะ
    โดยใช้เงื่อนไขหลัก: home.StatusHome_ID != 3 และ home.StatusShowPage_ID = 28
    รองรับการค้นหาและ limit/offset
    โดยผลลัพธ์ที่ส่งคืนจะถอดรหัส (urldecode) ใน field Home_Sub, Home_Short, Home_Detail
    """
    member_id = request.args.get('member_id', type=int)
    status_home_id = request.args.get('status_home_id', type=int)
    keyword_sub = request.args.get('home_sub', type=str)
    home_id = request.args.get('home_id', type=int)
    keyword_detail = request.args.get('home_detail', type=str)

offset_param = request.args.get('offset', 0, type=int)
    if offset_param < 0:
        offset_param = 0

limit_param = request.args.get('limit', 10, type=int)
    if limit_param <= 0:
        limit_param = 10

base_query = get_base_query()
    conditions = []
    params = []

if member_id is not None:
        conditions.append("home.Member_ID = %s")
        params.append(member_id)

if status_home_id is not None:
        conditions.append("home.StatusHome_ID = %s")
        params.append(status_home_id)

# สำหรับกรณีค้นหา home_sub / home_detail ใน DB จะเป็น urlencoded อยู่
    # จึงอาจต้อง urlencode ก่อนนำไป LIKE
    # แต่ในหลายกรณีอาจไม่ต้องการ search ด้วย substring ของ URLencoded
    # ถ้าไม่จำเป็นก็จะค้นหาได้ปกติถ้าข้อมูลเป็น plaintext
    # ที่นี่เป็นตัวอย่างว่าถ้าต้องการ search ตรง ๆ ใน db ที่ยังเก็บแบบ encoded ไว้
    # ก็ทำ urllib.parse.quote(keyword_sub, safe='') ฯลฯ
    # หรืออาจเก็บ plaintext แต่อ่านออกเป็น encoded ก็ได้ (ขึ้นกับออกแบบ)
    # ตัวอย่างนี้จะสมมติว่า DB เก็บ urlencoded ไว้ จึงต้อง encode ก่อน search
    
    if keyword_sub:
        encoded_sub = urllib.parse.quote(keyword_sub, safe='')
        conditions.append("home.Home_Sub LIKE %s")
        params.append(f"%{encoded_sub}%")

if home_id is not None:
        conditions.append("home.Home_ID = %s")
        params.append(home_id)

if keyword_detail:
        encoded_detail = urllib.parse.quote(keyword_detail, safe='')
        conditions.append("home.Home_Detail LIKE %s")
        params.append(f"%{encoded_detail}%")

# สร้าง query สำหรับนับจำนวนทั้งหมด (total_count)
    count_query = "SELECT COUNT(*) as total FROM home WHERE home.StatusHome_ID != 3 AND home.StatusShowPage_ID = 28"
    if conditions:
        count_query += " AND " + " AND ".join(conditions)

# ดึงจำนวนทั้งหมดก่อน
    total_results = query_db(count_query, params if conditions else None)
    total_count = total_results[0]['total'] if total_results else 0

# เพิ่มเงื่อนไขใน query หลัก
    if conditions:
        base_query += " AND " + " AND ".join(conditions)

base_query += " ORDER BY home.Home_ID DESC LIMIT %s OFFSET %s"
    params.extend([limit_param, offset_param])

# ดึงข้อมูลตาม limit และ offset
    results = query_db(base_query, params)
    results = serialize_result(results)

# ส่งผลลัพธ์กลับเป็น JSON พร้อม limit, offset, total_count
    response = {
        "results": results,
        "limit": limit_param,
        "offset": offset_param,
        "total_count": total_count
    }
    return jsonify(response)

@app.route('/api/content/insert', methods=['POST'])
def insert_main_content():
    """
    เพิ่มข้อมูลใหม่ในตาราง home ด้วย INSERT INTO
    รองรับทั้งการส่ง object เดียว { ... } หรือ list ของ object [ {...}, {...} ]
    โดย Home_Sub บันทึกเป็น plain text
    Home_Short, Home_Detail เข้ารหัส (urlencode) ก่อนบันทึก
    
    ต้องการ Log ค่า Home_ID ล่าสุดที่ insert ได้ในรูป latest_id: [xx, xx, ...]
    """
    data = request.get_json()
    if not data:
        return jsonify({'error': 'No data provided'}), 400

# เพื่อรองรับทั้งกรณี object เดียว กับ หลาย object
    if isinstance(data, dict):
        data = [data]
    elif isinstance(data, list):
        pass
    else:
        return jsonify({'error': 'JSON must be an object or an array of objects'}), 400

insert_query = """
    INSERT INTO home (
        Member_ID, Home_Date, Home_Time, Home_Visitors,
        Home_Sub, Home_Short, Home_Detail,
        Home_Category, StatusHome_ID, StatusShowPage_ID
    ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
    """

total_inserted = 0
    inserted_ids = []  # เก็บ Home_ID ที่ insert ได้

try:
        with mysql.connector.connect(**DB_CONFIG_RAM) as conn:
            with conn.cursor(dictionary=True) as cursor:
                for item in data:
                    sub_value = item.get('Home_Sub', '')
                    encoded_short = urllib.parse.quote(item.get('Home_Short', ''), safe='')
                    encoded_detail = urllib.parse.quote(item.get('Home_Detail', ''), safe='')

params = (
                        item.get('Member_ID'),
                        item.get('Home_Date'),
                        item.get('Home_Time'),
                        item.get('Home_Visitors', 0),
                        sub_value,          # plain text
                        encoded_short,      # encode
                        encoded_detail,     # encode
                        item.get('Home_Category'),
                        item.get('StatusHome_ID', 1),
                        item.get('StatusShowPage_ID', 28)
                    )

cursor.execute(insert_query, params)
                    total_inserted += cursor.rowcount

# ดึงค่า Home_ID ล่าสุดที่ถูก insert
                    new_id = cursor.lastrowid
                    inserted_ids.append(new_id)

conn.commit()

# ส่งกลับ JSON โดยเพิ่ม latest_id เป็นรายการของ Home_ID ที่เพิ่งเพิ่ม
        response = {
            'message': 'Inserted successfully',
            'inserted_count': total_inserted,
            'latest_id': inserted_ids
        }
        return jsonify(response), 201

except mysql.connector.Error as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/content/update', methods=['PUT'])
def update_main_content():    
    data = request.get_json()
    if not data:
        return jsonify({'error': 'No data provided'}), 400

# ถ้ารับมาเป็น Object เดียว => ห่อให้อยู่ใน List
    if isinstance(data, dict):
        data = [data]
    elif isinstance(data, list):
        pass
    else:
        return jsonify({'error': 'JSON must be an object or an array of objects'}), 400

total_updated = 0

try:
        with mysql.connector.connect(**DB_CONFIG_RAM) as conn:
            with conn.cursor(dictionary=True) as cursor:
                for item in data:
                    # ตรวจสอบว่ามี Home_ID หรือไม่
                    home_id = item.get('Home_ID')
                    if not home_id:
                        # ถ้าไม่มี Home_ID ให้ข้ามหรือจะ raise Error ก็ได้
                        continue

# ตรวจสอบว่ามี record นี้อยู่จริงหรือไม่
                    check_query = "SELECT Home_ID FROM home WHERE Home_ID = %s"
                    cursor.execute(check_query, (home_id,))
                    check_result = cursor.fetchall()
                    if not check_result:
                        # หากไม่พบ record => ข้ามหรือแจ้ง error
                        # ในตัวอย่างนี้จะข้ามเฉย ๆ
                        continue

set_clause = []
                    params = []

# Member_ID
                    if 'Member_ID' in item:
                        set_clause.append("Member_ID = %s")
                        params.append(item['Member_ID'])

# Home_Sub (plain text)
                    if 'Home_Sub' in item:
                        set_clause.append("Home_Sub = %s")
                        params.append(item['Home_Sub'])

# Home_Short (encode)
                    if 'Home_Short' in item:
                        encoded_short = urllib.parse.quote(item['Home_Short'], safe='')
                        set_clause.append("Home_Short = %s")
                        params.append(encoded_short)

# Home_Detail (encode)
                    if 'Home_Detail' in item:
                        encoded_detail = urllib.parse.quote(item['Home_Detail'], safe='')
                        set_clause.append("Home_Detail = %s")
                        params.append(encoded_detail)

# Home_Category
                    if 'Home_Category' in item:
                        set_clause.append("Home_Category = %s")
                        params.append(item['Home_Category'])

# ถ้าไม่มีฟิลด์อะไรให้อัปเดต => ข้าม
                    if not set_clause:
                        continue

# ต่อท้าย WHERE
                    params.append(home_id)
                    query = f"UPDATE home SET {', '.join(set_clause)} WHERE Home_ID = %s"

print("[UPDATE] SQL Query:", query)
                    print("[UPDATE] Params:", params)

cursor.execute(query, params)
                    total_updated += cursor.rowcount

# หลังวนลูปทุกเรคคอร์ดเสร็จค่อย commit
                conn.commit()

# สรุปจำนวนที่อัปเดต
        if total_updated == 0:
            return jsonify({
                'message': 'No changes were made to any record (already the same or not found).',
                'affected_rows': 0
            }), 200
        else:
            return jsonify({
                'message': 'Updated successfully',
                'affected_rows': total_updated
            }), 200

except mysql.connector.Error as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/content/delete', methods=['DELETE'])
def delete_main_content():
    """
    ลบข้อมูลจากตาราง home ด้วย DELETE
    รับ Home_IDs จาก JSON body ในรูปแบบ list เช่น [484, 485, 486]
    หรือรับ Home_ID เดียวจาก query params เพื่อ compatibility เดิม
    """
    # ตรวจสอบ JSON body ก่อน
    data = request.get_json(silent=True)
    if data and isinstance(data, list):
        home_ids = [int(id) for id in data if isinstance(id, (int, str)) and str(id).isdigit()]
        if not home_ids:
            return jsonify({'error': 'No valid Home_IDs provided in list'}), 400

# สร้าง query สำหรับลบหลาย ID
        placeholders = ','.join(['%s'] * len(home_ids))
        query = f"DELETE FROM home WHERE Home_ID IN ({placeholders})"
        params = tuple(home_ids)

else:
        # รองรับการใช้งานแบบเดิม (query param)
        home_id = request.args.get('home_id', type=int)
        if not home_id:
            return jsonify({'error': 'Home_ID(s) required in query param or JSON body'}), 400

query = "DELETE FROM home WHERE Home_ID = %s"
        params = (home_id,)

try:
        affected_rows = query_db(query, params, commit=True)
        if affected_rows == 0:
            return jsonify({'error': 'No records found to delete'}), 404
        return jsonify({'message': 'Deleted successfully', 'affected_rows': affected_rows})
    except mysql.connector.Error as e:
        return jsonify({'error': str(e)}), 500

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=422, debug=True)

${this.title}

Code Editor : content_main_ram.py