ark_backend/app/api/api_v1/endpoints/line.py

import uuid
import fastapi
import pymysql
pymysql.install_as_MySQLdb()
from linebot.models import (
    MessageEvent, TextMessage, TextSendMessage, FollowEvent,
    TemplateSendMessage, ButtonsTemplate, URITemplateAction,
)
from linebot.exceptions import LineBotApiError
import dataset
import requests
import json
import qrcode
from fastapi.encoders import jsonable_encoder
from random import randrange
from app.schemas import line
from app.core.config import settings
import datetime as dt
from fastapi import APIRouter, FastAPI, Request, Response, Body,Depends
from fastapi.routing import APIRoute
from app.api import deps
from app import crud, models, schemas
from typing import Callable, List
from uuid import uuid4
from sqlalchemy.orm import Session
from datetime import datetime
import httpx

import pymysql
pymysql.install_as_MySQLdb()


async def request_get(url, headers):
    async with httpx.AsyncClient() as client:
       return await client.get(url, headers = headers)

class LineRouter(APIRoute):
    def get_route_handler(self) -> Callable:
        original_route_handler = super().get_route_handler()

        async def custom_route_handler(request: Request) -> Response:
            try:
                the_body = await request.json()
            except:
                the_body = ""
            response: Response = await original_route_handler(request)
            print(f"request payload: {the_body}")
            # print(f"route response: {response.body}")
            print(f"route response headers: {response.headers}")
            return response

        return custom_route_handler


router = APIRouter(route_class=LineRouter)
baseUrl = "https://nft-api-staging.joyso.io/api/v1/"
headers = {
    'Authorization':
        'Basic %s' % 'bmZ0OmMxOTEzOWMzYjM3YjdjZWU3ZmY3OTFiZGU3NzdjZWNl'
}
def check_account(event):
    real_user_id = event.source.user_id
    db = dataset.connect('mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4')
    table = db['users']
    result1 = table.find_one(userid=real_user_id)

    # 都存在db的話
    if result1:
        print('already in db')
        db.close()
        settings.line_bot_api.reply_message(
            event.reply_token,
            TextSendMessage(text='很高興再見到您！'))

    # 建立全新使用者
    else:
        # create user account api
        url = 'https://nft-api-staging.joyso.io/api/v1/accounts'
        headers = {
            'Authorization':
            'Basic bmZ0OmMxOTEzOWMzYjM3YjdjZWU3ZmY3OTFiZGU3NzdjZWNl'
        }
        try:
            profile = settings.line_bot_api.get_profile(real_user_id)
            #print(profile['displayName'])
        except LineBotApiError as e:
            pass
        user_id = event.source.user_id
        data = 'uid=' + user_id
        r = requests.post(url=url, headers=headers, data=data)
        try:
            dict_str = json.loads(r.text)
            user_account = dict_str['account']
            user_address = user_account['address']
        except:
            get_acc_url = 'https://nft-api-staging.joyso.io/api/v1/accounts/'+user_id
            r = requests.get(url=get_acc_url,headers=headers)
            dict_str = json.loads(r.text)
            user_account = dict_str['account']
            user_address = user_account['address']
        # generate qr code from user id
        qr = qrcode.QRCode(
            version=1,
            box_size=10,
            border=5)
        qr.add_data(user_address)
        qr.make(fit=True)
        img_qr = qr.make_image(fill='black', back_color='white')
        filename = "/var/www/ArkCard-Linebot/ArkCard-web/qrcode/" + \
                   real_user_id + '.png'
        img_qr.save(filename)

        # add to db
        data = dict(userid=real_user_id, useraddress=user_address,is_active=1,created_at=dt.datetime.now(),updated_at=dt.datetime.now(),hashed_password='',email='',account='',is_superuser=0)
        table.insert(data)

        db.close()

        settings.line_bot_api.reply_message(
            event.reply_token,
            TextSendMessage(text='歡迎加入好友'))


# callback event
@router.post("/callback")
async def callback(request: fastapi.Request):
    signature = request.headers['X-Line-Signature']
    body = await request.body()
    settings.handler.handle(body.decode('utf-8'), signature)
    return 'OK'


# follow event
@settings.handler.add(FollowEvent)
def handle_follow(event):
    # get user id when follow
    check_account(event)

