• หน้าแรก
  • หลักสูตร
  • บทความ
  • ร้านค้า
  • ติดต่อเรา
    มีคำถามเกี่ยวกับ odoo ?
    (02) 4302475
    info@odoothaidev.com
    Login
    Odoothaidev - We are Odoo professional in Thailand
    • หน้าแรก
    • หลักสูตร
    • บทความ
    • ร้านค้า
    • ติดต่อเรา

      Uncategorized

      • บ้าน
      • บล็อก
      • Uncategorized
      • สร้างแอพ Chat ด้วย Node.js และ Socket.IO

      สร้างแอพ Chat ด้วย Node.js และ Socket.IO

      • โพสโดย admin
      • หมวดหมู่ Uncategorized
      • วันที่ กรกฎาคม 26, 2019
      • ความคิดเห็น 0 ความคิดเห็น
      • แท็ก nodejs

      วันนี้เรามาลองทำแอพ chat แบบเรียลไทม์ด้วย Node.js กันครับ สมัยก่อนอาจจะดูยุ่งยาก แต่สมัยนี้เราสามารถทำแอพแนวนี้ได้ง่ายเอามากๆ เลย เพื่อไม่ให้เสียเวลา เรามาเริ่มกันเลยฮะ

      แต่ก่อนเราทำอย่างไร ?

      คาดว่าหลายๆ คน คงจะเคยทำเว็บที่มีการ refresh ข้อมูลอยู่เรื่อยๆ ใช่มั้ยครับ วิธีทำก็อาจจะใช้การตั้งเวลาดึงข้อมูลมาจาก server ทุกๆ กี่นาทีก็ว่าไป แต่ลองนึกดูครับว่าถ้าจะทำแอพ chat กันแบบเรียลไทม์ การส่ง request ไปหา server เพื่อจะถามว่ามีใครส่งข้อความอะไรมาให้เราแล้วหรือยังก็คงจะต้องถี่เอามากๆ เลย บางทีส่งไปแล้วปรากฏว่าไม่มีใครส่งอะไรมาหาเราเลยก็เท่ากับว่า request นั้นสูญเปล่าถูกมั้ยครับ แล้วที่สำคัญ ในแต่ละ request นั้น มันก็จะมี overhead ด้วย เผลอๆ overhead อาจมีขนาดใหญ่กว่าข้อความที่คุยกันด้วยซ้ำไป วิธีนี้จึงไม่น่าจะเวิร์คกับแอพของเราครับ

      รู้จักกับ Web Socket

      วิธีที่น่าสนใจกว่าก็คือการสื่อสารกันผ่านสิ่งที่เรียกว่า Web Socket ครับ เพื่อให้เห็นภาพชัดๆ ผมขอเปรียบเทียบว่ามันก็เหมือนกับการสร้าง “ท่อ” เชื่อมระหว่าง client กับ server เข้าด้วยกันครับ โดยจุดเด่นของ Web Socket ก็คือ มันจะเป็นการสื่อสารแบบ 2 ทางครับ คือใครจะส่งข้อมูลไปหาใครก็ได้ นั่นหมายความว่าเราจะไม่ต้องคอยถาม server แล้วว่ามีใครส่งอะไรมาให้เรามั้ย เพราะเราจะให้ server เป็นคนบอกเราเองครับ นอกจากนั้น เจ้าท่อที่ว่านี้มันจะต่อค้างเอาไว้ด้วยนะครับ คือไม่ได้หายไปเวลาส่งข้อมูลเสร็จ นั่นหมายความว่าการส่งแต่ละครั้งจะไม่มีปัญหาเรื่อง overhead แล้วล่ะครับ

      ภาพรวมของแอพ

      ทีนี้เรามาดูตัวแอพของเราบ้างครับ ผมมองว่ามันแบ่งออกเป็น 2 ส่วน ดังนี้

      • Serverเอาไว้รับข้อความจาก client และกระจายข้อความนั้นไปยัง client ทุกๆ เครื่องที่เชื่อมต่ออยู่
      • Clientเอาไว้ส่งข้อความที่จะคุยไปยัง server และรับข้อความของคนอื่นที่ server ส่งมา

      เพื่อให้เห็นภาพมากขึ้น สมมติว่าในห้อง chat มีคนอยู่ 3 คน คือ A, B และ C แอพของเราจะต้องทำแบบนี้ได้ครับ

      1. A ส่งข้อความไปยัง server
      2. server ได้รับข้อความจาก A
      3. server ส่งข้อความของ A ไปยัง client ทั้งหมด ซึ่งก็คือ A, B และ C
      4. A, B และ C ได้รับข้อความของ A จาก server

      จะสังเกตนะครับว่า A ไม่ได้คุยกับ B และ C ตรงๆ และนี่เป็นเหตุผลครับว่าทำไมเราต้องมี server

      รู้จักกับ Socket.IO

      Socket.IO เป็นโมดูลของ Node.js ที่เอาไว้เรียกใช้งาน Web Socket ครับ ส่วนวิธีใช้งานนั้นก็ไม่ยากเลย เพราะที่ใช้หลักๆ แล้วจะมีด้วยกัน 2 แบบ เท่านั้นเองครับ

      • socket.on(ชื่อท่อ, callback)เมื่อได้รับข้อมูลมาทางท่อนี้ให้ทำอะไร
      • socket.emit(ชื่อท่อ, ข้อมูลที่จะส่ง)ส่งข้อมูลไปยังทุกๆ client ที่เชื่อมต่อกับท่อนี้อยู่

      จะเห็นว่าโค้ดนั้นเข้าใจง่ายมากเลยใช่มั้ยครับ งั้นเรามาเริ่มลงมือเขียนแอพกันเลยดีกว่าครับ

      Workshop – เขียนแอพ Instant Messaging

      สำหรับ workshop นี้ ผมจะขอถือว่าเราคุ้นเคยกับการใช้ Node.js, Express และ Jade มาเป็นอย่างดีแล้วนะครับ เพราะจะได้เน้นไปที่เนื้อหาเกี่ยวกับการใช้งาน Socket.IO ได้เต็มที่ครับ แต่ถ้าใครอยากจะทบทวนความรู้ ก็สามารถอ่านจากบทความด้านล่างนี้ได้เลยครับ

      • Node.js คืออะไร?
      • วิธีใช้ Node.js ทำเว็บไซต์ด้วย Express
      • วิธีใช้ Jade ร่วมกับ Express
      • Syntax ของ Jade

      ก่อนจะเริ่ม workshop หากเพื่อนๆ ยังไม่สะดวกที่จะเขียนโค้ดตามก็ไม่เป็นไรนะครับ แนะนำให้อ่านแล้วพยายามทำความเข้าใจโค้ดก็พอฮะ เพราะที่ท้ายบทความจะมี source code ให้ดาวน์โหลดไปลองเล่นอยู่แล้ว

      1. ติดตั้ง Dependency

      เริ่มต้นด้วย package.json ตามนี้ได้เลยครับ

      1
      2
      3
      4
      5
      6
      7
      8
      9
      {
        “name”: “realtime-chat”,
        “version”: “0.1.0”,
        “devDependencies”: {
          “express”: “^4.12.3”,
          “jade”: “^1.9.2”,
          “socket.io”: “^1.3.5”
        }
      }

      จากนั้นก็ติดตั้ง dependency ต่างๆ ด้วยคำสั่ง

      1
      npm install

      2. เตรียมไฟล์ต่างๆ

      โครงสร้างของแอพจะเป็นแบบนี้ครับ ให้เราสร้างไฟล์เปล่าๆ มารอไว้ก่อนได้เลย

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      |— app.js
      |
      |— node_modules/
      |   – express
      |   – jade
      |   – socket.io
      |
      |— package.json
      |
      |— public/
      |   – css/
      |     – main.css
      |
      `— views/
          – index.jade

      3. เขียนโค้ดที่ app.js

      เริ่มกันที่ไฟล์ app.js ครับ ให้เราใส่โค้ดด้านล่างนี้ลงไปได้เลย

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      var express = require(‘express’);
      var app = express();
      var path = require(‘path’);
      var port = 8081;
      var server = app.listen(port, function() {
          console.log(‘Listening on port: ‘ + port);
      });
      app.set(‘views’, path.join(__dirname, ‘views’));
      app.set(‘view engine’, ‘jade’);
      app.use(express.static(‘public’));
      app.get(‘/’, function(req, res) {
          res.render(‘index’);
      });

      จะเห็นว่าเป็นโค้ดสำหรับสร้าง http server ธรรมดาๆ ที่ port 8081 ครับ นอกจากนั้นก็จะมีการกำหนดว่าให้ใช้ Jade เป็น template engine นะ กำหนดให้ Express อ่านไฟล์ static ที่โฟลเดอร์ public นะ แล้วก็ทำ route สำหรับหน้าแรกให้ไปอ่าน template ที่ไฟล์ index.jadeครับ

      4. เขียนโค้ดที่ index.jade

      จากนั้นมาดูที่ไฟล์ index.jade ครับ ให้เราใส่โค้ดด้านล่างนี้ลงไป

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      doctype html
      html
          head
              title Realtime Chat using Node.js and Socket.IO
              meta(name=‘viewport’, content=“initial-scale=1”)
              link(rel=‘stylesheet’, href=‘css/main.css’)
          body
              div.box.box—container
                  div.box.box—chat
                      ul#chat-history
                      form#chat-form(action=””)
                          input.box(type=“text”, id=“chat-message”, autocomplete=“off”, placeholder=“Enter message here…”)

      ไล่โค้ดดูก็จะพบว่ามี form ที่เราจะเอาไว้พิมพ์ข้อความสำหรับ chat นั่นเองครับ

      5. เขียนโค้ดที่ main.css

      เพื่อความสวยงามของแอพเรา ให้ใส่โค้ด css ด้านล่างนี้ ลงไปที่ไฟล์ public/css/main.cssครับ

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      * {
          box-sizing: border-box;
          margin: 0;
          padding: 0;
      }
      html {
          font-size: 62.5%;
      }
      body {
          background: #ccc;
          font-family: arial, san-serif;
          font-size: 1.2em;
          color: #666;
      }
      .box {
          width: 100%;
          border-radius: 3px;
      }
      .box–container {
          max-width: 640px;
          margin: 0 auto;
          padding: 15px;
      }
      .box–chat {
        background: #fff;
        padding: 15px;
        border: 1px solid #eee;
      }
      #chat-history {
          list-style: none;
          padding: 0 0 10px 0;
          overflow: auto;
          height: 250px;
      }
      .message {
          background: #eee;
          padding: 10px 15px;
          border-radius: 20px;
          margin-bottom: 5px;
          float: left;
          clear: both;
      }
      .message–me {
          background: #B3ED7A;
          float: right;
      }
      #chat-message {
          background: #f5f5f5;
          padding: 10px;
          border: 1px solid #d5d5d5;
      }

      6. ลองรัน

      ให้เราลองรันดูเลยครับว่าหน้าตาของแอพเราในตอนนี้เป็นอย่างไร

      1
      node app.js

      เมื่อลองรันดูก็จะเห็นแอพหน้าตาสวยงาม มีช่องสำหรับพิมพ์ข้อความ แต่พอลองพิมพ์แล้ว Enter ดูก็จะพบว่ายังไม่มีอะไรเกิดขึ้นครับ

      7. เรียกใช้ Socket.IO ที่ฝั่ง Server

      ที่ไฟล์ app.js ให้เพิ่มโค้ดสำหรับใช้งาน Socket.IO เข้าไปต่อท้ายแบบนี้ครับ

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      // app.js
      .
      .
      .
      var io = require(‘socket.io’).listen(server);
      // เมื่อมี client เข้ามาเชื่อมต่อให้ทำอะไร?
      io.on(‘connection’, function(socket) {
          // แสดงข้อความ “a user connected” ออกมาทาง console
          console.log(‘a user connected’);
      });

      เสร็จแล้วอย่าเพิ่งรันแอพใหม่นะครับ เพราะเราจะต้องไปเซท Socket.IO ที่ฝั่ง client ด้วย

      8. เรียกใช้ Socket.IO ที่ฝั่ง Client

      ให้ไปดูที่ไฟล์ index.jade แล้วไปเพิ่ม script ของ socket.io แบบนี้ครับ

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      // index.jade
      doctype html
      html
          head
              .
              .
              .
          body
              .
              .
              .
              script(src=“https://cdn.socket.io/socket.io-1.3.3.js”)
              script.
                  // เชื่อมต่อกับ server ผ่าน Web Socket    
                  var socket = io();

      9. ลองรันใหม่

      เรามาลองรันแอพใหม่ดูอีกทีครับ คราวนี้เมื่อลองเข้าหน้าแอพผ่าน browser แล้วกลับไปดูที่ console เราก็จะเห็นข้อความ a user connected แล้วล่ะครับ หากลองรีเฟรช browser หลายๆ ที เราก็จะเห็นข้อความแสดงตามจำนวนครั้งที่เรารีเฟรชครับ

      10. ส่งข้อมูลไปยัง Server

      ก่อนหน้านี้เราก็แค่ดัก event ว่าพอมี client เข้ามาเขื่อมต่อ ก็ให้แสดงข้อความออกมาใช่มั้ยครับ ทีนี้เราจะมาลองเขียนโค้ดให้ client เป็นคนส่งข้อมูลไปหา server เองดูบ้าง ให้เข้าไปที่ไฟล์ index.jade อีกทีครับ แล้วเพิ่มโค้ด socket.emit(ชื่อท่อ, ข้อมูลที่จะส่ง) เข้าไปแบบนี้ครับ

      1
      2
      3
      4
      5
      6
      // index.jade
      script.
          var socket = io();
          // ส่งข้อความ “Hello” ไปหา server ผ่านทางท่อชื่อ “chat”
          socket.emit(‘chat’, ‘Hello’);

      จากนั้น ที่ไฟล์ app.js เราก็จะเพิ่มโค้ด socket.on(ชื่อท่อ, callback) เพื่อเอาไว้รอรับข้อมูลที่ client จะส่งมาครับ

      1
      2
      3
      4
      5
      6
      7
      8
      9
      // app.js
      io.on(‘connection’, function(socket) {
          // เมื่อได้รับข้อมูลจากท่อ “chat” ให้ทำอะไร?
          socket.on(‘chat’, function(message) {
              // แสดงข้อมูลที่ได้ ออกมาทาง console
              console.log(message);
          });
      });

      เมื่อลองรันใหม่ เราก็จะเห็นข้อความ Hello ที่ client เป็นคนส่งมา แสดงผลออกมาทาง console ครับ

      ชื่อของ “ท่อ” จะเป็นอะไรก็ได้ เพียงแต่ต้องตั้งชื่อให้เหมือนกันทั้งฝั่ง client และ server

      11. เปลี่ยนมาส่งข้อมูลด้วย Form Input

      ก่อนหน้านี้เราจะระบุข้อความที่จะส่งลงไปตรงๆ เลยใช่มั้ย ทีนี้เราจะเปลี่ยนมาใช้ form input ในการรับข้อความที่จะส่งจาก user กันดีกว่าครับ ให้เราเข้าไปแก้โค้ดที่ไฟล์ index.jade

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      // index.jade
      // โหลด jQuery มาใช้งาน
      script(src=“https://code.jquery.com/jquery-2.1.3.min.js”)
      script.
          var socket = io();
          // เมื่อ form ถูก submit ให้ทำอะไร?
          $(‘#chat-form’).submit(function() {
              // ส่งข้อความที่พิมพ์มาไปยัง server ผ่านทางท่อชื่อ “chat”
              socket.emit(‘chat’, $(‘#chat-message’).val());
              return false;
          });

      จากนั้นก็ลองรันดูอีกทีครับ ให้เราลองพิมพ์ข้อความอะไรก็ได้ แล้วลอง Enter ดู จากนั้นให้ลองไปดูที่ console เราก็จะเห็นข้อความที่เราพิมพ์ แสดงผลออกมาครับ

      12. กระจายข้อมูลไปยังทุกๆ Client

      ทีนี้มาถึงตา server กันบ้างครับ เราจะเขียนโค้ดให้ server กระจายข้อความเมื่อกี้ไปยัง client ทั้งหมดที่มีการเชื่อมต่อกับท่อที่ชื่อ “chat” อยู่ ให้เราเข้าไปที่ไฟล์ app.js แล้วเปลี่ยนจาก console.log() มาเป็น io.emit() แทน แบบนี้เลยครับ

      1
      2
      3
      4
      5
      6
      7
      8
      // app.js
      io.on(‘connection’, function(socket) {
          socket.on(‘chat’, function(message) {
              // ส่งข้อความที่ได้ไปหาทุกๆ client ที่เชื่อมต่อกับท่อชื่อ “chat”
              io.emit(‘chat’, message);
          });
      });

      แต่แค่นั้นยังไม่พอนะครับ เราจะต้องไปเพิ่มโค้ดรับข้อมูลที่ทางฝั่ง client ด้วย ให้เราเข้าไปที่ไฟล์ index.jade  แล้วเพิ่มโค้ดด้านล่างนี้ลงไปครับ

      1
      2
      3
      4
      5
      6
      7
      // index.jade
      // เมื่อได้รับข้อมูลจากท่อ “chat” ให้ทำอะไร?
      socket.on(‘chat’, function(message) {
          // แสดงผลข้อความที่ได้มาออกมาทางหน้าจอ
          $(‘#chat-history’).append($(‘<li class=”message”>’).text(message));
      });

      เรียบร้อยแล้วครับ เรามาลองเล่นดูเลย จะเห็นว่าเวลาเราพิมพ์อะไรลงไป ข้อความที่เราพิมพ์ก็จะขึ้นมาด้วยครับ แนะนำให้ลองเปิดมาอีก browser นึง แล้วลอง chat กับตัวเองดู เราก็จะพบว่าข้อความที่คุยกันมันอัพเดทแบบเรียลไทม์เลยล่ะครับ

      บทสรุป

      จะเห็นว่าการใช้ Node.js ร่วมกับ Socket.IO นั้น ช่วยให้เราสามารถสร้างแอพ Instant Messaging ขึ้นมาได้ง่ายๆ เลยใช่มั้ยครับ จริงๆ แล้ว การใช้ Socket.IO หลักๆ ก็มีอยู่เท่านี้ฮะ เราก็แค่ไปตั้งชื่อท่อของทั้งสองฝั่ง หากท่อชื่อตรงกันก็จะคุยกันรู้เรื่องครับ

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

      ผมอยากให้เพื่อนๆ ไปลองต่อยอดแอพนี้ให้มันใช้งานได้จริงๆ นะครับ หรือจะลองใช้ Socket.IO ทำแอพแนวอื่นดูก็ได้ฮะ แอพไหนซับซ้อนหน่อยก็อาจจะใช้หลายๆ ท่อเข้ามาช่วย แล้วแต่เราจะออกแบบเลยครับ ส่วนตัวผมเองก็ได้ลองต่อยอดแอพนี้ไปนิดหน่อยครับ คือจะแยกสีข้อความของตัวเองออกจากข้อความของคนอื่นด้วย เพื่อนๆ คนไหนทำแอพเสร็จแล้ว อย่าลืมเอามาให้ลองเล่นกันบ้างนะครับ

      Instant Messaging Screenshot

      [anakual_button title=”Download source” btn_color=”red” link=”http://static.siamhtml.com/tutorials/coding/socket.io.zip||target:%20_blank|”]

      แท็ก:nodejs

      • Share:
      อวตารของผู้เขียน
      admin

      โพสต์ก่อนหน้า

      สร้าง API ง่ายๆ ด้วย Node.js และ Express
      กรกฎาคม 26, 2019

      โพสต์ถัดไป

      [Beginner] Node.js คืออะไร
      กรกฎาคม 26, 2019

      คุณอาจชอบ

      ODOO IMPLEMENTATION PLAN
      23 กุมภาพันธ์, 2022

      plan is created individually for each cu …

      Install, Configure and Setting up Etherpad Server for Odoo
      6 กันยายน, 2019

      Etherpad is a highly customizable Open S …

      odoo-development 10 by IT-Project
      29 กรกฎาคม, 2019

      ทิ้งคำตอบไว้

      อีเมลของคุณจะไม่แสดงให้คนอื่นเห็น ช่องข้อมูลจำเป็นถูกทำเครื่องหมาย *

      ค้นหาบทความ

      หมวดหมู่

      หมวดหมู่

      • Accounting
      • Adobe XD
      • API
      • Blog
      • Business
      • Buttons
      • CRM
      • Custom Fields
      • Design / Branding
      • Django
      • Ecommerce
      • ERP
      • ERP Flow
      • Express
      • Flectra
      • Form View
      • Frontend
      • Github
      • Github
      • Grant Chart
      • Header
      • iReport
      • Jasper Server & Server
      • Jaspersoft Studio
      • Java
      • JSON-RPC
      • Lazada
      • Linux
      • MLM
      • MRP
      • Nignx Proxy
      • NodeJS
      • Odoo 10
      • Odoo 12 Module
      • Odoo 13
      • Odoo 14 Development
      • Odoo 16
      • Odoo 8
      • Odoo 9
      • Odoo API
      • Odoo Certification
      • Odoo Developer
      • Odoo Ebook
      • Odoo Enterprise
      • Odoo ERP
      • Odoo Event
      • Odoo Implement
      • Odoo Inventory
      • Odoo Report
      • Odoo V15
      • Open Source
      • Open-office
      • OpenERP 7.0
      • PhantomJS
      • Postgres SQL
      • Programming Language
      • Project Management
      • Python
      • Python3
      • Qweb
      • Reporting ระบบรายงาน
      • RML Report
      • Search View and Filters
      • Social Network
      • Statusbar
      • Ubuntu
      • Uncategorized
      • Voip & Call Center
      • Warehouse Management
      • WMS
      • Woocommerce
      • Workflow
      • XML-RPC
      • การ Implement
      • การเก็บข้อมูล Pre-Requirement
      • การเตรียมตัวเพื่อใช้งาน erp
      • ความรู้ด้านการตลาด CRM
      • ธีมเว็บไซต์ Odoo
      • ธุรกิจบริการ
      • ธุรกิจประเภทจัดอบรมสัมมนา
      • ธุรกิจสิ่งพิมพ์
      • นักพัฒนา
      • ประเภทธุรกิจที่เหมาะกับ Odoo
      • ระบบบัญชี
      • ระบบเคลม
      • ลิขสิทธิ์ – License
      Introduction LearnPress – LMS plugin

      Introduction LearnPress – LMS plugin

      Free
      From Zero to Hero with Nodejs

      From Zero to Hero with Nodejs

      Free
      Learn Python – Interactive Python

      Learn Python – Interactive Python

      $69.00

      บทความล่าสุด

      V16 Planned Date of Tasks are invisible.
      12ก.พ.2023
      Odoo Implement Methodology
      29พ.ย.2022
      Odoo Enterprise Subscription Agreement
      29พ.ย.2022
      (02) 430-2475
      info@odoothaidev.com
      Facebook Twitter Google-plus Pinterest

      Odoothaidev by OdooTeaM.

      • Privacy
      • Terms
      • Sitemap
      • Purchase

      เข้าสู่ระบบด้วยบัญชีเว็บไซต์ของคุณ

      ลืมรหัสผ่าน?

      Click to Copy