วิธีสร้างแอปพลิเคชันค้นหาสูตรโดยใช้ Python

การค้นหาสูตรอาหารในอุดมคติท่ามกลางแหล่งข้อมูลออนไลน์ที่มีอยู่มากมายสามารถพิสูจน์ได้ว่าเป็นงานที่น่าหวาดหวั่นเนื่องจากมีตัวเลือกมากมายและโฆษณาที่รบกวน การพัฒนาแอปพลิเคชันค้นหาสูตรอาหารเฉพาะบุคคลนำเสนออินเทอร์เฟซที่มีประสิทธิภาพและใช้งานง่าย ซึ่งจะกรองข้อมูลและสิ่งรบกวนที่ไม่เกี่ยวข้องออกไป จึงลดความซับซ้อนของกระบวนการค้นหาเนื้อหาการทำอาหารที่เหมาะสมสำหรับผู้ใช้

ด้วยการพัฒนาซอฟต์แวร์นี้ ซอฟต์แวร์นี้จะช่วยเพิ่มความสามารถในการกำหนดความต้องการ HTTP, การจัดการคีย์ API, การแก้ไขภาพ ตลอดจนการสร้างส่วนต่อประสานผู้ใช้แบบโต้ตอบพร้อมคุณสมบัติต่างๆ เช่น การอัปเดตตามเวลาจริง

ติดตั้งโมดูล Tkinter, คำขอ, หมอน และเว็บเบราว์เซอร์

ในการสร้างแอปพลิเคชันสำหรับค้นหาสูตรอาหาร จำเป็นต้องมี Tkinter, Requests, PIL และโมดูลเว็บเบราว์เซอร์ อดีตช่วยให้สามารถสร้างส่วนติดต่อผู้ใช้แบบกราฟิกบนเดสก์ท็อปผ่านการจัดหาวิดเจ็ตที่หลากหลายซึ่งช่วยอำนวยความสะดวกในการพัฒนา GUI ในการรับ Tkinter ผู้ใช้สามารถนำทางไปยังเทอร์มินัลและดำเนินการคำสั่ง:

 pip install tkinter 

ไลบรารีคำขอช่วยอำนวยความสะดวกในกระบวนการสร้างคำขอ HTTP โดยให้อินเทอร์เฟซที่ใช้งานง่ายสำหรับการดึงข้อมูลจากแหล่งต่างๆ รวมถึงข้อมูลหมายเลขผู้โทร การตรวจสอบสถานะเว็บไซต์ และการแปลงสกุลเงิน เครื่องมืออเนกประสงค์นี้สามารถนำไปใช้กับแอปพลิเคชันได้หลากหลาย เช่น การสร้างผู้รวบรวมข่าวสาร ในการรวมโมดูลคำขอเข้ากับโครงการของคุณ เพียงไปที่เทอร์มินัลแล้วดำเนินการคำสั่ง:

 pip install requests 

ไลบรารี่หมอน เป็นอนุพันธ์ของ Python Imaging Library (PIL) นำเสนอฟังก์ชันที่มีประสิทธิภาพสำหรับการจัดการรูปภาพ ซึ่งครอบคลุมงานต่างๆ เช่น การแก้ไข การสร้าง การแปลงรูปแบบ และการจัดเก็บ ในการรวมโมดูลนี้เข้ากับโครงการของคุณ ให้เริ่มกระบวนการติดตั้งโดยเปิดอินเทอร์เฟซบรรทัดคำสั่งและดำเนินการคำสั่งที่จำเป็น

 pip install Pillow 

โมดูลเว็บเบราว์เซอร์ซึ่งเป็นส่วนประกอบของไลบรารีมาตรฐาน Python ที่ครอบคลุม ช่วยให้ผู้ใช้เข้าถึง URL ที่ต้องการภายในเว็บเบราว์เซอร์ที่ต้องการโดยไม่ต้องติดตั้งภายนอก

สร้างรหัส Edamam API สำหรับการค้นหาสูตร

หากต้องการรับคีย์ API การค้นหาสูตรอาหาร Edamam โปรดปฏิบัติตามขั้นตอนต่อไปนี้:

⭐ ไปที่ Edamam แล้วคลิกที่ปุ่ม Signup API กรอกรายละเอียดและเลือกแผนของคุณเป็น Recipe Search API-Developer

