2025/10/23-やったことリスト

### dataserver to frontend
#### note in the frontend code
```
// dataserver -> frontend
// get an interrupt
// 
// {
//     "componentName"  : "Selector",
//     "command"        : "update",
//     "UUID"           : "UUID string",
//     "data"           : { }
// }
```
#### server interrupt reqest(JSON)
```json
{
    "componentName"  : "componentName",
    "interrupt"      : "update",
    "UUID"           : "UUID string",
    "data"           : { }
}
```

#### frontend response(JSON)
```json
{
    "status"        : "ok",
    "UUID"          : "UUID string",
    "interrupt"     : "update",
    "componentName" : "componentName",
    "errorMessage"  : "nothing",
    "data"          : { }    
}
```

# TODO: test and use this
# TODO: write the document
# arg:
#   websocket       : the connection to the frontend via websocket
#   interrupt       : content of the interrupt
# return value
#   OK      : None
#   Error   : Error state does not exist.
async def sendInterrupt(websocket,interrupt:dict):
#   "componentName"  : "componentName",
#   "interrupt"      : "update",
#   "UUID"           : "UUID string",
#   "data"           : { }
    
    if(
        "componentName" in interrupt.keys() and
        "interrupt"     in interrupt.keys() and
        "UUID"          in interrupt.keys() and
        "data"          in interrupt.keys()
        ):
        await websocket.send(json.dumps(interrupt))
    else:
        print("sendInterrupt helper ERROR: Mandatory keys are missing")
        print("componentName,interrupt,UUID,data")
        print(interrupt)

### dataserver to frontend
#### server interrupt reqest(JSON)
```json
{
    "event" : "EventName",
    "UUID"  : "UUID string",
    "data"  : { }
}
```
- event
 Interrupt event name. Any compornent are allowed to catch the interrupt.
- UUID  
 Identifier of the interrupt request
- data  
 Any data

# TODO: test and use this
# TODO: write the document
# arg:
#   websocket       : the connection to the frontend via websocket
#   interrupt       : content of the interrupt
# return value
#   OK      : None
#   Error   : Error state does not exist.
async def sendInterrupt(websocket,interrupt:dict):
#   "componentName"  : "componentName",
#   "interrupt"      : "update",
#   "UUID"           : "UUID string",
#   "data"           : { }
    
    if(
        "event"         in interrupt.keys() and
        "UUID"          in interrupt.keys() and
        "data"          in interrupt.keys()
        ):
        await websocket.send(json.dumps(interrupt))
    else:
        print("sendInterrupt helper ERROR: Mandatory keys are missing")
        print("componentName,interrupt,UUID,data")
        print(interrupt)

# newInfo
## Role
 Notifiy the frontend notebooks or pages are created or deleted.
 
## interrupt data 
```json
{
    "event" : "newInfo",
    "UUID"  : "UUID string",
    "data"  : { }
}
```

## related commands
- [createNotebook](../basicCommand/createNotebook.md)
- [deleteNotebook](../basicCommand/deleteNotebook.md)
- [createPage](../basicCommand/createPage.md)
- [deletePage](../basicCommand/deletePage.md)

...
// 問題の実装
// TODO: Fix fllikering
// TODO: Reconnection Loop singleton, there are bug Reconnection Loop are appear mutiple times.
export function useDatabaseEffects() {
  const serverIP = useDatabaseStore((s) => s.serverIP);
  const setWebsocket = useDatabaseStore.setState;
  const getWebsocket = useDatabaseStore((s) => s.getWebsocket)
  // const init = useRef(true)

  useEffect(() => {
    if (!serverIP) return;

    const reconnectLoop = () => { 
      console.log("reconnect observer")
      const websocket = getWebsocket()
      if(websocket != null){
        // when there is no problem
        if(websocket.readyState == WebSocket.OPEN){
          // observe the connection
          setTimeout(() => { 
            reconnectLoop()
          },interval * 1000)
          return
        }
      }

      // when try to reconnect the dataserver 
      setTimeout(() => { 
        const websocket = new WebSocket(serverIP);
        // websocket.addEventListener("error",reconnectLoop)
        // websocket.addEventListener("open",reconnectLoop)
        setWebsocket({ websocket: websocket });
      },interval / 2 * 1000)
      setTimeout(() => { 
        reconnectLoop()
      },interval * 1000)
    } 
    const websocket = new WebSocket(serverIP);
    websocket.addEventListener("error",reconnectLoop)
    websocket.addEventListener("open",reconnectLoop)
    websocket.addEventListener("close",reconnectLoop)
    setWebsocket({ websocket: websocket });

    return () => {
      websocket.close();
    };
  }, [serverIP, setWebsocket]);
}

# main server scirpt
# serve dataserver function with websocket. 

import asyncio
import multiprocessing
# from modules.reqestParser import parser
from websockets.asyncio.server import serve
from helper import loadSettings
from helper.netwrok import receiveLoop 
import tasks
import controller

# 以下の mainLoop 関数では、サーバが何かしらの理由で終了されても、ちゃんと WebSocket を閉じてくれない。
async def mainLoop(websocket):
    await receiveLoop(websocket,controller.controller)    