# message handler
@settings.handler.add(MessageEvent, message=TextMessage)
def message(event):
    if '我要發送' in event.message.text:
        button_template_message = ButtonsTemplate(
            title=' ',
            text='點擊並打開收藏的NFT，可以選擇想要發送的NFT給對方！',
            actions=[
                URITemplateAction(
                    label='打開發送頁',
                    uri='https://ark.cards/collect.html?'
                        + event.source.user_id)])
        settings.line_bot_api.reply_message(
            event.reply_token,
            TemplateSendMessage(
                alt_text="Receive",
                template=button_template_message))

    elif '我要接收' in event.message.text:

        check_account(event)
        button_template_message = ButtonsTemplate(
            title=' ',
            text='點擊並打開接收頁面，即可分享接收地址給對方！',
            actions=[
                URITemplateAction(
                    label='打開接收頁',
                    uri='https://ark.cards/qr-code.html?' +
                        event.source.user_id)])
        settings.line_bot_api.reply_message(
            event.reply_token,
            TemplateSendMessage(
                alt_text="Receive",
                template=button_template_message))

    elif 'NFT商店' in event.message.text:
        button_template_message = ButtonsTemplate(
            title=' ',
            text='點擊並打開NFT商品頁，就可以購買您所想要的NFT商品哦！',
            actions=[
                URITemplateAction(
                    label='打開NFT商品頁',
                    uri='https://ark.cards/shop.html?' +
                        event.source.user_id)])
        settings.line_bot_api.reply_message(
            event.reply_token,
            TemplateSendMessage(
                alt_text="Receive",
                template=button_template_message))

    elif 'NFT收藏' in event.message.text:
        button_template_message = ButtonsTemplate(
            title=' ',
            text='點擊並打開收藏的NFT，可以查看收到的NFT！',
            actions=[
                URITemplateAction(
                    label='打開收藏頁',
                    uri='https://ark.cards/collect.html?' +
                        event.source.user_id), ])
        settings.line_bot_api.reply_message(
            event.reply_token,
            TemplateSendMessage(
                alt_text="Receive",
                template=button_template_message))
    else:
        button_template_message = ButtonsTemplate(
            title=' ',
            text='更多的服務內容，歡迎請上我們的官網！',
            actions=[
                URITemplateAction(
                    label='ArkCard的官網',
                    uri='https://ark.cards')])
        settings.line_bot_api.reply_message(
            event.reply_token,
            TemplateSendMessage(
                alt_text="Receive",
                template=button_template_message))


@router.post("/push/")
def push_text(user, message):
    settings.line_bot_api.push_message(
        user, TextSendMessage(text=message)
    )


# nft collection api
@router.get("/collection/{userid}")
async def collection(userid, db: Session = Depends(deps.get_db)):
    # db connect
    
    url = 'accounts/' + str(userid)  + '/nft_balances'
    r = await request_get(baseUrl + url, headers)
    nft_all = {}
    outcome = r.json()['nft_balances']
    ii = 0
    for i in range(len(outcome)):
        nft_ = crud.nft.get_by_uid(db, uid=outcome[i]['uid'])
        if nft_:
            nft_all[ii] = jsonable_encoder(nft_)
            nft_all[ii]['amount'] = outcome[i]['amount']
            ii+=1

    return nft_all
    db = dataset.connect(
        'mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4'
    )
    table3 = db['nftdrops']
    table2 = db['nft']
    nftdrops = {}
    nft = {}
    nfts_all = {}
    i = 0
    j = 0
    if not table3.find_one(userid=userid) and not table2.find_one(userid=userid):
        db.close()
        return "error: user don't have any nft"

    else:
        results1 = table3.find(userid=userid)
        for item in results1:
            nft_id = item['nftid']
            nftdrops[i] = table2.find_one(id=nft_id)
            i += 1

        results2 = table2.find(userid=userid)
        for item in results2:
            nft[j] = item
            j += 1

        nfts_all[0] = nftdrops
        nfts_all[1] = nft
        return nfts_all
        db.close()


# receive handler
@router.get("/receive/{userid}")
def receive(userid):
    # db connect
    db = dataset.connect(
        'mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4'
    )
    table = db['users']

    table.find_one(userid=userid)
    if not table.find_one(userid=userid):
        db.close()
        return "ERROR: User Not Found"
    else:
        result = table.find_one(userid=userid)
        return {
            "userid": result['userid'], "useraddress": result['useraddress']
        }
    db.close()