⭐ ลงชื่อเข้าใช้บัญชีของคุณ คลิกที่ปุ่มบัญชี จากนั้นคลิกที่ปุ่มไปที่แดชบอร์ด

⭐ หลังจากนั้น คลิกที่แท็บ Applications และสุดท้ายคลิกที่ปุ่ม View ถัดจาก Recipe Search API

โปรดคัดลอก ID แอปพลิเคชันที่ให้ไว้ พร้อมด้วยรหัสแอปพลิเคชันที่เกี่ยวข้อง สำหรับการอ้างอิงในอนาคตและการรวมเข้าด้วยกันในกระบวนการพัฒนาแอปพลิเคชันของคุณ

สร้างฟังก์ชันการทำงานเพื่อรับสูตรอาหาร 5 อันดับแรก

ซอร์สโค้ดที่สมบูรณ์ที่จำเป็นในการพัฒนาเสิร์ชเอ็นจิ้นสูตรโดยใช้ Python มีอยู่ในที่เก็บ GitHub นี้โดยเฉพาะ ซึ่งทำหน้าที่เป็นแพลตฟอร์มออนไลน์สำหรับนักพัฒนาในการทำงานร่วมกันและแบ่งปันผลงานกับผู้อื่น

แน่นอน! นี่คือตัวอย่างการใช้งานใน Python โดยใช้ Flask framework และไลบรารี่ของ Elasticsearch สำหรับการค้นหาสูตรตามส่วนผสม: pythonfrom flask import Flask, requestimport request from elasticsearch import Elasticsearchapp=Flask( name )es=Elasticsearch([{‘host’:’localhost’,‘พอร์ต’: 9200}])@app.route(’/’)def ค้นหา():query=request.args.get(‘query’)ถ้าไม่ใช่ query:return “กรุณาป้อนคำค้นหา”, 400# ค้นหาสูตรอาหารที่มีส่วนผสมที่กำหนด response=es.search(index=‘my_index’, body={‘query’: {‘multi

หากผู้ใช้ระบุชื่อสูตร ให้กำหนด URL พื้นฐานสำหรับฟังก์ชันการค้นหาสูตรของ Edamam API โดยรวม ID แอปพลิเคชันและคีย์ที่ได้รับก่อนหน้านี้เพื่อวัตถุประสงค์ในการตรวจสอบสิทธิ์และการอนุญาต

 import tkinter as tk
import requests
from PIL import Image, ImageTk
import webbrowser

def get_top_5_recipes():
    recipe_name = entry_recipe_name.get()
    if recipe_name:
        api_url = "https://api.edamam.com/search"
        app_id = # Put your app id for edamam api
        app_key = # Put your app key for edamam api

ในการสร้างพจนานุกรมที่มีพารามิเตอร์ต่างๆ ที่จำเป็นในคำขอ API ก่อนอื่นเราต้องกำหนดคู่คีย์-ค่าสำหรับคีย์สำคัญสามคีย์ ได้แก่ q , app\_id และ app\_key ควรกำหนดค่าเหล่านี้ตามลำดับที่ได้รับก่อนหน้านี้ นอกจากนี้ สิ่งสำคัญคือต้องตั้งค่าพารามิเตอร์ from ให้แสดงจำนวนผลการค้นหาที่ต้องการในขณะที่ปรับพารามิเตอร์ เป็น ให้สอดคล้องกัน

ในการดึงข้อมูลจาก Edamam API จะต้องส่งคำขอ GET พร้อมกับตำแหน่งข้อมูล API และพารามิเตอร์ที่จำเป็นใดๆ ที่รวมเป็นส่วนหนึ่งของ URL พร้อมกับพจนานุกรมพารามิเตอร์ การตอบสนองที่เป็นผลลัพธ์ควรแยกวิเคราะห์และแตกไฟล์ในรูปแบบ JSON สำหรับการประมวลผลเพิ่มเติม นอกจากนี้ สิ่งสำคัญคือต้องเรียกใช้ฟังก์ชัน “clear\_recipe\_list()” เพื่อลบสูตรที่แสดงก่อนหน้านี้ออกจากการเรียก API ก่อนหน้านี้

         params = {
            "q": recipe_name,
            "app_id": app_id,
            "app_key": app_key,
            "from": 0,
            "to": 5,
        }

        response = requests.get(api_url, params=params)
        data = response.json()
        clear_recipe_list() 