async def dataserver():
    async with serve(mainLoop, loadSettings.settings["ip"], loadSettings.settings["port"]) as server:
        await server.serve_forever()

def dataserverThread():
    asyncio.run(dataserver())

def serviceThread():
    asyncio.run(tasks.taskController(loadSettings.settings["taskInterval"]))

if __name__ == "__main__":
    # 以下のコードでは、単に各プロセスをスタートさせて並列に動作させるだけになっており、
    # それぞれのプロセスが終了するのを待たないため、親プロセスにおいて、keyboardInterruptを全くつかめない。
    multiprocessing.Process(target=dataserverThread).start()
    multiprocessing.Process(target=serviceThread).start()

# main server scirpt
# serve dataserver function with websocket. 

import asyncio
import multiprocessing
# from modules.reqestParser import parser
from websockets.asyncio.server import serve
from helper import loadSettings
from helper.netwrok import receiveLoop 
import tasks
import controller
import sys

# 以下のコードでは、なるべく終了時に Websocket を閉じるようにした。
# ただし、except asyncio.CancelledError: はたぶん機能してなさそうなので要検証。
# dataserver() ですでに例外をつかんでしまっているからなのかは不明。
async def mainLoop(websocket):
    try:
        await receiveLoop(websocket,controller.controller)    
    except asyncio.CancelledError:
        print("The dataserver mainLoop is stopped.")
    finally:
        print("The dataserver mainLoop is closed.")
        await websocket.close()

async def dataserver():
    async with serve(mainLoop, loadSettings.settings["ip"], loadSettings.settings["port"]) as server:
        try:
            await server.serve_forever()
        except asyncio.CancelledError:
            print("The dataserver is stopped.")

def dataserverThread():
    asyncio.run(dataserver())

def serviceThread():
    try:
        asyncio.run(tasks.taskController(loadSettings.settings["taskInterval"]))
    except KeyboardInterrupt:
        print("The task controller is stopped.")

if __name__ == "__main__":
    print("This dataserver is started.")
    dataserverProcess = multiprocessing.Process(target=dataserverThread)
    serviceProcess = multiprocessing.Process(target=serviceThread)
    dataserverProcess.start()
    serviceProcess.start()

    # 例外をつかむために、各プロセスの終了を親プロセスで待つようにした。
    try:
        dataserverProcess.join()
        serviceProcess.join()
    except KeyboardInterrupt:
        print("This server will be stopped.")
        dataserverProcess.terminate()
        serviceProcess.terminate()
        print("All processes are terminated.")
        sys.exit()

    useEffect(() => {
        const showAndHide = (event:MouseEvent) => {
            event.preventDefault() // これだとすべてのマウス入力で、preventDefault してしまう。
            if(event.button == 2){
                position.current.x = event.clientX
                position.current.y = event.clientY
                setVisible(true)
            }else{
                setVisible(false)
            }
        }
        addEventListener("mousedown",showAndHide)
        oncontextmenu = () => {return false}
        
        return () => {
            removeEventListener("mousedown",showAndHide)
        }
    },[])

    useEffect(() => {
        const showAndHide = (event:MouseEvent) => {
            if(event.button == 2){
                event.preventDefault() // 右クリックのだけ、preventDefaultするようにすることで、通常の左クリックの操作を妨げないようにした。
                position.current.x = event.clientX
                position.current.y = event.clientY
                setVisible(true)
            }else{
                setVisible(false)
            }
        }
        addEventListener("mousedown",showAndHide)
        oncontextmenu = () => {return false}
        
        return () => {
            removeEventListener("mousedown",showAndHide)
        }
    },[])

    function addItemToTheStore(){
        if(selectedType.current == null){
            showMessageBox({
                title: "Add Item",
                message: "Please select page type.",
                UUID: messageBoxUUID.current,
                type: "error"
            })
            return
        }

        // create an new item
        const targetElement = getElement(selectedType.current)       

        if(targetElement == null){
            showMessageBox({
                title: "Add Item",
                message: "Unable to find the page type.",
                UUID: messageBoxUUID.current,
                type: "error"
            })   
            return
        }

        // これでは、ディープコピーをしていないため、targetElement.defaultDataの参照をあちこちにばらまく結果となり、
        // アイテムを管理しているストアの中に、defaultData が登録されても、その登録された defaultData や targetElement.defaultData の ID が、
        // 全部 defaultData.ID = genUUID() で置き換わってしまうため、一つの独立したアイテムのデータを作るということができていなかった。
        const defaultData:AnItem = targetElement.defaultData
        defaultData.ID = genUUID()
        console.log(defaultData)

        // append the new item to the item store
        addItem(defaultData)

        const window = getWindow(OverlayWindowArg)
        if(window) closeWindow(window)
    }

    function addItemToTheStore(){
        if(selectedType.current == null){
            showMessageBox({
                title: "Add Item",
                message: "Please select page type.",
                UUID: messageBoxUUID.current,
                type: "error"
            })
            return
        }

        // create an new item
        const targetElement = getElement(selectedType.current)       

        if(targetElement == null){
            showMessageBox({
                title: "Add Item",
                message: "Unable to find the page type.",
                UUID: messageBoxUUID.current,
                type: "error"
            })   
            return
        }

        // 以下では、targetElement.defaultData をディープコピーしてから、新しいアイテムのデータとして利用し、UUIDなどを設定しているため、
        // targetElement.defaultData の参照とは、新しいアイテムのデータは切り離され問題が解消されている。
        // deep copy is required
        // https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone
        const defaultData:AnItem = structuredClone(targetElement.defaultData)
        defaultData.ID = genUUID()
        console.log(defaultData)

        // append the new item to the item store
        addItem(defaultData)

        const window = getWindow(OverlayWindowArg)
        if(window) closeWindow(window)
    }

