domain bug fix

2023-11-04 22:11:32 +09:00
parent a782e92bd6 57a4823f61
commit 5a875e6853
15 changed files with 699 additions and 292 deletions
--- a/backend/app/api/api_v1/routers/auth.py
+++ b/backend/app/api/api_v1/routers/auth.py
@@ -29,18 +29,19 @@ async def login(
    else:
        permissions = "user"
    access_token = security.create_access_token(
-        data={"sub": user.email, "permissions": permissions},
+        data={"sub": user.id, "permissions": permissions},
        expires_delta=access_token_expires,
    )

-    return {"access_token": access_token, "token_type": "bearer"}
+    return {"access_token": access_token, "token_type": "bearer","user_name":user.first_name + " " + user.last_name}


@r.post("/signup")
 async def signup(
+    firstname:str, lastname:str,
    db=Depends(get_db), form_data: OAuth2PasswordRequestForm = Depends()
 ):
-    user = sign_up_new_user(db, form_data.username, form_data.password)
+    user = sign_up_new_user(db, form_data.username, form_data.password,firstname,lastname)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
@@ -56,8 +57,8 @@ async def signup(
    else:
        permissions = "user"
    access_token = security.create_access_token(
-        data={"sub": user.email, "permissions": permissions},
+        data={"sub": user.id, "permissions": permissions},
        expires_delta=access_token_expires,
    )

-    return {"access_token": access_token, "token_type": "bearer"}
+    return {"access_token": access_token, "token_type": "bearer","user_name":user.first_name + " " + user.last_name}
--- a/backend/app/api/api_v1/routers/kintone.py
+++ b/backend/app/api/api_v1/routers/kintone.py
@@ -5,21 +5,29 @@ import pandas as pd
 import json
 import httpx
 import deepdiff
-import app.core.config as c
+import app.core.config as config
 import os
-import sys
 from app.db.session import SessionLocal
-from app.db.crud import get_flows_by_app
+from app.db.crud import get_flows,get_activedomain
+from app.core.auth import get_current_active_user,get_current_user

 kinton_router = r = APIRouter()

+def getkintoneenv(user = Depends(get_current_user)):
+    db = SessionLocal()
+    domain = get_activedomain(db, user.id)
+    db.close()
+    kintoneevn = config.KINTONE_ENV(domain)
+    return kintoneevn
+    
+
 def getfieldsfromexcel(df):
    appname = df.iloc[0,2]
    col=[]
    for row in range(5,len(df)):
        if pd.isna(df.iloc[row,1]):
            break
-        if not df.iloc[row,3] in c.KINTONE_FIELD_TYPE:
+        if not df.iloc[row,3] in config.KINTONE_FIELD_TYPE:
            continue
        p=[] 
        for column in range(1,7):
@@ -42,10 +50,10 @@ def getsettingfromexcel(df):
    des = df.iloc[2,2]
    return {"name":appname,"description":des}

-def getsettingfromkintone(app:str):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+def getsettingfromkintone(app:str,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
    params = {"app":app}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/app/settings.json"
+    url = f"{c.BASE_URL}{config.API_V1_STR}/app/settings.json"
    r = httpx.get(url,headers=headers,params=params)
    return r.json()

@@ -57,24 +65,24 @@ def analysesettings(excel,kintone):
            updatesettings[key] = excel[key]
    return updatesettings

-def createkintoneapp(name:str):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+def createkintoneapp(name:str,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
    data = {"name":name}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app.json"
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app.json"
    r = httpx.post(url,headers=headers,data=json.dumps(data))
    return r.json()

-def updateappsettingstokintone(app:str,updates:dict):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/settings.json"
+def updateappsettingstokintone(app:str,updates:dict,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/settings.json"
    data = {"app":app}
    data.update(updates)
    r = httpx.put(url,headers=headers,data=json.dumps(data))
    return r.json()

-def addfieldstokintone(app:str,fields:dict,revision:str = None):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/form/fields.json"
+def addfieldstokintone(app:str,fields:dict,c:config.KINTONE_ENV,revision:str = None):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/form/fields.json"
    if revision != None:
        data = {"app":app,"revision":revision,"properties":fields}
    else:
@@ -82,32 +90,32 @@ def addfieldstokintone(app:str,fields:dict,revision:str = None):
    r = httpx.post(url,headers=headers,data=json.dumps(data))
    return r.json()

-def updatefieldstokintone(app:str,revision:str,fields:dict):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/form/fields.json"
+def updatefieldstokintone(app:str,revision:str,fields:dict,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/form/fields.json"
    data = {"app":app,"properties":fields}
    r = httpx.put(url,headers=headers,data=json.dumps(data))
    return r.json()

-def deletefieldsfromkintone(app:str,revision:str,fields:dict):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/form/fields.json"
+def deletefieldsfromkintone(app:str,revision:str,fields:dict,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/form/fields.json"
    params = {"app":app,"revision":revision,"fields":fields}
    #r = httpx.delete(url,headers=headers,content=json.dumps(params))
    r = httpx.request(method="DELETE",url=url,headers=headers,content=json.dumps(params))
    return r.json()

-def deoployappfromkintone(app:str,revision:str):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/deploy.json"
+def deoployappfromkintone(app:str,revision:str,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/deploy.json"
    data = {"apps":[{"app":app,"revision":revision}],"revert": False}
    r = httpx.post(url,headers=headers,data=json.dumps(data))
    return r.json
    
-def getfieldsfromkintone(app):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+def getfieldsfromkintone(app:str,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
    params = {"app":app}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/app/form/fields.json"
+    url = f"{c.BASE_URL}{config.API_V1_STR}/app/form/fields.json"
    r = httpx.get(url,headers=headers,params=params)
    return r.json()

@@ -131,10 +139,10 @@ def analysefields(excel,kintone):

    return {"update":updatefields,"add":addfields,"del":delfields}

-def getprocessfromkintone(app:str):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+def getprocessfromkintone(app:str,c:config.KINTONE_ENV):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
    params = {"app":app}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/app/status.json"
+    url = f"{c.BASE_URL}{config.API_V1_STR}/app/status.json"
    r = httpx.get(url,headers=headers,params=params)
    return r.json()

@@ -198,36 +206,36 @@ def analysprocess(excel,kintone):
    #         return True
    return diff

-def updateprocesstokintone(app:str,process:dict):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/status.json"
+def updateprocesstokintone(app:str,process:dict,c:config.KINTONE_ENV=Depends(getkintoneenv)):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/status.json"
    data = {"app":app,"enable":True}
    data.update(process)
    r = httpx.put(url,headers=headers,data=json.dumps(data))
    return r.json()

-def getkintoneusers():
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+def getkintoneusers(c:config.KINTONE_ENV=Depends(getkintoneenv)):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
    url = f"{c.BASE_URL}/v1/users.json"
    r = httpx.get(url,headers=headers)
    return r.json()

-def getkintoneorgs():
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+def getkintoneorgs(c:config.KINTONE_ENV=Depends(getkintoneenv)):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
    params = {"code":c.KINTONE_USER}
    url = f"{c.BASE_URL}/v1/user/organizations.json"
    r = httpx.get(url,headers=headers,params=params)
    return r.json()

-def uploadkintonefiles(file):
+def uploadkintonefiles(file,c:config.KINTONE_ENV=Depends(getkintoneenv)):
    upload_files = {'file': open(file,'rb')}
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
    data ={'name':'file','filename':os.path.basename(file)}
    url = f"{c.BASE_URL}/k/v1/file.json"
    r = httpx.post(url,headers=headers,data=data,files=upload_files)
    return r.json()

-def updateappjscss(app,uploads):
+def updateappjscss(app,uploads,c:config.KINTONE_ENV=Depends(getkintoneenv)):
    dsjs = []
    dscss = []
    for upload in uploads:
@@ -239,25 +247,27 @@ def updateappjscss(app,uploads):
    ds ={'js':dsjs,'css':dscss}
    mb ={'js':[],'css':[]}
    data = {'app':app,'scope':'ALL','desktop':ds,'mobile':mb}
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/customize.json"
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/customize.json"
    print(data)
    r = httpx.put(url,headers=headers,data=json.dumps(data))
    return r.json()

 def createappjs(app):
    db = SessionLocal()
-    flows = get_flows_by_app(db,app)
+    flows = get_flows(db,app)
    db.close()
    content={}
    for flow in flows:
        content[flow.eventid] = {'flowid':flow.flowid,'name':flow.name,'content':flow.content}
-    js = 'const alcflow=' + json.dumps(content)
-    fpath = os.path.join("Temp",f"alc_setting_{app}.js")
-    with open(fpath,'w') as file:
-        file.write(js)
+    js = 'const flow=' + json.dumps(content)
+    fpath =  '{}\\alc_setting_{}.js'.format('Temp',app)
+    file = open(fpath,'w',encoding="utf-8")
+    file.write(js)
+    file.close()
    return fpath

+
@r.post("/test",)
 async def test(file:UploadFile= File(...),app:str=None):
    if file.filename.endswith('.xlsx'):
@@ -283,14 +293,14 @@ async def test(file:UploadFile= File(...),app:str=None):


@r.post("/download",)
-async def download(key):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+async def download(key,c:config.KINTONE_ENV=Depends(getkintoneenv)):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
    params = {"fileKey":key}
    url = f"{c.BASE_URL}/k/v1/file.json"
    r = httpx.get(url,headers=headers,params=params)
    return r.json()

-@r.post("/upload",)
+@r.post("/upload")
 async def upload(files:t.List[UploadFile] = File(...)):
    dataframes = []
    for file in files:
@@ -308,7 +318,7 @@ async def upload(files:t.List[UploadFile] = File(...)):
    return {"files": [file.filename for file in files]}  

@r.post("/updatejscss")
-async def jscss(app:str,files:t.List[UploadFile] = File(...)):
+async def jscss(app:str,files:t.List[UploadFile] = File(...),env = Depends(getkintoneenv)):
    try:
        jscs=[]
        for file in files:
@@ -318,61 +328,49 @@ async def jscss(app:str,files:t.List[UploadFile] = File(...)):
            fout = open(fpath,'wb')
            fout.write(fbytes)
            fout.close()
-            upload = uploadkintonefiles(fpath)
+            upload = uploadkintonefiles(fpath,env)
            if upload.get('fileKey') != None:
                jscs.append({ file.filename:upload['fileKey']})
        appjscs = updateappjscss(app,jscs)
        if appjscs.get("revision") != None:
-           deoployappfromkintone(app,appjscs["revision"])
+           deoployappfromkintone(app,appjscs["revision"],env)
           return appjscs
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Error occurred while update file {file.filename}: {str(e)}")
     

-@r.get("/allapps",)
-async def allapps():
-    try:
-        headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
-        url = f"{c.BASE_URL}{c.API_V1_STR}/apps.json"
-        r = httpx.get(url,headers=headers,timeout=httpx.Timeout(10))
-        return r.json()
-    except Exception as e:
-        print(f"異常発生しました。{type(e).__name__},{e}")
-        
-@r.get("/app")
-async def app(app:str):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/app.json"
-    params ={"id":app}
-    r = httpx.get(url,headers=headers,params=params)
+@r.get("/allapps")
+async def allapps(c:config.KINTONE_ENV=Depends(getkintoneenv)):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/apps.json"
+    r = httpx.get(url,headers=headers)
    return r.json()

-
@r.get("/appfields")
-async def appfields(app:str):
-    return getfieldsfromkintone(app)
+async def appfields(app:str,env = Depends(getkintoneenv)):
+    return getfieldsfromkintone(app,env)

@r.get("/appprocess")
-async def appprocess(app:str):
-    return getprocessfromkintone(app)
+async def appprocess(app:str,env = Depends(getkintoneenv)):
+    return getprocessfromkintone(app,env)

@r.get("/alljscss")
-async def alljscs(app:str):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/app/customize.json"
+async def alljscs(app:str,c:config.KINTONE_ENV=Depends(getkintoneenv)):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE}
+    url = f"{c.BASE_URL}{config.API_V1_STR}/app/customize.json"
    params = {"app":app}
    r = httpx.get(url,headers=headers,params=params)
    return r.json()

@r.post("/createapp",)
-async def createapp(name:str):
-    headers={c.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
+async def createapp(name:str,c:config.KINTONE_ENV=Depends(getkintoneenv)):
+    headers={config.API_V1_AUTH_KEY:c.API_V1_AUTH_VALUE,"Content-Type": "application/json"}
    data = {"name":name}
-    url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app.json"
+    url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app.json"
    r = httpx.post(url,headers=headers,data=json.dumps(data))
    result = r.json()
    if result.get("app") != None:
-        url = f"{c.BASE_URL}{c.API_V1_STR}/preview/app/deploy.json"
+        url = f"{c.BASE_URL}{config.API_V1_STR}/preview/app/deploy.json"
        data = {"apps":[result],"revert": False}
        r = httpx.post(url,headers=headers,data=json.dumps(data))
    return r.json
@@ -380,7 +378,7 @@ async def createapp(name:str):
 property=["label","code","type","required","defaultValue","options"]

@r.post("/createappfromexcel",)
-async def createappfromexcel(files:t.List[UploadFile] = File(...)):
+async def createappfromexcel(files:t.List[UploadFile] = File(...),env = Depends(getkintoneenv)):
    for file in files:
        if file.filename.endswith('.xlsx'):
            try:
@@ -394,18 +392,18 @@ async def createappfromexcel(files:t.List[UploadFile] = File(...)):
                users = getkintoneusers()
                orgs =  getkintoneorgs()
                processes = getprocessfromexcel(df,users["users"], orgs["organizationTitles"])
-                app = createkintoneapp(appname)
+                app = createkintoneapp(appname,env)
                if app.get("app") != None:
                    result["app"] = app["app"]
-                    app = updateappsettingstokintone(result["app"],{"description":desc})
+                    app = updateappsettingstokintone(result["app"],{"description":desc},env)
                if app.get("revision") != None:
                    result["revision"] = app["revision"]
-                    app = addfieldstokintone(result["app"],fields)
+                    app = addfieldstokintone(result["app"],env,fields)
                if len(processes)> 0:
                    app = updateprocesstokintone(result["app"],processes)
                if app.get("revision") != None:
                    result["revision"] = app["revision"]
-                    deoployappfromkintone(result["app"],result["revision"])
+                    deoployappfromkintone(result["app"],result["revision"],env)
            except Exception as e:
                raise HTTPException(status_code=400, detail=f"Error occurred while parsing file {file.filename}: {str(e)}")
        else:
@@ -414,42 +412,42 @@ async def createappfromexcel(files:t.List[UploadFile] = File(...)):
    return result


-@r.post("/updateappfromexcel",)
-async def updateappfromexcel(app:str,files:t.List[UploadFile] = File(...)):
+@r.post("/updateappfromexcel")
+async def updateappfromexcel(app:str,files:t.List[UploadFile] = File(...),env = Depends(getkintoneenv)):
    for file in files:
        if file.filename.endswith('.xlsx'):
            try:
                content = await file.read()
                df = pd.read_excel(BytesIO(content))
                excel = getsettingfromexcel(df)
-                kintone= getsettingfromkintone(app)
+                kintone= getsettingfromkintone(app,env)
                settings = analysesettings(excel,kintone)
                excel = getfieldsfromexcel(df)
-                kintone = getfieldsfromkintone(app)
+                kintone = getfieldsfromkintone(app,env)
                users = getkintoneusers()
                orgs =  getkintoneorgs()
                exp = getprocessfromexcel(df,users["users"], orgs["organizationTitles"])
                #exp = getprocessfromexcel(df)
-                kinp = getprocessfromkintone(app)
+                kinp = getprocessfromkintone(app,env)
                process = analysprocess(exp,kinp)
                revision = kintone["revision"]
                fields = analysefields(excel,kintone["properties"])
                result = {"app":app,"revision":revision,"msg":"No Update"}
                deploy = False
                if len(fields["update"]) > 0:
-                    result = updatefieldstokintone(app,revision,fields["update"])
+                    result = updatefieldstokintone(app,revision,fields["update"],env)
                    revision = result["revision"]
                    deploy = True
                if len(fields["add"]) > 0:
-                    result = addfieldstokintone(app,fields["add"],revision)
+                    result = addfieldstokintone(app,fields["add"],env,revision)
                    revision = result["revision"]
                    deploy = True
                if len(fields["del"]) > 0:
-                    result = deletefieldsfromkintone(app,revision,fields["del"])
+                    result = deletefieldsfromkintone(app,revision,fields["del"],env)
                    revision = result["revision"]
                    deploy = True
                if len(settings) > 0:
-                    result = updateappsettingstokintone(app,settings)
+                    result = updateappsettingstokintone(app,settings,env)
                    revision = result["revision"]
                    deploy = True
                if len(process)>0:
@@ -457,7 +455,7 @@ async def updateappfromexcel(app:str,files:t.List[UploadFile] = File(...)):
                    revision = result["revision"]
                    deploy = True
                if deploy:
-                    result = deoployappfromkintone(app,revision)
+                    result = deoployappfromkintone(app,revision,env)
            except Exception as e:
                raise HTTPException(status_code=400, detail=f"Error occurred while parsing file {file.filename}: {str(e)}")
        else:
@@ -466,11 +464,11 @@ async def updateappfromexcel(app:str,files:t.List[UploadFile] = File(...)):
    return result

@r.post("/updateprocessfromexcel",)
-async def updateprocessfromexcel(app:str):
+async def updateprocessfromexcel(app:str,env = Depends(getkintoneenv)):
   
    try:
        excel = getprocessfromexcel()
-        kintone = getprocessfromkintone(app)
+        kintone = getprocessfromkintone(app,env)
        revision = kintone["revision"]
        #fields = analysefields(excel,kintone["properties"])
        result = {"app":app,"revision":revision,"msg":"No Update"}
@@ -495,7 +493,7 @@ async def updateprocessfromexcel(app:str):
        revision = result["revision"]
        deploy = True
        if deploy:
-            result = deoployappfromkintone(app,revision)
+            result = deoployappfromkintone(app,revision,env)
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Error occurred : {str(e)}")
       
@@ -503,22 +501,20 @@ async def updateprocessfromexcel(app:str):


@r.post("/createjstokintone",)
-async def createjstokintone(app:str):
+async def createjstokintone(app:str,env = Depends(getkintoneenv)):
   
    try:
        jscs=[]
        files=[]
        files.append(createappjs(app))
-        base_dir = os.path.abspath('Temp')
-        runtimeJs = os.path.join(base_dir, 'alc_runtime.js')
-        files.append(runtimeJs)
+        files.append('Temp\\alc_runtime.js')
        for file in files:
-            upload = uploadkintonefiles(file)
+            upload = uploadkintonefiles(file,env)
            if upload.get('fileKey') != None:
                jscs.append({ app + '.js':upload['fileKey']})
        appjscs = updateappjscss(app,jscs)
        if appjscs.get("revision") != None:
-           deoployappfromkintone(app,appjscs["revision"])
+           deoployappfromkintone(app,appjscs["revision"],env)
           return appjscs
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Error occurred : {str(e)}")
--- a/backend/app/api/api_v1/routers/platform.py
+++ b/backend/app/api/api_v1/routers/platform.py
@@ -4,6 +4,7 @@ from app.db.session import get_db
 from app.db.crud import *
 from app.db.schemas import *
 from typing import List
+from app.core.auth import get_current_active_user,get_current_user

 platform_router = r = APIRouter()

@@ -140,19 +141,18 @@ async def flow_delete(
    return delete_flow(db, flowid)

@r.get(
-    "/domain/{userid}",
+    "/domains/{tenantid}",
    response_model=List[Domain],
    response_model_exclude_none=True,
 )
 async def domain_details(
    request: Request,
-    userid: str,
+    tenantid:str,
    db=Depends(get_db),
 ):
-    domains = get_domain(db, userid)
+    domains = get_domains(db,tenantid)
    return domains

-
@r.post("/domain", response_model=Domain, response_model_exclude_none=True)
 async def domain_create(
    request: Request,
@@ -174,13 +174,105 @@ async def domain_edit(


@r.delete(
-    "/domain/{userid}/{id}", response_model=Domain, response_model_exclude_none=True
+    "/domain/{id}", response_model=Domain, response_model_exclude_none=True
 )
 async def domain_delete(
    request: Request,
-    userid: int,
    id: int,
    db=Depends(get_db),
 ):

-    return delete_domain(db, userid,id)
+    return delete_domain(db,id)
+
+@r.get(
+    "/domain",
+    response_model=List[Domain],
+    response_model_exclude_none=True,
+)
+async def userdomain_details(
+    request: Request,
+    user=Depends(get_current_user),
+    db=Depends(get_db),
+):
+    domains = get_domain(db, user.id)
+    return domains
+
+@r.post(
+    "/domain/{userid}",
+    response_model_exclude_none=True,
+)
+async def create_userdomain(
+    request: Request,
+    userid: int,
+    domainids:list,
+    db=Depends(get_db),
+):
+    domain = add_userdomain(db, userid,domainids)
+    return domain
+
+@r.delete(
+    "/domain/{domainid}/{userid}", response_model_exclude_none=True
+)
+async def userdomain_delete(
+    request: Request,
+    domainid:int,
+    userid: int,
+    db=Depends(get_db),
+):
+    return delete_userdomain(db, userid,domainid)
+
+
+@r.get(
+    "/activedomain",
+    response_model=Domain,
+    response_model_exclude_none=True,
+)
+async def get_useractivedomain(
+    request: Request,
+    user=Depends(get_current_user),
+    db=Depends(get_db),
+):
+    domain = get_activedomain(db, user.id)
+    return domain
+
+@r.put(
+    "/activedomain/{domainid}",
+    response_model_exclude_none=True,
+)
+async def update_activeuserdomain(
+    request: Request,
+    domainid:int,
+    user=Depends(get_current_user),
+    db=Depends(get_db),
+):
+    domain = active_userdomain(db, user.id,domainid)
+    return domain
+
+
+@r.get(
+    "/events",
+    response_model=t.List[Event],
+    response_model_exclude={"id"},
+    response_model_exclude_none=True,
+)
+async def event_data(
+    request: Request,
+    db=Depends(get_db),
+):
+    events = get_events(db)
+    return events
+
+
+@r.get(
+    "/eventactions/{eventid}",
+    response_model=t.List[Action],
+    response_model_exclude={"id"},
+    response_model_exclude_none=True,
+)
+async def eventactions_data(
+    request: Request,
+    eventid: str,
+    db=Depends(get_db),
+):
+    actions = get_eventactions(db,eventid)
+    return actions
--- a/backend/app/core/auth.py
+++ b/backend/app/core/auth.py
@@ -3,7 +3,7 @@ from fastapi import Depends, HTTPException, status
 from jwt import PyJWTError

 from app.db import models, schemas, session
-from app.db.crud import get_user_by_email, create_user
+from app.db.crud import get_user_by_email, create_user,get_user
 from app.core import security


@@ -19,14 +19,14 @@ async def get_current_user(
        payload = jwt.decode(
            token, security.SECRET_KEY, algorithms=[security.ALGORITHM]
        )
-        email: str = payload.get("sub")
-        if email is None:
+        id: int = payload.get("sub")
+        if id is None:
            raise credentials_exception
        permissions: str = payload.get("permissions")
-        token_data = schemas.TokenData(email=email, permissions=permissions)
+        token_data = schemas.TokenData(id = id, permissions=permissions)
    except PyJWTError:
        raise credentials_exception
-    user = get_user_by_email(db, token_data.email)
+    user = get_user(db, token_data.id)
    if user is None:
        raise credentials_exception
    return user
@@ -58,7 +58,7 @@ def authenticate_user(db, email: str, password: str):
    return user


-def sign_up_new_user(db, email: str, password: str):
+def sign_up_new_user(db, email: str, password: str, firstname: str,lastname: str):
    user = get_user_by_email(db, email)
    if user:
        return False  # User already exists
@@ -67,6 +67,8 @@ def sign_up_new_user(db, email: str, password: str):
        schemas.UserCreate(
            email=email,
            password=password,
+            firstname = firstname,
+            lastname = lastname,
            is_active=True,
            is_superuser=False,
        ),
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -1,18 +1,26 @@
 import os
+import base64

 PROJECT_NAME = "KintoneAppBuilder"

 SQLALCHEMY_DATABASE_URI = "postgres://maxz64:m@xz1205@alicornkintone.postgres.database.azure.com/postgres"
-
-BASE_URL = "https://mfu07rkgnb7c.cybozu.com"
+#SQLALCHEMY_DATABASE_URI = "postgres://kabAdmin:P@ssw0rd!@kintonetooldb.postgres.database.azure.com/postgres"

 API_V1_STR = "/k/v1"

 API_V1_AUTH_KEY = "X-Cybozu-Authorization"

-API_V1_AUTH_VALUE = "TVhaOm1heHoxMjA1"
-
-KINTONE_USER = "MXZ"
-
 KINTONE_FIELD_TYPE=["GROUP","GROUP_SELECT","CHECK_BOX","SUBTABLE","DROP_DOWN","USER_SELECT","RADIO_BUTTON","RICH_TEXT","LINK","REFERENCE_TABLE","CALC","TIME","NUMBER","ORGANIZATION_SELECT","FILE","DATETIME","DATE","MULTI_SELECT","SINGLE_LINE_TEXT","MULTI_LINE_TEXT"]

+class KINTONE_ENV:
+    
+    BASE_URL = ""
+
+    API_V1_AUTH_VALUE = ""
+
+    KINTONE_USER = ""
+
+    def __init__(self,domain) -> None:
+        self.BASE_URL = domain.url
+        self.KINTONE_USER = domain.kintoneuser
+        self.API_V1_AUTH_VALUE = base64.b64encode(bytes(f"{domain.kintoneuser}:{domain.kintonepwd}","utf-8"))
--- a/backend/app/db/crud.py
+++ b/backend/app/db/crud.py
@@ -1,5 +1,6 @@
 from fastapi import HTTPException, status
 from sqlalchemy.orm import Session
+from sqlalchemy import and_
 import typing as t

 from . import models, schemas
@@ -182,8 +183,8 @@ def get_flows_by_app(db: Session, appid: str):
    return flows

 def create_domain(db: Session, domain: schemas.DomainBase):
-    db_domain = models.UserDomain(
-        userid=domain.userid,
+    db_domain = models.Domain(
+        tenantid = domain.tenantid,
        name=domain.name,
        url=domain.url,
        kintoneuser=domain.kintoneuser,
@@ -194,9 +195,9 @@ def create_domain(db: Session, domain: schemas.DomainBase):
    db.refresh(db_domain)
    return db_domain

-def delete_domain(db: Session, userid: int,id: int):
-    db_domain = db.query(models.UserDomain).get(id)
-    if not db_domain or db_domain.userid != userid:
+def delete_domain(db: Session,id: int):
+    db_domain = db.query(models.Domain).get(id)
+    if not db_domain:
        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Domain not found")
    db.delete(db_domain)
    db.commit()
@@ -206,8 +207,8 @@ def delete_domain(db: Session, userid: int,id: int):
 def edit_domain(
    db: Session, domain: schemas.DomainBase
 ) -> schemas.Domain:
-    db_domain = db.query(models.UserDomain).get(domain.id)
-    if not db_domain or db_domain.userid != domain.userid:
+    db_domain = db.query(models.Domain).get(domain.id)
+    if not db_domain:
        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Domain not found")
    update_data = domain.dict(exclude_unset=True)

@@ -220,8 +221,64 @@ def edit_domain(
    db.refresh(db_domain)
    return db_domain

+def add_userdomain(db: Session, userid:int,domainids:list):
+    for domainid in domainids:
+        db_domain = models.UserDomain(
+            userid = userid,
+            domainid = domainid
+        )
+        db.add(db_domain)
+    db.commit()
+    db.refresh(db_domain)
+    return db_domain
+
+def delete_userdomain(db: Session, userid: int,domainid: int):
+    db_domain = db.query(models.UserDomain).filter(and_(models.UserDomain.userid == userid,models.UserDomain.domainid == domainid)).first()
+    if not db_domain:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Domain not found")
+    db.delete(db_domain)
+    db.commit()
+    return db_domain
+
+def active_userdomain(db: Session, userid: int,domainid: int):
+    db_userdomains = db.query(models.UserDomain).filter(models.UserDomain.userid == userid).all()
+    if not db_userdomains:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Domain not found")
+    for domain in db_userdomains:
+        if domain.domainid == domainid:
+            domain.active = True
+        else:
+            domain.active = False
+        db.add(domain)
+    db.commit()
+    return db_userdomains
+
+def get_activedomain(db: Session, userid: int):
+    db_domain = db.query(models.Domain).join(models.UserDomain,models.UserDomain.domainid == models.Domain.id ).filter(and_(models.UserDomain.userid == userid,models.UserDomain.active == True)).first()
+    if not db_domain:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Domain not found")
+    return db_domain
+
 def get_domain(db: Session, userid: str):
-    domains = db.query(models.UserDomain).filter(models.UserDomain.userid == userid).all()
+    domains = db.query(models.Domain).join(models.UserDomain,models.UserDomain.domainid == models.Domain.id ).filter(models.UserDomain.userid == userid).all()
    if not domains:
        raise HTTPException(status_code=404, detail="Data not found")
    return domains
+
+def get_domains(db: Session,tenantid:str):
+    domains = db.query(models.Domain).filter(models.Domain.tenantid == tenantid ).all()
+    if not domains:
+        raise HTTPException(status_code=404, detail="Data not found")
+    return domains
+
+def get_events(db: Session):
+    events = db.query(models.Event).all()
+    if not events:
+        raise HTTPException(status_code=404, detail="Data not found")
+    return events
+
+def get_eventactions(db: Session,eventid: str):
+    eveactions = db.query(models.Action).join(models.EventAction,models.EventAction.actionid == models.Action.id ).join(models.Event,models.Event.id == models.EventAction.eventid).filter(models.Event.eventid == eventid).all()
+    if not eveactions:
+        raise HTTPException(status_code=404, detail="Data not found")
+    return eveactions
--- a/backend/app/db/models.py
+++ b/backend/app/db/models.py
@@ -50,12 +50,43 @@ class Flow(Base):
    name = Column(String(200))   
    content = Column(String)  

-class UserDomain(Base):
-    __tablename__ = "userdomain"
+class Tenant(Base):
+    __tablename__ = "tenant"

-    userid = Column(Integer,ForeignKey("user.id"))
+    tenantid =  Column(String(100), index=True, nullable=False)
+    name = Column(String(200)) 
+    licence  = Column(String(200)) 
+    startdate = Column(DateTime)
+    enddate = Column(DateTime) 
+
+class Domain(Base):
+    __tablename__ = "domain"
+
+    tenantid =  Column(String(100), index=True, nullable=False)
    name = Column(String(100), nullable=False)   
    url = Column(String(200), nullable=False)
    kintoneuser = Column(String(100), nullable=False)
    kintonepwd = Column(String(100), nullable=False)
+
+
+class UserDomain(Base):
+    __tablename__ = "userdomain"
+
+    userid = Column(Integer,ForeignKey("user.id"))
+    domainid = Column(Integer,ForeignKey("domain.id"))
    active = Column(Boolean, default=False)
+
+class Event(Base):
+    __tablename__ = "event"
+
+    category = Column(String(100), nullable=False)
+    type = Column(String(100), nullable=False)
+    eventid= Column(String(100), nullable=False)
+    function = Column(String(500), nullable=False)   
+    mobile = Column(Boolean, default=False)
+
+class EventAction(Base):
+    __tablename__ = "eventaction"
+
+    eventid = Column(Integer,ForeignKey("event.id"))
+    actionid = Column(Integer,ForeignKey("action.id"))
--- a/backend/app/db/schemas.py
+++ b/backend/app/db/schemas.py
@@ -21,6 +21,8 @@ class UserOut(UserBase):

 class UserCreate(UserBase):
    password: str
+    first_name: str
+    last_name: str

    class Config:
        orm_mode = True
@@ -46,6 +48,7 @@ class Token(BaseModel):


 class TokenData(BaseModel):
+    id:int = 0
    email: str = None
    permissions: str = "user"

@@ -106,21 +109,30 @@ class Flow(Base):

 class DomainBase(BaseModel):
    id: int
-    userid: int 
+    tenantid: str
    name: str 
    url: str
    kintoneuser: str 
    kintonepwd: str 
-    active:bool = False

 class Domain(Base):
    id: int
-    userid: str 
+    tenantid: str
    name: str 
    url: str
    kintoneuser: str 
    kintonepwd: str 
-    active:bool
+
+    class Config:
+        orm_mode = True
+
+class Event(Base):
+    id: int
+    category: str
+    type: str 
+    eventid: str
+    function: str 
+    mobile: bool

    class Config:
        orm_mode = True
--- a/frontend/src/components/DomainSelect.vue
+++ b/frontend/src/components/DomainSelect.vue
@@ -0,0 +1,42 @@
+<template>
+  <div class="q-pa-md">
+    <q-table :title="name+'一覧'" :selection="type" v-model:selected="selected" :columns="columns" :rows="rows" />
+  </div>
+</template>
+<script>
+import { ref,onMounted,reactive } from 'vue'
+import { api } from 'boot/axios';
+
+export default {
+  name: 'DomainSelect',
+  props: {
+    name: String,
+    type: String
+  },
+  setup() {
+  const columns = [
+  { name: 'id'},
+  { name: 'tenantid', required: true,label: 'テナント',align: 'left',field: 'tenantid',sortable: true},
+  { name: 'name', align: 'center', label: 'ドメイン', field: 'name', sortable: true },
+  { name: 'url', label: 'URL', field: 'url', sortable: true },
+  { name: 'kintoneuser', label: 'アカウント', field: 'kintoneuser' }
+  ]
+  const rows = reactive([])
+    onMounted( () => {
+      api.get(`http://127.0.0.1:8000/api/domains/testtenant`).then(res =>{
+         res.data.forEach((item) =>
+        {
+          rows.push({id:item.id,tenantid:item.tenantid,name:item.name,url:item.url,kintoneuser:item.kintoneuser});
+        }
+        )
+      });
+      });
+    return {
+      columns,
+      rows,
+      selected: ref([]),
+    }
+  },
+
+}
+</script>
--- a/frontend/src/components/DomainSelector.vue
+++ b/frontend/src/components/DomainSelector.vue
@@ -6,7 +6,7 @@
      no-caps
      icon="share"
      size="md"
-      :label="`${userStore.currentDomain.domainName}.cybozu.com`"
+      :label="userStore.currentDomain.domainName"
    >
      <q-list>
        <q-item v-for="domain in domains" :key="domain.domainName"
@@ -15,7 +15,8 @@
            <q-icon name="share" size="sm" color="orange" text-color="white"></q-icon>
          </q-item-section>
          <q-item-section>
-            <q-item-label>{{ `${domain.domainName}.cybozu.com` }}</q-item-label>
+            <q-item-label>{{domain.domainName}}</q-item-label>
+            <q-item-label caption>{{domain.kintoneUrl}}</q-item-label>
          </q-item-section>
        </q-item>
      </q-list>
--- a/frontend/src/pages/TenantDomain.vue
+++ b/frontend/src/pages/TenantDomain.vue
@@ -0,0 +1,225 @@
+<template>
+  <div class="q-pa-md">
+    <q-table
+      title="Treats"
+      :rows="rows"
+      :columns="columns"
+      row-key="id"
+      selection="single"
+      :filter="filter"
+      :loading="loading"
+      v-model:selected="selected"
+    >
+
+      <template v-slot:top>
+        <q-btn color="primary" :disable="loading" label="新規" @click="addRow" />
+        <q-btn class="q-ml-sm" color="primary" :disable="loading" label="編集" @click="editRow" />
+        <q-btn class="q-ml-sm" color="primary" :disable="loading" label="削除" @click="removeRow" />
+        <q-space />
+        <q-input borderless dense debounce="300" color="primary" v-model="filter">
+          <template v-slot:append>
+            <q-icon name="search" />
+          </template>
+        </q-input>
+      </template>
+
+    </q-table>
+
+    <q-dialog :model-value="show" persistent>
+      <q-card style="min-width: 400px">
+        <q-card-section>
+          <div class="text-h6">Kintone Account</div>
+        </q-card-section>
+
+        <q-card-section class="q-pt-none">
+          <q-form class="q-gutter-md">
+            <q-input filled v-model="tenantid" label="Tenant" hint="Tenant ID" lazy-rules
+              :rules="[val => val && val.length > 0 || 'Please type something']" />
+
+            <q-input filled v-model="name" label="Your name *" hint="Kintone envirment name" lazy-rules
+              :rules="[val => val && val.length > 0 || 'Please type something']" />
+
+            <q-input filled type="url" v-model="url" label="Kintone url" hint="Kintone domain address" lazy-rules
+              :rules="[val => val && val.length > 0, isDomain || 'Please type something']" />
+
+            <q-input filled v-model="kintoneuser" label="Login user " hint="Kintone user name" lazy-rules
+              :rules="[val => val && val.length > 0 || 'Please type something']" />
+
+            <q-input v-model="kintonepwd" filled :type="isPwd ? 'password' : 'text'" hint="Password with toggle"
+              label="User password">
+              <template v-slot:append>
+                <q-icon :name="isPwd ? 'visibility_off' : 'visibility'" class="cursor-pointer" @click="isPwd = !isPwd" />
+              </template>
+            </q-input>
+          </q-form>
+        </q-card-section>
+        <q-card-actions align="right" class="text-primary">
+          <q-btn label="Save" type="submit" color="primary" @click="onSubmit"/>
+          <q-btn label="Cancel" type="cancel" color="primary" flat class="q-ml-sm" @click="closeDg()"/>
+        </q-card-actions>
+      </q-card>
+
+    </q-dialog>
+
+    <q-dialog v-model="confirm" persistent>
+      <q-card>
+        <q-card-section class="row items-center">
+          <q-avatar icon="confirm" color="primary" text-color="white" />
+          <span class="q-ml-sm">削除してもよろしいですか？</span>
+        </q-card-section>
+
+        <q-card-actions align="right">
+          <q-btn flat label="Cancel" color="primary" v-close-popup />
+          <q-btn flat label="OK" color="primary" v-close-popup @click = "deleteDomain()"/>
+        </q-card-actions>
+      </q-card>
+    </q-dialog>
+
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref,onMounted, reactive} from 'vue';
+import { useQuasar } from 'quasar'
+import { api } from 'boot/axios';
+
+const columns = [
+  { name: 'id'},
+  {
+    name: 'tenantid',
+    required: true,
+    label: 'Tenant',
+    align: 'left',
+    field: row => row.tenantid,
+    format: val => `${val}`,
+    sortable: true
+  },
+  { name: 'name', align: 'center', label: 'Name', field: 'name', sortable: true },
+  { name: 'url', align: 'left',label: 'URL', field: 'url', sortable: true },
+  { name: 'user', label: 'Account', field: 'user' },
+  { name: 'password', label: 'Password', field: 'password' }
+]
+
+
+  const loading = ref(false)
+  const filter = ref('')
+  const rows = reactive([])
+  const show = ref(false);
+  const confirm = ref(false);
+  const selected = ref([])
+  const tenantid = ref('')
+  const name = ref('')
+  const url =ref('')
+  const isPwd =ref(true)
+  const kintoneuser =ref('')
+  const kintonepwd =ref('')
+
+  const $q = useQuasar()
+
+  let editId = ref(0);
+
+    const getDomain = () => {
+      loading.value = true;
+      api.get(`http://127.0.0.1:8000/api/domains/testtenant`).then(res => {
+        rows.length = 0;
+        res.data.forEach((item) => {
+          rows.push({ id:item.id,tenantid: item.tenantid,name: item.name, url: item.url, user: item.kintoneuser, password: item.kintonepwd });
+        }
+        )
+  }).finally(()=>{ loading.value = false; });
+
+}
+onMounted(() => {
+  getDomain();
+})
+
+
+
+      // emulate fetching data from server
+      const addRow = () => {
+        editId.value
+        show.value = true;
+      }
+
+      const removeRow = () => {
+        //loading.value = true
+        confirm.value = true;
+        let row = JSON.parse(JSON.stringify(selected.value[0]));
+        if(selected.value.length === 0)
+        {
+          return;
+        }
+        editId.value = row.id;
+      }
+
+      const deleteDomain = () => {
+        api.delete(`http://127.0.0.1:8000/api/domain/`+ editId.value).then(() =>{
+                  getDomain();
+                })
+        editId.value = 0;
+        selected.value=[];
+      };
+
+    const editRow = () => {
+        if(selected.value.length === 0)
+        {
+          return;
+        }
+        let row = JSON.parse(JSON.stringify(selected.value[0]));
+        editId.value = row.id;
+        tenantid.value = row.tenantid;
+        name.value = row.name;
+        url.value = row.url;
+        kintoneuser.value = row.user;
+        kintonepwd.value = row.password;
+        isPwd.value = true;
+        show.value = true;
+      };
+    const closeDg = () =>  {
+      show.value = false;
+      onReset();
+    }
+
+    const onSubmit = () => {
+      if(editId.value !== 0)
+      {
+        api.put(`http://127.0.0.1:8000/api/domain`,{
+                'id': editId.value,
+                'tenantid': tenantid.value,
+                'name': name.value,
+                'url': url.value,
+                'kintoneuser': kintoneuser.value,
+                'kintonepwd': kintonepwd.value
+              }).then(() =>{
+                getDomain();
+                closeDg();
+                onReset();
+              })
+      }
+      else
+      {
+        api.post(`http://127.0.0.1:8000/api/domain`,{
+                'id': 0,
+                'tenantid': tenantid.value,
+                'name': name.value,
+                'url': url.value,
+                'kintoneuser': kintoneuser.value,
+                'kintonepwd': kintonepwd.value
+              }).then(() =>{
+                getDomain();
+                closeDg();
+                onReset();
+              })
+      }
+      selected.value=[];
+    }
+
+  const onReset = () => {
+      name.value = '';
+      url.value = '';
+      kintoneuser.value = '';
+      kintonepwd.value ='';
+      isPwd.value = true;
+      editId.value = 0;
+    }
+</script>
--- a/frontend/src/pages/UserDomain.vue
+++ b/frontend/src/pages/UserDomain.vue
@@ -111,7 +111,7 @@ export default {
     <q-table grid grid-header title="Domain" selection="single" :rows="rows" :columns="columns"   v-model:selected="selected" row-key="name" :filter="filter" hide-header>
      <template v-slot:top>
        <div class="q-pa-md q-gutter-sm">
-        <q-btn color="primary" size="sm" label=" 新規 " @click="newDomain()" dense />
+        <q-btn color="primary" label="追加" @click="newDomain()" dense />
      </div>
        <q-space />
        <q-input borderless dense debounce="300" v-model="filter" placeholder="Search">
@@ -125,21 +125,24 @@ export default {
          <q-card>
            <q-card-section>
              <div class="q-table__grid-item-row">
-                <div class="q-table__grid-item-title">Name</div>
+                <div class="q-table__grid-item-title">Domain</div>
                <div class="q-table__grid-item-value">{{ props.row.name }}</div>
              </div>
              <div class="q-table__grid-item-row">
-                <div class="q-table__grid-item-title">Domain</div>
+                <div class="q-table__grid-item-title">URL</div>
                <div class="q-table__grid-item-value">{{ props.row.url }}</div>
              </div>
              <div class="q-table__grid-item-row">
                <div class="q-table__grid-item-title">Account</div>
                <div class="q-table__grid-item-value">{{ props.row.kintoneuser }}</div>
              </div>
+              <div class="q-table__grid-item-row">
+                <div class="q-table__grid-item-value">{{isActive(props.row.id) }}</div>
+              </div>
            </q-card-section>
            <q-separator />
            <q-card-actions align="right">
-              <q-btn flat @click = "editDomain(props.row)">編集</q-btn>
+              <q-btn flat @click = "activeDomain(props.row.id)">有効</q-btn>
              <q-btn flat @click = "deleteConfirm(props.row)">削除</q-btn>
            </q-card-actions>
          </q-card>
@@ -147,40 +150,9 @@ export default {
      </template>
    </q-table>

-    <q-dialog :model-value="show" persistent>
-      <q-card style="min-width: 400px">
-        <q-card-section>
-          <div class="text-h6">Kintone Account</div>
-        </q-card-section>
-
-        <q-card-section class="q-pt-none">
-          <q-form class="q-gutter-md">
-            <q-input filled v-model="name" label="Your name *" hint="Kintone envirment name" lazy-rules
-              :rules="[val => val && val.length > 0 || 'Please type something']" />
-
-            <q-input filled type="url" v-model="url" label="Kintone url" hint="Kintone domain address" lazy-rules
-              :rules="[val => val && val.length > 0, isDomain || 'Please type something']" />
-
-            <q-input filled v-model="kintoneuser" label="Login user " hint="Kintone user name" lazy-rules
-              :rules="[val => val && val.length > 0 || 'Please type something']" />
-
-            <q-input v-model="kintonepwd" filled :type="isPwd ? 'password' : 'text'" hint="Password with toggle"
-              label="User password">
-              <template v-slot:append>
-                <q-icon :name="isPwd ? 'visibility_off' : 'visibility'" class="cursor-pointer" @click="isPwd = !isPwd" />
-              </template>
-            </q-input>
-
-            <q-toggle v-model="active" label="Active Domain" />
-          </q-form>
-        </q-card-section>
-        <q-card-actions align="right" class="text-primary">
-          <q-btn label="Save" type="submit" color="primary" @click="onSubmit"/>
-          <q-btn label="Cancel" type="cancel" color="primary" flat class="q-ml-sm" @click="closeDg()"/>
-        </q-card-actions>
-      </q-card>
-
-    </q-dialog>
+    <show-dialog v-model:visible="show" name="ドメイン" @close="closeDg">
+        <domain-select ref="domainDg" name="ドメイン" type="multiple"></domain-select>
+    </show-dialog>

    <q-dialog v-model="confirm" persistent>
      <q-card>
@@ -201,23 +173,23 @@ export default {
 <script setup lang="ts">
 import { useQuasar } from 'quasar'
 import { ref, onMounted, reactive } from 'vue'
-import { api } from 'boot/axios';
+import ShowDialog from 'components/ShowDialog.vue';
+import DomainSelect from 'components/DomainSelect.vue';
+import { useAuthStore } from 'stores/useAuthStore';

+const authStore = useAuthStore();
+import { api } from 'boot/axios';

 const $q = useQuasar()

+const domainDg = ref();
 const selected = ref([])
-const name = ref('')
-const active = ref(false)
-const isPwd =ref(true)
-const url =ref('')
-const kintoneuser =ref('')
-const kintonepwd =ref('')

 const show = ref(false);
 const confirm = ref(false)

 let editId = ref(0);
+let activedomainid = ref(0);

 const columns = [
 { name: 'id'},
@@ -231,25 +203,29 @@ const columns = [
  },
  { name: 'url', align: 'center', label: 'Domain', field: 'url', sortable: true },
  { name: 'kintoneuser', label: 'User', field: 'kintoneuser', sortable: true },
-  { name: 'kintonepwd' }
+  { name: 'kintonepwd' },
+  { name: 'active', field: 'active'}
 ]

 const rows = reactive([])

+const isActive = (id:number) =>{
+  if(id == activedomainid.value)
+    return "Active";
+  else
+    return "Inactive";
+}
+
 const newDomain = () => {
  editId.value = 0;
  show.value = true;
 };

-const editDomain = (row:object) => {
-  editId.value = row.id;
-  name.value = row.name;
-  url.value = row.url;
-  kintoneuser.value = row.kintoneuser;
-  kintonepwd.value = row.kintonepwd;
-  isPwd.value = true;
-  active.value = false;
-  show.value = true;
+
+const activeDomain = (id:number) => {
+  api.put(`http://127.0.0.1:8000/api/activedomain/`+ id).then(() =>{
+            getDomain();
+          })
 };

 const deleteConfirm = (row:object) => {
@@ -258,21 +234,33 @@ const deleteConfirm = (row:object) => {
 };

 const deleteDomain = () => {
-  api.delete(`http://127.0.0.1:8000/api/domain/1/`+ editId.value).then(() =>{
+  api.delete(`http://127.0.0.1:8000/api/domain/`+ editId.value+'/1').then(() =>{
            getDomain();
          })
  editId.value = 0;
 };

-const closeDg = () => {
-  show.value = false;
-  onReset();
+const closeDg = (val:string) => {
+  if (val == 'OK') {
+    let dodmainids =[];
+    let domains = JSON.parse(JSON.stringify(domainDg.value.selected));
+    for(var key in domains)
+    {
+      dodmainids.push(domains[key].id);
+    }
+    api.post(`http://127.0.0.1:8000/api/domain`, dodmainids).then(() =>{getDomain();});
+  }
+
 };
 const getDomain = () => {
-  api.get(`http://127.0.0.1:8000/api/domain/1`).then(res => {
+  api.get(`http://127.0.0.1:8000/api/activedomain`).then(res => {
+    activedomainid.value = res.data.id;
+    authStore.changedomain(res.data.name);
+  });
+  api.get(`http://127.0.0.1:8000/api/domain`).then(res => {
    rows.length = 0;
    res.data.forEach((item) => {
-      rows.push({ id:item.id,name: item.name, url: item.url, kintoneuser: item.kintoneuser, kintonepwd: item.kintonepwd });
+      rows.push({ id:item.id,name: item.name, url: item.url, kintoneuser: item.kintoneuser, kintonepwd: item.kintonepwd});
    }
    )
  });
@@ -286,68 +274,6 @@ const isDomain = (val) =>{
      //  return (domainPattern.test(val) || '無効なURL')
      return true;
    };
-
-const onSubmit = () =>{
-  if(editId.value !== 0)
-  {
-    api.put(`http://127.0.0.1:8000/api/domain`,{
-            'id': editId.value,
-            'userid': 1,
-            'name': name.value,
-            'url': url.value,
-            'kintoneuser': kintoneuser.value,
-            'kintonepwd': kintonepwd.value,
-            'active': active.value
-          }).then(() =>{
-            getDomain();
-            closeDg();
-            onReset();
-          })
-  }
-  else
-  {
-    api.post(`http://127.0.0.1:8000/api/domain`,{
-            'id': 0,
-            'userid': 1,
-            'name': name.value,
-            'url': url.value,
-            'kintoneuser': kintoneuser.value,
-            'kintonepwd': kintonepwd.value,
-            'active': active.value
-          }).then(() =>{
-            getDomain();
-            closeDg();
-            onReset();
-          })
-    }
-  // if (accept.value !== true) {
-  //   $q.notify({
-  //     color: 'red-5',
-  //     textColor: 'white',
-  //     icon: 'warning',
-  //     message: 'You need to accept the license and terms first'
-  //   })
-  // }
-  // else {
-  //   $q.notify({
-  //     color: 'green-4',
-  //     textColor: 'white',
-  //     icon: 'cloud_done',
-  //     message: 'Submitted'
-  //   })
-  // }
-};
-
-const onReset = () => {
-  name.value = '';
-  url.value = '';
-  kintoneuser.value = '';
-  kintonepwd.value ='';
-  isPwd.value = true;
-  active.value = false;
-  editId.value = 0;
-}
-
 </script>


--- a/frontend/src/router/routes.ts
+++ b/frontend/src/router/routes.ts
@@ -19,7 +19,8 @@ const routes: RouteRecordRaw[] = [
      { path: 'flowEditor2', component: () => import('pages/FlowChart.vue') },
      { path: 'flowChart2', component: () => import('pages/FlowEditorPage2.vue') },
      { path: 'right', component: () => import('pages/testRight.vue') },
-      { path: 'domain', component: () => import('pages/UserDomain.vue') }
+      { path: 'domain', component: () => import('pages/TenantDomain.vue') },
+      { path: 'userdomain', component: () => import('pages/UserDomain.vue') }
    ],
  },
  // Always leave this as last one,
--- a/frontend/src/stores/useAuthStore.ts
+++ b/frontend/src/stores/useAuthStore.ts
@@ -11,11 +11,17 @@ export interface IUserState{

 export const useAuthStore = defineStore({
    id: 'auth',
-    state: () :IUserState => ({
-        token: localStorage.getItem('token')||'',
-        returnUrl: '',
-        currentDomain: JSON.parse(localStorage.getItem('currentDomain')||"{}")
-    }),
+    state: ():IUserState =>{
+      const token=localStorage.getItem('token')||'';
+      if(token!==''){
+        api.defaults.headers["Authorization"]='Bearer ' + token;
+      }
+      return {
+          token,
+          returnUrl: '',
+          currentDomain: JSON.parse(localStorage.getItem('currentDomain')||"{}")
+        }
+    },
    actions: {
        async login(username:string, password:string) {
          const params = new URLSearchParams();
@@ -26,6 +32,7 @@ export const useAuthStore = defineStore({
              console.info(result);
              this.token =result.data.access_token;
              localStorage.setItem('token', result.data.access_token);
+              api.defaults.headers["Authorization"]='Bearer ' + this.token;
              this.currentDomain=await this.getCurrentDomain();
              localStorage.setItem('currentDomain',JSON.stringify(this.currentDomain));
              Router.push(this.returnUrl || '/');
@@ -37,22 +44,23 @@ export const useAuthStore = defineStore({
          }
        },
        async getCurrentDomain():Promise<IDomainInfo>{
+          const activedomain = await api.get(`http://127.0.0.1:8000/api/activedomain`);
          return {
-            domainName:'mfu07rkgnb7c',
-            kintoneUrl:'https://mfu07rkgnb7c.cybozu.com'
+            id:activedomain.data.id,
+            domainName:activedomain.data.name,
+            kintoneUrl:activedomain.data.url
          }
        },
        async getUserDomains():Promise<IDomainInfo[]>{
-          return [
-            {
-              domainName:'mfu07rkgnb7c',
-              kintoneUrl:'https://mfu07rkgnb7c.cybozu.com'
-            },
-            {
-              domainName:'alicorn',
-              kintoneUrl:'https://alicorn.cybozu.com'
+          const resp = await api.get(`http://127.0.0.1:8000/api/domain`);
+          const domains =resp.data as any[];
+          return domains.map(data=>{
+            return {
+              id:data.id,
+              domainName:data.name,
+              kintoneUrl:data.url
            }
-          ]
+          });
        },
        logout() {
            this.token = undefined;
@@ -60,7 +68,11 @@ export const useAuthStore = defineStore({
            localStorage.removeItem('currentDomain');
            Router.push('/login');
        },
-        setCurrentDomain(domain:IDomainInfo){
+        async setCurrentDomain(domain:IDomainInfo){
+          if(domain.id===this.currentDomain.id){
+            return;
+          }
+          await api.put(`http://127.0.0.1:8000/api/activedomain/${domain.id}`);
          this.currentDomain=domain;
          localStorage.setItem('currentDomain',JSON.stringify(this.currentDomain));
        }
--- a/frontend/src/types/ActionTypes.ts
+++ b/frontend/src/types/ActionTypes.ts
@@ -1,5 +1,6 @@
 import { v4 as uuidv4 } from 'uuid';
 export interface IDomainInfo{
+  id:number;
  domainName:string;
  kintoneUrl:string;
 }