ตรวจสอบว่าคำหลักที่ระบุปรากฏในเนื้อหา JSON ที่ดึงมาหรือไม่ และตรวจสอบให้แน่ใจว่าครอบคลุมผลลัพธ์การค้นหาที่ต้องการ ในกรณีที่มีการยืนยันในเชิงบวก ให้วนซ้ำแต่ละรายการในรายการผลการค้นหาและแยกรายละเอียดสูตรอาหารที่เกี่ยวข้อง ต่อจากนั้น ส่งคำขอ GET HTTP ไปยัง URL ของรูปภาพที่เกี่ยวข้องในขณะที่กำหนดค่าแอตทริบิวต์"สตรีม"เป็นจริง ซึ่งจะช่วยให้สามารถส่งข้อมูลภาพแบบเรียลไทม์ได้

ใช้ฟังก์ชันที่มีให้โดยคลาส รูปภาพ ของไลบรารี่ Pillow เพื่อเข้าถึงภาพดิจิทัลที่ส่ง ปรับความละเอียดของเนื้อหาภาพให้เหมาะสมที่สุดโดยใช้เทคนิคการสุ่มตัวอย่างขั้นสูงของ Lanczos ซึ่งเป็นที่ทราบกันดีว่าให้ผลลัพธ์ที่ยอดเยี่ยมในการดำเนินการปรับขนาดภาพ ต่อจากนั้น แปลงภาพที่ปรับปรุงให้เป็นรูปแบบที่เข้ากันได้กับวัตถุ PhotoImage ของ Tkinter ทำให้สามารถผสานรวมได้อย่างราบรื่นภายในอินเทอร์เฟซผู้ใช้แบบกราฟิก

         if "hits" in data and data["hits"]:
            for i, hit in enumerate(data["hits"]):
                recipe = hit["recipe"]
                recipe_list.append(recipe)
                recipe_name = recipe["label"]
                recipe_link = recipe["url"]
                image_url = recipe["image"]

                image_response = requests.get(image_url, stream=True)
                image = Image.open(image_response.raw)
                image = image.resize((200, 200), Image.LANCZOS)
                photo_image = ImageTk.PhotoImage(image) 

การสร้างโครงสร้างของแอปพลิเคชัน