export const defaultItemData:AnItem = { 
    // need to be overwrite 
    data    : "",
    ID      : "",
    type    : "",

    // optional to overwrite
    position: {
        x: 100,
        y: 100,
        z: 1
    },
    size:{
        height: 100,
        width: 100
    },
    color:{
        a: 1,
        b: 100,
        g: 100,
        r: 100
    },
}

// テンプレート作成の部分 -------
// テンプレート作成の部分 -------
const defaultItemDataForTextView:AnItem = defaultItemData
defaultItemDataForTextView.data = "Blank text item"
defaultItemDataForTextView.type = "text"
// テンプレート作成の部分 -------
// テンプレート作成の部分 -------

const element:FreePageElement = {
    name        : "text",
    element     : TextView,
    defaultData : defaultItemDataForTextView,
}

        const defaultData:AnItem = structuredClone(targetElement.defaultData)
        defaultData.ID = genUUID()
        console.log(defaultData)

        // append the new item to the item store
        addItem(defaultData)

from newInfo    import newInfo
from updatePage import updatePage 

intrruptList = {
    "newInfo"       : newInfo,
    "updatePage"    : updatePage,
}

# return 
#  False -> OK
#  True  -> Something went worng
def callInterrupt(websocket,intrruptName:str,data:dict):
    for AnIntrrupt in intrruptList.keys():
        if(AnIntrrupt == intrruptName):
            # call intrrupt
            return intrruptList[AnIntrrupt](websocket,data)        
    
    print("callInterrupt ERROR: The intrrupt does not exist.")
    return True

from ..helper.common import sendInterrupt
import uuid, copy, json

actionList = [
    "createNotebook",
    "deleteNotebook",
    "createPage",
    "deletePage",
]

def newInfo(websocket,data:dict):
    if(not "action" in data.keys()):
        print("newInfo interrupt ERROR: The mandatory key 'action' does not exist.")
        return True

    find = False
    for action in actionList:
        if(action == data["action"]):
            find = True
            break

    if(not find):
        print("newInfo interrupt ERROR: The action is invalid.")
        print(data)
        return True

    response = {
        "event" : "newInfo",
        "UUID"  : "UUID string",
        "data"  : data
    }

    return sendInterrupt(websocket,response)

# arg:
#   websocket       : the connection to the frontend via websocket
#   interrupt       : content of the interrupt
# return value
#   OK      : False will be returned. It mean there are no problems
#   Error   : True will be returned. It mean there are something missing in dict keys of "interrupt" arg
async def sendInterrupt(websocket,interrupt:dict):
#   "evnet" : "eventName",
#   "UUID"  : "UUID string",
#   "data"  : { }
    
    if(
        "event"         in interrupt.keys() and
        "UUID"          in interrupt.keys() and
        "data"          in interrupt.keys()
        ):
        responseString = json.dumps(interrupt)
        print(">>> " + responseString)

        # これでは、コマンドを実行したフロントエンド以外には何も割り込みに通知がいかない
        await websocket.send(responseString)
        return False
    
    else:
        print("sendInterrupt helper ERROR: Mandatory keys are missing")
        print("componentName,interrupt,UUID,data")
        print(interrupt)
        return True

# arg:
#   websocket       : the connection to the frontend via websocket
#   interrupt       : content of the interrupt
# return value
#   OK      : False will be returned. It mean there are no problems
#   Error   : True will be returned. It mean there are something missing in dict keys of "interrupt" arg
async def sendInterrupt(websocket,interrupt:dict):
#   "evnet" : "eventName",
#   "UUID"  : "UUID string",
#   "data"  : { }
    if(
        "event"         in interrupt.keys() and
        "UUID"          in interrupt.keys() and
        "data"          in interrupt.keys()
        ):
        responseString = json.dumps(interrupt)
        print(">>> " + responseString)

        # 割り込みをすべてのフロントエンドに送信する実装
        for Awebsocket in websockets:
            try:
                await Awebsocket.send(responseString)            
            except Exception as e:
                print("sendInterrupt helper ERROR: Ignore the disconnected websocket.")
                print(e)
        # 割り込みをすべてのフロントエンドに送信する実装 終わり
        
        print(websockets)
        return False
    
    else:
        print("sendInterrupt helper ERROR: Mandatory keys are missing")
        print("componentName,interrupt,UUID,data")
        print(interrupt)
        return True