# send handler
@router.post("/send")
async def send(
    userid: str,
    to: str,
    nftuid: int,
    amount: int,
    db_: Session = Depends(deps.get_db),
    ):
    try:
        to_userid = crud.user.get_by_address(db_, address=to)
    except:
        to_userid = "外部"
    db = dataset.connect(
        'mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4'
    )
    transaction_table = db['transaction']
    txid = str(uuid.uuid4())
    payload = {
        "txid": txid,
        # "contract": "0xe0d9102c88b09369df99b1c126fb2eebc13804f8",
        "contract": "0x8d5a7d8ca33fd9edca4b871cf5fb2a9cb5091505",
        "to": to,
        "uid": nftuid,
        "value": amount
    }
    url = "https://nft-api-staging.joyso.io/api/v1/accounts/Uba38e8903d243cd1bd15d5c27cc6653e/erc1155/safe_transfer_to"
    # r = requests.post(baseUrl + "accounts/" + userid+ "/erc1155/safe_transfer_to" , headers=headers, data=payload)
    r = requests.post(baseUrl + "accounts/" + userid+ "/erc1155/transfer_by_admin" , headers=headers, data=payload)
    # r = requests.post(url , headers=headers, data=payload)
    if r.status_code == 200:
        title = crud.nft.get_by_uid(db_, uid=nftuid).__dict__['title']
        message = "您的NFT : " + title + ", 已劃轉！"
        push_text(userid, message)
        transaction_table.insert({'txid':txid,'tfrom':userid,'to':to_userid,'nft':nftuid,'transaction_at':datetime.now()})
        from_name = settings.line_bot_api.get_profile(userid).as_json_dict()['displayName']
        try:
            to_name = settings.line_bot_api.get_profile(to_userid).as_json_dict()['displayName']
        except:
            to_name = "外部"
        fr = "您給"+ to_name +"的NFT(" + title + "), 已發送成功！"
        to_message = from_name +"給您的NFT("+title+"), 已收到！"
        push_text(userid, fr)
        try:
            push_text(to_userid, to_message)
        except:
            pass
    else:
        # push訊息
        message = "交易失敗！如果有疑問，請洽網站的服務信箱！"
        push_text(userid, message)
        return {'msg': r.content}
    return {'msg': 'OK'}


# shop handler
@router.get("/shop/{userid}")
def shop(userid):
    # db connect
    db = dataset.connect(
        'mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4'
    )

    sql = 'SELECT title, id, imgurl, userid FROM arkcard.nft  ' \
          'GROUP BY uid'
    result = db.query(sql)
    rows = {}
    i = 0
    for row in result:
        rows[i] = row
        i += 1
    return rows
    db.close()


@router.post("/buy")
async def buy(userModel: line.BuyNft):
    # db connect
    db = dataset.connect(
        'mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4'
    )
    table2 = db['nft']

    # input
    nftid = userModel.nftid
    userid = userModel.userid

    if not table2.find_one(id=nftid):
        db.close()
        # push訊息
        message = "購買失敗！如果有疑問，請洽網站的服務信箱！"
        push_text(userid, message)
        return "該NFT商品不存在！如果有疑問，請洽網站的服務信箱！"
    else:
        user_obj = table2.find_one(id=nftid)
        user_obj['userid'] = userid
        table2.update(dict(user_obj), ['id'])

        # push訊息
        result3 = table2.find_one(id=nftid)
        title = result3['title']
        message = "您的NFT : " + title + ", 已購買成功！"
        push_text(userid, message)

        db.close()
    return "您已購買成功！"


@router.post("/event")
async def nftdrops(userModel: line.NftDrops):
    # db connect
    db = dataset.connect(
        'mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4'
    )
    table3 = db['nftdrops']

    # input對應
    eventid = '1'
    nftid = '1001'
    nftid2 = '1002'
    userid = userModel.userid
    email = userModel.email
    now = dt.datetime.now()

    # 如果userid不在db, 寫入到一個空值nft
    if not table3.find_one(userid=userid):
        # 新增資料
        table3.insert(
            dict(
                eventid=eventid, nftid=nftid,
                userid=userid, email=email, time=now
            ))
        table3.insert(
            dict(
                eventid=eventid, nftid=nftid2,
                userid=userid, email=email, time=now
            ))
        db.close()
        # push訊息
        message = "已為您登記活動！"
        push_text(userid, message)
        return "新增成功"
    # 如果userid存在，回傳通知
    else:
        db.close()
        # push訊息
        message = "您已登記過活動了！"
        push_text(userid, message)
        return "已有資料"


@router.get("/transactions")
def transactions(
    skip: int = 0,
    limit: int = 100,
    current_user: models.users = Depends(deps.get_current_active_superuser),
    ):
    # db connect
    db = dataset.connect(
        'mysql://choozmo:pAssw0rd@db.ptt.cx:3306/arkcard?charset=utf8mb4'
    )
    sql = 'SELECT * FROM transaction ORDER BY id Desc ' \
          'limit '+str(skip)+', '+str(limit)+''
    nft_table = db['nft']
    result = db.query(sql)
    rows = []
    for row in result:
        nft_item = nft_table.find_one(uid=row['nft'])
        try:
            row['nft'] = nft_item['title']
        except:
            pass
        rows.append(row)
    db.close()

    return rows