ในการแสดงชื่อสูตรอาหาร รูปภาพประกอบ และให้ไฮเปอร์ลิงก์ไปยังสูตรอาหารที่เกี่ยวข้องภายในหน้าต่างหลักที่ระบุ ให้ใช้ข้อมูลโค้ดต่อไปนี้ซึ่งกำหนดป้ายกำกับสามป้ายพร้อมแอตทริบิวต์เฉพาะสำหรับแต่ละองค์ประกอบ ป้ายกำกับแรกแสดงชื่อสูตรอาหารโดยใช้ข้อความที่มีให้ ในขณะที่ป้ายกำกับที่สองแสดงรูปภาพโดยใช้แอตทริบิวต์ photo\_image และเปิดใช้งานการคลิกที่ไฮเปอร์ลิงก์โดยตั้งค่าคุณสมบัติ ` เคอร์เซอร์’ของป้ายกำกับที่สามเป็น’hand2’

ในการสร้างการเชื่อมต่อระหว่างไฮเปอร์ลิงก์กับเหตุการณ์คลิกซ้าย จำเป็นต้องเรียกใช้ฟังก์ชัน open\_link() เพื่อทำงานนี้ให้สำเร็จ เราใช้เมธอด pack() ในการจัดระเบียบวิดเจ็ตต่าง ๆ ในขณะที่ตรวจสอบให้แน่ใจว่าวิดเจ็ตนั้นอยู่ในแนวกึ่งกลางตามแกนนอนพร้อมช่องว่างภายในที่เหมาะสม สิ่งสำคัญคือต้องสร้างรายการแยกต่างหากสำหรับจัดเก็บชื่อเรื่อง รูปภาพ และลิงก์ เพื่อให้สามารถเข้าถึงได้ง่ายเมื่อจำเป็น

                 recipe_title_label = tk.Label(
                   canvas_frame,
                   text=f"{i\+1}. {recipe_name}",
                   font=("Helvetica", 12, "bold"),
               )
               recipe_title_label.pack(pady=(5, 0), anchor=tk.CENTER)

               image_response = requests.get(image_url, stream=True)
               image = Image.open(image_response.raw)
               image = image.resize((200, 200), Image.LANCZOS)
               photo_image = ImageTk.PhotoImage(image)
               image_label = tk.Label(canvas_frame, image=photo_image)
               image_label.image = photo_image
               image_label.pack(pady=(0, 5), anchor=tk.CENTER)

               link_label = tk.Label(
                   canvas_frame, text=recipe_link, fg="blue", cursor="hand2"
               )
               link_label.pack(pady=(0, 10), anchor=tk.CENTER)
               link_label.bind(
                   "<Button-1>", lambda event, link=recipe_link: open_link(link)
               )

               recipe_labels.append(recipe_title_label)
               recipe_images.append(photo_image)
               recipe_links.append(link_label) 

เพื่อกำจัดองค์ประกอบภาพทั้งหมดที่เกิดจากคำขอก่อนหน้านี้ แนะนำฟังก์ชันใหม่ชื่อ clear\_recipe\_list() การดำเนินการนี้จะลบร่องรอยของข้อมูลทั้งหมดที่อยู่ในรายการสูตร ขณะที่วนซ้ำผ่านแต่ละรายการในคอลเล็กชัน Recipe\_labels

การใช้ฟังก์ชัน “pack\_forget()” เพื่อแยกฉลากที่แสดงในขณะที่รักษาโครงสร้างวิดเจ็ตพื้นฐานไว้ จะเรียกว่าการลบป้ายกำกับออกจากการนำเสนอด้วยภาพ แต่ยังคงไว้ซึ่งฟังก์ชันการทำงานภายในโปรแกรม

เพื่อให้แน่ใจว่าข้อมูลทั้งหมดที่เกี่ยวข้องกับสูตรอาหารเป็นปัจจุบัน จำเป็นต้องล้างข้อมูลที่มีอยู่ที่เกี่ยวข้องกับฉลากสูตรอาหาร ซึ่งรวมถึงข้อความของฉลากเท่านั้น แต่ยังรวมถึงรูปภาพหรือไฮเปอร์ลิงก์ที่เกี่ยวข้องด้วย เพื่ออำนวยความสะดวกในกระบวนการนี้ เราสามารถกำหนดฟังก์ชันที่เรียกว่า “open\_link()” ซึ่งจะเปิดลิงก์สูตรที่เกี่ยวข้องภายในเว็บเบราว์เซอร์ที่ผู้ใช้ต้องการ

 def clear_recipe_list():
    recipe_list.clear()
    for label in recipe_labels:
        label.pack_forget()
    recipe_labels.clear()
    for image_label in recipe_images:
        image_label.pack_forget()
    recipe_images.clear()
    for link_label in recipe_links:
        link_label.pack_forget()
    recipe_links.clear()

def open_link(link):
    webbrowser.open(link) 

เริ่มต้นหน้าต่างหลักของ Tkinter โดยระบุชื่อโปรแกรมและสร้างวิดเจ็ตระดับบนสุด กำหนดขนาดของหน้าต่างและใช้ความละเอียดที่ต้องการเพื่อคุณภาพการแสดงผลที่ดีที่สุด สร้างสีทึบหรือการไล่ระดับสีเป็นธีมพื้นหลังเพื่อเพิ่มความดึงดูดสายตา สร้างองค์ประกอบเฟรมที่ทำหน้าที่เป็นคอนเทนเนอร์สำหรับส่วนประกอบอื่นๆ ภายในอินเทอร์เฟซ ระบุพาเรนต์ของเฟรมในขณะที่กำหนดความกว้าง ความสูง และเฉดสีพื้นหลัง ออกแบบฉลาก ฟิลด์ป้อนข้อมูล และปุ่มค้นหา ซึ่งแต่ละอย่างเป็นไปตามหลักปฏิบัติที่ดีที่สุดในหลักการออกแบบ GUI ใช้ตัวจัดการเลย์เอาต์ pack เพื่อจัดระเบียบองค์ประกอบเหล่านี้อย่างมีประสิทธิภาพ โดยใช้ระยะห่างที่เหมาะสมเมื่อจำเป็น

 root = tk.Tk()
root.title("Recipe Finder")
root.geometry("600x600")
root.configure(bg="#F1F1F1")

frame = tk.Frame(root, bg="#F1F1F1")
frame.pack(fill=tk.BOTH, expand=tk.YES, padx=20, pady=20)

label_recipe_name = tk.Label(
   frame, text="Enter Recipe Name:", font=("Helvetica", 14, "bold"), bg="#F1F1F1"
)
label_recipe_name.pack()

entry_recipe_name = tk.Entry(frame, font=("Helvetica", 12))
entry_recipe_name.pack(pady=5)

search_button = tk.Button(
   frame,
   text="Search Recipes",
   font=("Helvetica", 12, "bold"),
   command=get_top_5_recipes,
)
search_button.pack(pady=10) 

“สั่งให้คอมพิวเตอร์สร้างผืนผ้าใบเปล่าที่มีฉากหลังสีขาวบริสุทธิ์ ซึ่งจะทำหน้าที่เป็นพื้นที่จัดแสดงสำหรับวิดเจ็ตต่างๆ ที่มีส่วนผสมและคำแนะนำเกี่ยวกับอาหารปรุงสุก โปรดวางตำแหน่งตู้โชว์ภาพนี้ไว้ที่ขอบด้านซ้ายของหน้าจอ เพื่อให้ครอบคลุมความกว้างทั้งหมดของพื้นที่ที่จัดสรร ขณะเดียวกันก็ขยายขนาดเมื่อหน้าต่างถูกปรับขนาด

ในการสร้างแถบเลื่อนแนวตั้งสำหรับผืนผ้าใบ ก่อนอื่นเราต้องเรียกเมธอด scrollbars()'ของพาเรนต์วิดเจ็ต (ในกรณีนี้คือหน้าต่างหลัก) เพื่อเปิดใช้งานหากถูกปิดใช้งานตามค่าเริ่มต้น จากนั้น เราสามารถใช้ฟังก์ชัน create_window จากโมดูล tkinter เพื่อสร้างวัตถุแถบเลื่อนใหม่ที่มีคุณสมบัติที่ต้องการ เช่น ขนาด คำสั่ง ฯลฯ หลังจากนั้น เราจำเป็นต้องเพิ่มการผูกเหตุการณ์ลงในช่อง"ปุ่ม"ของแถบเลื่อน ดังนั้น เมื่อมีการคลิกหรือลาก จะเรียกใช้เมธอดที่สอดคล้องกันในคลาสคอนโทรลเลอร์ของแถบเลื่อน สุดท้าย เราสามารถผูกการเคลื่อนไหวของแถบเลื่อนเข้ากับผืนผ้าใบโดยใช้เมธอด xview และ yview ` ของวิดเจ็ตผืนผ้าใบ

เพื่อสร้างขอบเขตที่เหมาะสมภายในสภาพแวดล้อมผ้าใบเพื่อรองรับส่วนประกอบของสูตรอาหาร และติดไว้ที่มุมซ้ายบนของหน้าจอแสดงผลอย่างแน่นหนา ใช้โอกาสนี้และควบคุมตามนั้น เพื่อรับประกันว่ากรอบที่ครอบคลุมจะสามารถเลื่อนได้อย่างเพียงพอเมื่อ เนื้อหาของมันผ่านการเปลี่ยนแปลงหรือปรับขนาด

 canvas = tk.Canvas(frame, bg="white")
canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.YES)

scrollbar = tk.Scrollbar(frame, orient=tk.VERTICAL, command=canvas.yview)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
canvas.configure(yscrollcommand=scrollbar.set)

canvas_frame = tk.Frame(canvas, bg="white")
canvas.create_window((0, 0), window=canvas_frame, anchor=tk.NW)
canvas_frame.bind(
   "<Configure>", lambda event: canvas.configure(scrollregion=canvas.bbox("all"))
) 

ที่เก็บสูตรอาหาร ฉลากสำหรับระบุรายการหรือหมวดหมู่เฉพาะ การแสดงภาพในรูปแบบของรูปภาพ และการเชื่อมโยงหลายมิติที่เชื่อมโยงข้อมูลที่เกี่ยวข้องเข้าด้วยกัน ด้วยการใช้คุณสมบัติหลักเหล่านี้ ผู้ใช้สามารถนำทางผ่านแอปพลิเคชันได้อย่างง่ายดายในขณะที่ได้รับประโยชน์จากการนำเสนอข้อมูลที่เป็นระเบียบ ฟังก์ชัน mainloop() ทำหน้าที่เป็นรากฐานที่สำคัญของการออกแบบนี้โดยสั่งให้ล่าม Python เปิดใช้งาน Tkinter event loop สิ่งนี้ทำให้โปรแกรมสามารถตรวจสอบเหตุการณ์ที่เข้ามาอย่างต่อเนื่องและตอบสนองตามนั้นจนถึงเวลาที่ผู้ใช้เลือกที่จะปิดอินเทอร์เฟซแบบกราฟิก ด้วยกระบวนการซ้ำๆ นี้ แอปพลิเคชันของเรายังคงตอบสนองและปรับให้เข้ากับอินพุตของผู้ใช้ สร้างประสบการณ์ที่ราบรื่นตลอดการโต้ตอบแต่ละครั้ง

 recipe_list = []
recipe_labels = []
recipe_images = []
recipe_links = []

root.mainloop() 

สัมผัสประสบการณ์อาหารรสเลิศที่หลากหลายด้วยการคลิกเมาส์ง่ายๆ เพราะเรารวบรวมอาหารหลากหลายจากทั่วโลกเพื่อความสะดวกของคุณ

ผลลัพธ์ของแอปพลิเคชันค้นหาสูตรอาหาร

เมื่อรันแอปพลิเคชันซอฟต์แวร์และพิมพ์"เบอร์เกอร์ไก่"เป็นอินพุต รายการผลการค้นหาห้าอันดับแรกจะปรากฏขึ้น การรวบรวมนี้ประกอบด้วยชื่อเรื่อง รูปภาพประกอบ และไฮเปอร์ลิงก์ไปยังหน้าสูตรที่เกี่ยวข้อง เมื่อเลือก URL ที่ระบุ อินเทอร์เน็ตเบราว์เซอร์ที่คุณต้องการจะเปิดหน้าเว็บที่ระบุโดยอัตโนมัติ ขณะที่คุณเลื่อนดูเนื้อหา ขนาดจะคงที่ในขณะที่นำเสนอผลการค้นหาหลายรายการที่จัดตำแหน่งอย่างสมมาตรตรงกลางหน้าจอ

การปรับปรุงแอปพลิเคชันค้นหาสูตรอาหาร

เพื่อปรับแต่งการทำงานของซอฟต์แวร์การค้นหาสูตรอาหารของเรา เราได้รวมตัวเลือกต่างๆ สำหรับการกรองและจัดระเบียบผลการค้นหาตามรสนิยมและความต้องการส่วนบุคคล ผู้ใช้อาจเลือกที่จะจำกัดการค้นหาให้แคบลงโดยระบุเกณฑ์ เช่น ข้อจำกัดด้านอาหาร เวลาในการเตรียมตัว และภูมิหลังทางวัฒนธรรม ขณะเดียวกันก็มีความยืดหยุ่นในการจัดเรียงผลลัพธ์ตามลำดับที่ต้องการ

แนะนำคุณสมบัติส่วนบุคคลที่ช่วยให้ผู้ใช้สามารถบันทึกสูตรอาหารที่ต้องการเพื่อใช้อ้างอิงในอนาคต ในขณะเดียวกันก็เปิดโอกาสให้แบ่งปันการเลือกเหล่านี้กับเพื่อนและครอบครัวผ่านแพลตฟอร์มโซเชียลเน็ตเวิร์กต่างๆ นอกจากนี้ ให้พิจารณาใช้ระบบการจัดหมวดหมู่ที่เน้นอาหารที่ค้นหายอดนิยมหรืออาหารที่บันทึกไว้บ่อย ทำให้ผู้ใช้สามารถสำรวจตัวเลือกการทำอาหารใหม่ๆ ตามความชอบร่วมกันของชุมชน

ใช้ประโยชน์จากความสามารถของคุณในการเขียนโปรแกรมและใช้ความสามารถที่แข็งแกร่งของ Application Programming Interfaces (API) คุณจึงมีศักยภาพในการแปลงแอปพลิเคชันพื้นฐานนี้เป็นโซลูชันขั้นสูงที่ครอบคลุม