diff --git a/web/templates/gen-windws.html b/web/templates/gen-windws.html
index d99a97d..54f40ef 100644
--- a/web/templates/gen-windws.html
+++ b/web/templates/gen-windws.html
@@ -21,7 +21,7 @@ <h1 class="mt-4">데이터 생성 Windows</h1>
                 <div class="input-group">
                     <span class="input-group-text"><i class="fas fa-folder"></i></span>
                     <div class="form-floating">
-                      <input type="text" class="form-control" id="gen-windows-path" name="path" value={{ .tmpPath }} placeholder="디렉토리 경로">
+                      <input type="text" class="form-control" id="gen-windows-path" name="path" value={{ .TmpPath }} placeholder="디렉토리 경로">
                       <label for="gen-windows-path">디렉토리 경로</label>
                     </div>
                 </div>
diff --git a/web/templates/index.html b/web/templates/index.html
index 9d41437..d9b23a2 100644
--- a/web/templates/index.html
+++ b/web/templates/index.html
@@ -24,7 +24,7 @@
                             </a>
                             <div class="collapse" id="collapseOnpremiseGenerate" data-bs-parent="#collapseOnpremiseGenerate">
                                 <nav class="sb-sidenav-menu-nested nav">
-                                    {{if eq .os "linux"}}
+                                    {{if eq .OS "linux"}}
                                         <a class="nav-link" href="/generate/linux">Linux</a>
                                     {{else}}
                                         <a class="nav-link" href="/generate/windows">Windows</a>
@@ -80,7 +80,7 @@
                             </a>
                             <div class="collapse" id="collapseOnpremiseMigration" data-bs-parent="#sidenavAccordion">
                                 <nav class="sb-sidenav-menu-nested nav accordion" id="sidenavAccordionOnpremiseMigration">
-                                    {{if eq .os "linux"}}
+                                    {{if eq .OS "linux"}}
                                         <a class="nav-link collapsed" href="#" data-bs-toggle="collapse" data-bs-target="#migrationCollapseLinux" aria-expanded="false" aria-controls="migrationCollapseLinux">
                                             Linux to
                                             <div class="sb-sidenav-collapse-arrow"><i class="fas fa-angle-down"></i></div>
@@ -123,7 +123,7 @@
                                     </a>
                                     <div class="collapse" id="migrationCollapseS3" data-bs-parent="#sidenavAccordionObjectStorageMigration">
                                         <nav class="sb-sidenav-menu-nested nav">
-                                            {{if eq .os "linux"}}
+                                            {{if eq .OS "linux"}}
                                                 <a class="nav-link" href="/migration/s3/linux">Linux</a>
                                             {{else}}
                                                 <a class="nav-link" href="/migration/s3/windows">Windows</a>
@@ -139,7 +139,7 @@
                                     </a>
                                     <div class="collapse" id="migrationCollapseGCP" data-bs-parent="#sidenavAccordionObjectStorageMigration">
                                         <nav class="sb-sidenav-menu-nested nav">
-                                            {{if eq .os "linux"}}
+                                            {{if eq .OS "linux"}}
                                                 <a class="nav-link" href="/migration/gcp/linux">Linux</a>
                                             {{else}}
                                                 <a class="nav-link" href="/migration/gcp/windows">Windows</a>
@@ -155,7 +155,7 @@
                                     </a>
                                     <div class="collapse" id="migrationCollapseNCP" data-bs-parent="#sidenavAccordionObjectStorageMigration">
                                         <nav class="sb-sidenav-menu-nested nav">
-                                            {{if eq .os "linux"}}
+                                            {{if eq .OS "linux"}}
                                                 <a class="nav-link" href="/migration/ncp/linux">Linux</a>
                                             {{else}}
                                                 <a class="nav-link" href="/migration/ncp/windows">Windows</a>
diff --git a/websrc/controllers/generateHandlers.go b/websrc/controllers/generateHandlers.go
index 504dc9e..4a01497 100644
--- a/websrc/controllers/generateHandlers.go
+++ b/websrc/controllers/generateHandlers.go
@@ -7,17 +7,12 @@ import (
 	"path/filepath"
 	"time"
 
+	"github.com/cloud-barista/cm-data-mold/websrc/models"
 	"github.com/labstack/echo/v4"
 )
 
-// SimpleMsg is struct for JSON Simple message
-type BasicResponse struct {
-	Result string `json:"Result"`
-	Error  string `json:"Error"`
-}
-
 type GenerateLinuxPostHandlerResponseBody struct {
-	BasicResponse
+	models.BasicResponse
 }
 
 // GenerateLinuxPostHandler godoc
@@ -39,25 +34,25 @@ func GenerateLinuxPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("genlinux", "Create dummy data in linux", start)
 
 	if !osCheck(logger, start, "linux") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := getData("gen", ctx).(GenDataParams)
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Successfully creating a dummy with Linux", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -69,9 +64,9 @@ func GenerateWindowsPostHandler(ctx echo.Context) error {
 
 	if !osCheck(logger, start, "windows") {
 		fmt.Println("test")
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
@@ -79,17 +74,17 @@ func GenerateWindowsPostHandler(ctx echo.Context) error {
 	params := getData("gen", ctx).(GenDataParams)
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	jobEnd(logger, "Successfully creating a dummy with Windows", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -102,9 +97,9 @@ func GenerateS3PostHandler(ctx echo.Context) error {
 
 	tmpDir, ok := createDummyTemp(logger, start)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
@@ -112,34 +107,34 @@ func GenerateS3PostHandler(ctx echo.Context) error {
 	params.DummyPath = tmpDir
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	awsOSC := getS3OSC(logger, start, "gen", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	if !oscImport(logger, start, "s3", awsOSC, params.DummyPath) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	jobEnd(logger, "Dummy creation and import successful with s3", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -151,27 +146,27 @@ func GenerateGCPPostHandler(ctx echo.Context) error {
 	params := getData("gen", ctx).(GenDataParams)
 
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	tmpDir, ok := createDummyTemp(logger, start)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
@@ -179,33 +174,33 @@ func GenerateGCPPostHandler(ctx echo.Context) error {
 	params.DummyPath = tmpDir
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	gcpOSC := getGCPCOSC(logger, start, "gen", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	if !oscImport(logger, start, "gcp", gcpOSC, params.DummyPath) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Dummy creation and import successful with gcp", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -218,9 +213,9 @@ func GenerateNCPPostHandler(ctx echo.Context) error {
 
 	tmpDir, ok := createDummyTemp(logger, start)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
@@ -229,33 +224,33 @@ func GenerateNCPPostHandler(ctx echo.Context) error {
 	params.DummyPath = tmpDir
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	ncpOSC := getS3COSC(logger, start, "gen", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	if !oscImport(logger, start, "ncp", ncpOSC, params.DummyPath) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Create dummy data and import to ncp objectstorage", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -268,9 +263,9 @@ func GenerateMySQLPostHandler(ctx echo.Context) error {
 
 	tmpDir, ok := createDummyTemp(logger, start)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(tmpDir)
@@ -280,27 +275,27 @@ func GenerateMySQLPostHandler(ctx echo.Context) error {
 	params.SizeServerSQL = "5"
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	rdbc := getMysqlRDBC(logger, start, "gen", params)
 	if rdbc == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	sqlList := []string{}
 	if !walk(logger, start, &sqlList, params.DummyPath, ".sql") {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -313,9 +308,9 @@ func GenerateMySQLPostHandler(ctx echo.Context) error {
 			logger.Errorf("os ReadFile failed : %v", err)
 			logger.Infof("end time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 			logger.Infof("Elapsed time : %s", end.Sub(start).String())
-			return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-				"Result": logstrings.String(),
-				"Error":  nil,
+			return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+				Result: logstrings.String(),
+				Error:  nil,
 			})
 
 		}
@@ -326,18 +321,18 @@ func GenerateMySQLPostHandler(ctx echo.Context) error {
 			logger.Errorf("RDBController import failed : %v", err)
 			logger.Infof("end time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 			logger.Infof("Elapsed time : %s", end.Sub(start).String())
-			return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-				"Result": logstrings.String(),
-				"Error":  nil,
+			return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+				Result: logstrings.String(),
+				Error:  nil,
 			})
 		}
 		logger.Infof("sql put success : %s", filepath.Base(sql))
 	}
 
 	jobEnd(logger, "Dummy creation and import successful with mysql", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -350,9 +345,9 @@ func GenerateDynamoDBPostHandler(ctx echo.Context) error {
 
 	tmpDir, ok := createDummyTemp(logger, start)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(tmpDir)
@@ -362,39 +357,39 @@ func GenerateDynamoDBPostHandler(ctx echo.Context) error {
 	params.SizeServerJSON = "1"
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jsonList := []string{}
 	if !walk(logger, start, &jsonList, params.DummyPath, ".json") {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsNRDB := getDynamoNRDBC(logger, start, "gen", params)
 	if awsNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !nrdbPutWorker(logger, start, "DynamoDB", awsNRDB, jsonList) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Dummy creation and import successful with dynamoDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -405,26 +400,26 @@ func GenerateFirestorePostHandler(ctx echo.Context) error {
 
 	params := GenDataParams{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	tmpDir, ok := createDummyTemp(logger, start)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(tmpDir)
@@ -434,39 +429,39 @@ func GenerateFirestorePostHandler(ctx echo.Context) error {
 	params.SizeServerJSON = "1"
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jsonList := []string{}
 	if !walk(logger, start, &jsonList, params.DummyPath, ".json") {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	gcpNRDB := getFirestoreNRDBC(logger, start, "gen", params, credFileName)
 	if gcpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !nrdbPutWorker(logger, start, "FirestoreDB", gcpNRDB, jsonList) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Dummy creation and import successful with firestoreDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -479,9 +474,9 @@ func GenerateMongoDBPostHandler(ctx echo.Context) error {
 
 	tmpDir, ok := createDummyTemp(logger, start)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(tmpDir)
@@ -491,39 +486,39 @@ func GenerateMongoDBPostHandler(ctx echo.Context) error {
 	params.SizeServerJSON = "1"
 
 	if !dummyCreate(logger, start, params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jsonList := []string{}
 	if !walk(logger, start, &jsonList, params.DummyPath, ".json") {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	ncpNRDB := getMongoNRDBC(logger, start, "gen", params)
 	if ncpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !nrdbPutWorker(logger, start, "MongoDB", ncpNRDB, jsonList) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Dummy creation and import successful with mongoDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
diff --git a/websrc/controllers/migrationGCPHandlers.go b/websrc/controllers/migrationGCPHandlers.go
index 7e11a9f..71b7066 100644
--- a/websrc/controllers/migrationGCPHandlers.go
+++ b/websrc/controllers/migrationGCPHandlers.go
@@ -3,27 +3,15 @@ package controllers
 import (
 	"net/http"
 	"os"
-	"path/filepath"
-	"runtime"
 	"time"
 
+	"github.com/cloud-barista/cm-data-mold/websrc/models"
 	"github.com/labstack/echo/v4"
 )
 
 // Object Storage
 
 // FROM Google Cloud Storage
-func MigrationGCPToLinuxGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("miggcplin")
-	logger.Info("miggcplin get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-GCP-Linux",
-		"os":      runtime.GOOS,
-		"Regions": GetGCPRegions(),
-		"error":   nil,
-	})
-}
 
 func MigrationGCPToLinuxPostHandler(ctx echo.Context) error {
 
@@ -32,63 +20,49 @@ func MigrationGCPToLinuxPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("miggcplin", "Export gcp data to windows", start)
 
 	if !osCheck(logger, start, "linux") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscExport(logger, start, "gcp", gcpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from gcp to linux", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationGCPToWindowsGetHandler(ctx echo.Context) error {
-	tmpPath := filepath.Join(os.TempDir(), "dummy")
-
-	logger := getLogger("miggcpwin")
-	logger.Info("miggcpwin get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-GCP-Windows",
-		"os":      runtime.GOOS,
-		"Regions": GetGCPRegions(),
-		"tmpPath": tmpPath,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -99,60 +73,49 @@ func MigrationGCPToWindowsPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("miggcpwin", "Export gcp data to windows", start)
 
 	if !osCheck(logger, start, "windows") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscExport(logger, start, "gcp", gcpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from gcp to windows", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationGCPToS3GetHandler(ctx echo.Context) error {
-
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-GCP-S3",
-		"os":         runtime.GOOS,
-		"GCPRegions": GetGCPRegions(),
-		"AWSRegions": GetAWSRegions(),
-		"error":      nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -164,34 +127,34 @@ func MigrationGCPToS3PostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -201,30 +164,17 @@ func MigrationGCPToS3PostHandler(ctx echo.Context) error {
 		logger.Errorf("OSController migration failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from gcp to s3", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationGCPToNCPGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("miggcpncp")
-	logger.Info("miggcpncp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-GCP-NCP",
-		"os":         runtime.GOOS,
-		"GCPRegions": GetGCPRegions(),
-		"NCPRegions": GetNCPRegions(),
-		"error":      nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -236,34 +186,34 @@ func MigrationGCPToNCPPostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -273,15 +223,15 @@ func MigrationGCPToNCPPostHandler(ctx echo.Context) error {
 		logger.Errorf("OSController migration failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Successfully migrated data from gcp to ncp", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
diff --git a/websrc/controllers/migrationHandlers.go b/websrc/controllers/migrationHandlers.go
index 972e135..a5c096f 100644
--- a/websrc/controllers/migrationHandlers.go
+++ b/websrc/controllers/migrationHandlers.go
@@ -3,75 +3,52 @@ package controllers
 import (
 	"net/http"
 	"os"
-	"path/filepath"
-	"runtime"
 	"time"
 
+	"github.com/cloud-barista/cm-data-mold/websrc/models"
 	"github.com/labstack/echo/v4"
 )
 
-func MigrationLinuxToS3GetHandler(ctx echo.Context) error {
-	logger := getLogger("miglins3")
-	logger.Info("miglinux get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-Linux-S3",
-		"Regions": GetAWSRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
-	})
-}
-
 func MigrationLinuxToS3PostHandler(ctx echo.Context) error {
 	start := time.Now()
 
 	logger, logstrings := pageLogInit("miglins3", "Import linux data to s3", start)
 
 	if !osCheck(logger, start, "linux") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscImport(logger, start, "s3", awsOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from Linux to s3", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationLinuxToGCPGetHandler(ctx echo.Context) error {
-	logger := getLogger("miglingcp")
-	logger.Info("miglingcp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-Linux-GCP",
-		"Regions": GetGCPRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -81,27 +58,27 @@ func MigrationLinuxToGCPPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("miglingcp", "Import linux data to gcp", start)
 
 	if !osCheck(logger, start, "linux") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
@@ -109,38 +86,26 @@ func MigrationLinuxToGCPPostHandler(ctx echo.Context) error {
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	if !oscImport(logger, start, "gcp", gcpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from Linux to gcp", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationLinuxToNCPGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("miglinncp")
-	logger.Info("miglinncp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-Linux-NCP",
-		"Regions": GetNCPRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -151,56 +116,42 @@ func MigrationLinuxToNCPPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("miglinncp", "Import linux data to ncp objectstorage", start)
 
 	if !osCheck(logger, start, "linux") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscImport(logger, start, "ncp", ncpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from Linux to ncp objectstorage", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationWindowsToS3GetHandler(ctx echo.Context) error {
-	tmpPath := filepath.Join(os.TempDir(), "dummy")
-	logger := getLogger("migwins3")
-	logger.Info("migwins3 get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-Windows-S3",
-		"Regions": GetAWSRegions(),
-		"os":      runtime.GOOS,
-		"tmpPath": tmpPath,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
-
 }
 
 func MigrationWindowsToS3PostHandler(ctx echo.Context) error {
@@ -210,57 +161,44 @@ func MigrationWindowsToS3PostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("migwins3", "Import windows data to s3", start)
 
 	if !osCheck(logger, start, "windows") {
-		return ctx.JSON(http.StatusOK, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusOK, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	if !oscImport(logger, start, "s3", awsOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from Windows to s3", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationWindowsToGCPGetHandler(ctx echo.Context) error {
-	tmpPath := filepath.Join(os.TempDir(), "dummy")
-	logger := getLogger("migwingcp")
-	logger.Info("migwingcp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-Windows-GCP",
-		"Regions": GetGCPRegions(),
-		"os":      runtime.GOOS,
-		"tmpPath": tmpPath,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -270,63 +208,49 @@ func MigrationWindowsToGCPPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("migwingcp", "Import windows data to gcp", start)
 
 	if !osCheck(logger, start, "windows") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscImport(logger, start, "gcp", gcpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from Windows to gcp", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationWindowsToNCPGetHandler(ctx echo.Context) error {
-	tmpPath := filepath.Join(os.TempDir(), "dummy")
-
-	logger := getLogger("migwinncp")
-	logger.Info("migwinncp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-Windows-NCP",
-		"Regions": GetNCPRegions(),
-		"os":      runtime.GOOS,
-		"tmpPath": tmpPath,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -337,54 +261,44 @@ func MigrationWindowsToNCPPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("migwinncp", "Import linux data to ncp objectstorage", start)
 
 	if !osCheck(logger, start, "windows") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusOK, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusOK, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscImport(logger, start, "ncp", ncpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from Windows to ncp objectstorage", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
 // SQL Database
-func MigrationMySQLGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migmysql")
-	logger.Info("migmysql get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-MySQL",
-		"error":   nil,
-		"os":      runtime.GOOS,
-	})
-}
 
 func MigrationMySQLPostHandler(ctx echo.Context) error {
 
@@ -394,26 +308,26 @@ func MigrationMySQLPostHandler(ctx echo.Context) error {
 
 	formdata := MigrationMySQLForm{}
 	if !getDataWithBind(logger, start, ctx, &formdata) {
-		return ctx.JSON(http.StatusOK, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusOK, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	params := GetMigrationParamsFormFormData(formdata)
 
 	srdbc := getMysqlRDBC(logger, start, "smig", params)
 	if srdbc == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	trdbc := getMysqlRDBC(logger, start, "tmig", params)
 	if trdbc == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -422,16 +336,16 @@ func MigrationMySQLPostHandler(ctx echo.Context) error {
 		logger.Errorf("RDBController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusOK, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusOK, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// mysql migration success result send to client
 	jobEnd(logger, "Successfully migrated data from mysql to mysql", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
diff --git a/websrc/controllers/migrationNCPHandlers.go b/websrc/controllers/migrationNCPHandlers.go
index 17ef0b2..eaf417d 100644
--- a/websrc/controllers/migrationNCPHandlers.go
+++ b/websrc/controllers/migrationNCPHandlers.go
@@ -3,27 +3,15 @@ package controllers
 import (
 	"net/http"
 	"os"
-	"path/filepath"
-	"runtime"
 	"time"
 
+	"github.com/cloud-barista/cm-data-mold/websrc/models"
 	"github.com/labstack/echo/v4"
 )
 
 // Object Storage
 
 // FROM Naver Object Storage
-func MigrationNCPToLinuxGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migncplin")
-	logger.Info("migncplin get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-NCP-Linux",
-		"Regions": GetNCPRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
-	})
-}
 
 func MigrationNCPToLinuxPostHandler(ctx echo.Context) error {
 
@@ -32,53 +20,39 @@ func MigrationNCPToLinuxPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("migncplin", "Export ncp data to linux", start)
 
 	if !osCheck(logger, start, "linux") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscExport(logger, start, "ncp", ncpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Successfully migrated data from ncp objectstorage to linux", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationNCPToWindowsGetHandler(ctx echo.Context) error {
-	tmpPath := filepath.Join(os.TempDir(), "dummy")
-
-	logger := getLogger("migncpwin")
-	logger.Info("migncpwin get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-NCP-Windows",
-		"Regions": GetNCPRegions(),
-		"os":      runtime.GOOS,
-		"tmpPath": tmpPath,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -89,53 +63,40 @@ func MigrationNCPToWindowsPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("migncpwin", "Export ncp data to windows", start)
 
 	if !osCheck(logger, start, "windows") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscExport(logger, start, "ncp", ncpOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from ncp to windows", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationNCPToS3GetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migncps3")
-	logger.Info("migncps3 get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-NCP-S3",
-		"NCPRegions": GetNCPRegions(),
-		"os":         runtime.GOOS,
-		"AWSRegions": GetAWSRegions(),
-		"error":      nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -147,25 +108,25 @@ func MigrationNCPToS3PostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -175,30 +136,17 @@ func MigrationNCPToS3PostHandler(ctx echo.Context) error {
 		logger.Errorf("OSController migration failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from ncp to s3", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationNCPToGCPGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migncpgcp")
-	logger.Info("migncpgcp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-NCP-GCP",
-		"NCPRegions": GetNCPRegions(),
-		"os":         runtime.GOOS,
-		"GCPRegions": GetGCPRegions(),
-		"error":      nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -210,34 +158,34 @@ func MigrationNCPToGCPPostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -247,15 +195,15 @@ func MigrationNCPToGCPPostHandler(ctx echo.Context) error {
 		logger.Errorf("OSController migration failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	jobEnd(logger, "Successfully migrated data from ncp to gcp", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
diff --git a/websrc/controllers/migrationNoSqlHandlers.go b/websrc/controllers/migrationNoSqlHandlers.go
index 75874a2..6fe242f 100644
--- a/websrc/controllers/migrationNoSqlHandlers.go
+++ b/websrc/controllers/migrationNoSqlHandlers.go
@@ -3,27 +3,14 @@ package controllers
 import (
 	"net/http"
 	"os"
-	"runtime"
 	"time"
 
+	"github.com/cloud-barista/cm-data-mold/websrc/models"
 	"github.com/labstack/echo/v4"
 )
 
 // AWS DynamoDB to others
 
-func MigrationDynamoDBToFirestoreGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migDNFS")
-	logger.Info("migDNFS get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-DynamoDB-Firestore",
-		"AWSRegions": GetAWSRegions(),
-		"os":         runtime.GOOS,
-		"GCPRegions": GetGCPRegions(),
-		"error":      nil,
-	})
-}
-
 func MigrationDynamoDBToFirestorePostHandler(ctx echo.Context) error {
 
 	start := time.Now()
@@ -32,34 +19,34 @@ func MigrationDynamoDBToFirestorePostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	awsNRDB := getDynamoNRDBC(logger, start, "mig", params)
 	if awsNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	gcpNRDB := getFirestoreNRDBC(logger, start, "mig", params, credFileName)
 	if gcpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -68,29 +55,17 @@ func MigrationDynamoDBToFirestorePostHandler(ctx echo.Context) error {
 		logger.Errorf("NRDBController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from dynamoDB to firestoreDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationDynamoDBToMongoDBGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migDNMG")
-	logger.Info("migDNMG get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-DynamoDB-MongoDB",
-		"Regions": GetAWSRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -101,25 +76,25 @@ func MigrationDynamoDBToMongoDBPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("migDNMG", "Export dynamoDB data to mongoDB", start)
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsNRDB := getDynamoNRDBC(logger, start, "mig", params)
 	if awsNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpNRDB := getMongoNRDBC(logger, start, "mig", params)
 	if ncpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -128,35 +103,22 @@ func MigrationDynamoDBToMongoDBPostHandler(ctx echo.Context) error {
 		logger.Errorf("NRDBController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from dynamoDB to ncp mongoDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
 // Google Cloud Firestore to others
 
-func MigrationFirestoreToDynamoDBGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migFSDN")
-	logger.Info("migFSDN get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-Firestore-DynamoDB",
-		"AWSRegions": GetAWSRegions(),
-		"os":         runtime.GOOS,
-		"GCPRegions": GetGCPRegions(),
-		"error":      nil,
-	})
-}
-
 func MigrationFirestoreToDynamoDBPostHandler(ctx echo.Context) error {
 
 	start := time.Now()
@@ -165,34 +127,34 @@ func MigrationFirestoreToDynamoDBPostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpNRDB := getFirestoreNRDBC(logger, start, "mig", params, credFileName)
 	if gcpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsNRDB := getDynamoNRDBC(logger, start, "mig", params)
 	if awsNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -201,29 +163,17 @@ func MigrationFirestoreToDynamoDBPostHandler(ctx echo.Context) error {
 		logger.Errorf("NRDBController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from firestoreDB to dynamoDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationFirestoreToMongoDBGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migFSMG")
-	logger.Info("migFSMG get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-Firestore-MongoDB",
-		"Regions": GetGCPRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -235,34 +185,34 @@ func MigrationFirestoreToMongoDBPostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpNRDB := getFirestoreNRDBC(logger, start, "mig", params, credFileName)
 	if gcpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpNRDB := getMongoNRDBC(logger, start, "mig", params)
 	if ncpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -271,34 +221,22 @@ func MigrationFirestoreToMongoDBPostHandler(ctx echo.Context) error {
 		logger.Errorf("NRDBController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from firestoreDB to mongoDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
 // Naver Cloud MongoDB to others
 
-func MigrationMongoDBToDynamoDBGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migMGDN")
-	logger.Info("migMGDN get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-MongoDB-DynamoDB",
-		"Regions": GetAWSRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
-	})
-}
-
 func MigrationMongoDBToDynamoDBPostHandler(ctx echo.Context) error {
 
 	start := time.Now()
@@ -307,25 +245,25 @@ func MigrationMongoDBToDynamoDBPostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpNRDB := getMongoNRDBC(logger, start, "mig", params)
 	if ncpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsNRDB := getDynamoNRDBC(logger, start, "mig", params)
 	if awsNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -334,29 +272,17 @@ func MigrationMongoDBToDynamoDBPostHandler(ctx echo.Context) error {
 		logger.Errorf("NRDBController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from mongoDB to dynamoDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationMongoDBToFirestoreGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migMGFS")
-	logger.Info("migMGFS get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-MongoDB-Firestore",
-		"Regions": GetGCPRegions(),
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -368,34 +294,34 @@ func MigrationMongoDBToFirestorePostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	gcpNRDB := getFirestoreNRDBC(logger, start, "mig", params, credFileName)
 	if gcpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpNRDB := getMongoNRDBC(logger, start, "mig", params)
 	if ncpNRDB == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -404,16 +330,16 @@ func MigrationMongoDBToFirestorePostHandler(ctx echo.Context) error {
 		logger.Errorf("NRDBController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from mongoDB to firestoreDB", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
diff --git a/websrc/controllers/migrationS3Handlers.go b/websrc/controllers/migrationS3Handlers.go
index 0f78f14..21774df 100644
--- a/websrc/controllers/migrationS3Handlers.go
+++ b/websrc/controllers/migrationS3Handlers.go
@@ -3,27 +3,15 @@ package controllers
 import (
 	"net/http"
 	"os"
-	"path/filepath"
-	"runtime"
 	"time"
 
+	"github.com/cloud-barista/cm-data-mold/websrc/models"
 	"github.com/labstack/echo/v4"
 )
 
 // Object Storage
 
 // FROM AWS S3
-func MigrationS3ToLinuxGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migs3lin")
-	logger.Info("migs3lin get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-S3-Linux",
-		"Regions": GetAWSRegions(),
-		"error":   nil,
-		"os":      runtime.GOOS,
-	})
-}
 
 func MigrationS3ToLinuxPostHandler(ctx echo.Context) error {
 
@@ -32,54 +20,40 @@ func MigrationS3ToLinuxPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("migs3lin", "Export s3 data to linux", start)
 
 	if !osCheck(logger, start, "linux") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscExport(logger, start, "s3", awsOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from S3 to Linux", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationS3ToWindowsGetHandler(ctx echo.Context) error {
-	tmpPath := filepath.Join(os.TempDir(), "dummy")
-
-	logger := getLogger("migs3win")
-	logger.Info("migs3win get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Migration-S3-Windows",
-		"Regions": GetAWSRegions(),
-		"tmpPath": tmpPath,
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -90,53 +64,40 @@ func MigrationS3ToWindowsPostHandler(ctx echo.Context) error {
 	logger, logstrings := pageLogInit("genlinux", "Export s3 data to windows", start)
 
 	if !osCheck(logger, start, "windows") {
-		return ctx.JSON(http.StatusBadRequest, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusBadRequest, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	if !oscExport(logger, start, "s3", awsOSC, params.Path) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from S3 to Windows", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
-	})
-}
-
-func MigrationS3ToGCPGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migs3gcp")
-	logger.Info("migs3gcp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-S3-GCP",
-		"AWSRegions": GetAWSRegions(),
-		"GCPRegions": GetGCPRegions(),
-		"os":         runtime.GOOS,
-		"error":      nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
@@ -148,34 +109,34 @@ func MigrationS3ToGCPPostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	credTmpDir, credFileName, ok := gcpCreateCredFile(logger, start, ctx)
 	if !ok {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 	defer os.RemoveAll(credTmpDir)
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	gcpOSC := getGCPCOSC(logger, start, "mig", params, credFileName)
 	if gcpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -185,32 +146,20 @@ func MigrationS3ToGCPPostHandler(ctx echo.Context) error {
 		logger.Errorf("OSController migration failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from s3 to gcp", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
 
-func MigrationS3ToNCPGetHandler(ctx echo.Context) error {
-
-	logger := getLogger("migs3ncp")
-	logger.Info("migs3ncp get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content":    "Migration-S3-NCP",
-		"AWSRegions": GetAWSRegions(),
-		"NCPRegions": GetNCPRegions(),
-		"os":         runtime.GOOS,
-		"error":      nil,
-	})
-}
 func MigrationS3ToNCPPostHandler(ctx echo.Context) error {
 
 	start := time.Now()
@@ -219,25 +168,25 @@ func MigrationS3ToNCPPostHandler(ctx echo.Context) error {
 
 	params := MigrationForm{}
 	if !getDataWithBind(logger, start, ctx, &params) {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	awsOSC := getS3OSC(logger, start, "mig", params)
 	if awsOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	ncpOSC := getS3COSC(logger, start, "mig", params)
 	if ncpOSC == nil {
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
@@ -247,16 +196,16 @@ func MigrationS3ToNCPPostHandler(ctx echo.Context) error {
 		logger.Errorf("OSController copy failed : %v", err)
 		logger.Infof("End time : %s", end.Format("2006-01-02T15:04:05-07:00"))
 		logger.Infof("Elapsed time : %s", end.Sub(start).String())
-		return ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
-			"Result": logstrings.String(),
-			"Error":  nil,
+		return ctx.JSON(http.StatusInternalServerError, models.BasicResponse{
+			Result: logstrings.String(),
+			Error:  nil,
 		})
 	}
 
 	// migration success. Send result to client
 	jobEnd(logger, "Successfully migrated data from s3 to ncp", start)
-	return ctx.JSON(http.StatusOK, map[string]interface{}{
-		"Result": logstrings.String(),
-		"Error":  nil,
+	return ctx.JSON(http.StatusOK, models.BasicResponse{
+		Result: logstrings.String(),
+		Error:  nil,
 	})
 }
diff --git a/websrc/controllers/pageHandlers.go b/websrc/controllers/pageHandlers.go
index f84f519..455f9dc 100644
--- a/websrc/controllers/pageHandlers.go
+++ b/websrc/controllers/pageHandlers.go
@@ -6,14 +6,15 @@ import (
 	"path/filepath"
 	"runtime"
 
+	"github.com/cloud-barista/cm-data-mold/websrc/models"
 	"github.com/labstack/echo/v4"
 )
 
 func MainGetHandler(ctx echo.Context) error {
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "main",
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "main",
+		OS:      runtime.GOOS,
+		Error:   nil,
 	})
 }
 
@@ -25,24 +26,23 @@ func GenerateLinuxGetHandler(ctx echo.Context) error {
 	logger := getLogger("genlinux")
 	logger.Info("genlinux get page accessed")
 
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-Linux",
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-Linux",
+		OS:      runtime.GOOS,
+		Error:   nil,
 	})
 }
 
 func GenerateWindowsGetHandler(ctx echo.Context) error {
 
-	tmpPath := filepath.Join(os.TempDir(), "dummy")
+	// tmpPath := filepath.Join(os.TempDir(), "dummy")
 
 	logger := getLogger("genwindows")
 	logger.Info("genwindows get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-Windows",
-		"os":      runtime.GOOS,
-		"tmpPath": tmpPath,
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-Windows",
+		OS:      runtime.GOOS,
+		Error:   nil,
 	})
 }
 
@@ -50,22 +50,22 @@ func GenerateS3GetHandler(ctx echo.Context) error {
 
 	logger := getLogger("genS3")
 	logger.Info("genS3 get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-S3",
-		"os":      runtime.GOOS,
-		"Regions": GetAWSRegions(),
-		"Error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-S3",
+		OS:      runtime.GOOS,
+		Error:   nil,
+		Regions: GetAWSRegions(),
 	})
 }
 
 func GenerateGCPGetHandler(ctx echo.Context) error {
 	logger := getLogger("genGCP")
 	logger.Info("genGCP get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-GCP",
-		"os":      runtime.GOOS,
-		"Regions": GetGCPRegions(),
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-GCP",
+		OS:      runtime.GOOS,
+		Error:   nil,
+		Regions: GetGCPRegions(),
 	})
 }
 
@@ -73,11 +73,11 @@ func GenerateNCPGetHandler(ctx echo.Context) error {
 
 	logger := getLogger("genNCP")
 	logger.Info("genNCP get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-NCP",
-		"os":      runtime.GOOS,
-		"Regions": GetNCPRegions(),
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-NCP",
+		OS:      runtime.GOOS,
+		Error:   nil,
+		Regions: GetNCPRegions(),
 	})
 }
 
@@ -85,41 +85,383 @@ func GenerateMySQLGetHandler(ctx echo.Context) error {
 
 	logger := getLogger("genmysql")
 	logger.Info("genmysql get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-MySQL",
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-MySQL",
+		OS:      runtime.GOOS,
+		Error:   nil,
 	})
 }
 
 func GenerateDynamoDBGetHandler(ctx echo.Context) error {
 	logger := getLogger("gendynamodb")
 	logger.Info("gendynamodb get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-DynamoDB",
-		"os":      runtime.GOOS,
-		"Regions": GetAWSRegions(),
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-DynamoDB",
+		OS:      runtime.GOOS,
+		Error:   nil,
+		Regions: GetAWSRegions(),
 	})
 }
 
 func GenerateFirestoreGetHandler(ctx echo.Context) error {
 	logger := getLogger("genfirestore")
 	logger.Info("genfirestore get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-Firestore",
-		"os":      runtime.GOOS,
-		"Regions": GetGCPRegions(),
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-Firestore",
+		OS:      runtime.GOOS,
+		Error:   nil,
+		Regions: GetGCPRegions(),
 	})
 }
 
 func GenerateMongoDBGetHandler(ctx echo.Context) error {
 	logger := getLogger("genfirestore")
 	logger.Info("genmongodb get page accessed")
-	return ctx.Render(http.StatusOK, "index.html", map[string]interface{}{
-		"Content": "Generate-MongoDB",
-		"os":      runtime.GOOS,
-		"error":   nil,
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Generate-MongoDB",
+		OS:      runtime.GOOS,
+		Error:   nil,
+		Regions: GetNCPRegions(),
+	})
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+// Page handlers related to migration data
+
+// linux to object storage
+
+func MigrationLinuxToS3GetHandler(ctx echo.Context) error {
+	logger := getLogger("miglins3")
+	logger.Info("miglinux get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-Linux-S3",
+		Regions: GetAWSRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+func MigrationLinuxToGCPGetHandler(ctx echo.Context) error {
+	logger := getLogger("miglingcp")
+	logger.Info("miglingcp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-Linux-GCP",
+		Regions: GetGCPRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+func MigrationLinuxToNCPGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("miglinncp")
+	logger.Info("miglinncp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-Linux-NCP",
+		Regions: GetNCPRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+// windows to object storage
+
+func MigrationWindowsToS3GetHandler(ctx echo.Context) error {
+	tmpPath := filepath.Join(os.TempDir(), "dummy")
+	logger := getLogger("migwins3")
+	logger.Info("migwins3 get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-Windows-S3",
+		Regions: GetAWSRegions(),
+		OS:      runtime.GOOS,
+		TmpPath: tmpPath,
+		Error:   nil,
+	})
+
+}
+
+func MigrationWindowsToGCPGetHandler(ctx echo.Context) error {
+	tmpPath := filepath.Join(os.TempDir(), "dummy")
+	logger := getLogger("migwingcp")
+	logger.Info("migwingcp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-Windows-GCP",
+		Regions: GetGCPRegions(),
+		OS:      runtime.GOOS,
+		TmpPath: tmpPath,
+		Error:   nil,
+	})
+}
+
+func MigrationWindowsToNCPGetHandler(ctx echo.Context) error {
+	tmpPath := filepath.Join(os.TempDir(), "dummy")
+
+	logger := getLogger("migwinncp")
+	logger.Info("migwinncp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-Windows-NCP",
+		Regions: GetNCPRegions(),
+		OS:      runtime.GOOS,
+		TmpPath: tmpPath,
+		Error:   nil,
+	})
+}
+
+// mysql migration page
+
+func MigrationMySQLGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migmysql")
+	logger.Info("migmysql get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-MySQL",
+		Error:   nil,
+		OS:      runtime.GOOS,
+	})
+}
+
+// Object Storage
+// AWS to others
+
+func MigrationS3ToLinuxGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migs3lin")
+	logger.Info("migs3lin get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-S3-Linux",
+		Regions: GetAWSRegions(),
+		Error:   nil,
+		OS:      runtime.GOOS,
+	})
+}
+
+func MigrationS3ToWindowsGetHandler(ctx echo.Context) error {
+	tmpPath := filepath.Join(os.TempDir(), "dummy")
+
+	logger := getLogger("migs3win")
+	logger.Info("migs3win get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-S3-Windows",
+		Regions: GetAWSRegions(),
+		TmpPath: tmpPath,
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+func MigrationS3ToGCPGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migs3gcp")
+	logger.Info("migs3gcp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-S3-GCP",
+		AWSRegions: GetAWSRegions(),
+		GCPRegions: GetGCPRegions(),
+		OS:         runtime.GOOS,
+		Error:      nil,
+	})
+}
+
+func MigrationS3ToNCPGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migs3ncp")
+	logger.Info("migs3ncp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-S3-NCP",
+		AWSRegions: GetAWSRegions(),
+		NCPRegions: GetNCPRegions(),
+		OS:         runtime.GOOS,
+		Error:      nil,
+	})
+}
+
+// Object Storage
+// GCP to others
+
+func MigrationGCPToLinuxGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("miggcplin")
+	logger.Info("miggcplin get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-GCP-Linux",
+		OS:      runtime.GOOS,
+		Regions: GetGCPRegions(),
+		Error:   nil,
+	})
+}
+
+func MigrationGCPToWindowsGetHandler(ctx echo.Context) error {
+	tmpPath := filepath.Join(os.TempDir(), "dummy")
+
+	logger := getLogger("miggcpwin")
+	logger.Info("miggcpwin get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-GCP-Windows",
+		OS:      runtime.GOOS,
+		Regions: GetGCPRegions(),
+		TmpPath: tmpPath,
+		Error:   nil,
+	})
+}
+
+func MigrationGCPToS3GetHandler(ctx echo.Context) error {
+
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-GCP-S3",
+		OS:         runtime.GOOS,
+		GCPRegions: GetGCPRegions(),
+		AWSRegions: GetAWSRegions(),
+		Error:      nil,
+	})
+}
+
+func MigrationGCPToNCPGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("miggcpncp")
+	logger.Info("miggcpncp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-GCP-NCP",
+		OS:         runtime.GOOS,
+		GCPRegions: GetGCPRegions(),
+		NCPRegions: GetNCPRegions(),
+		Error:      nil,
+	})
+}
+
+// Object Storage
+// NCP to others
+
+func MigrationNCPToLinuxGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migncplin")
+	logger.Info("migncplin get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-NCP-Linux",
+		Regions: GetNCPRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+func MigrationNCPToWindowsGetHandler(ctx echo.Context) error {
+	tmpPath := filepath.Join(os.TempDir(), "dummy")
+
+	logger := getLogger("migncpwin")
+	logger.Info("migncpwin get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-NCP-Windows",
+		Regions: GetNCPRegions(),
+		OS:      runtime.GOOS,
+		TmpPath: tmpPath,
+		Error:   nil,
+	})
+}
+
+func MigrationNCPToS3GetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migncps3")
+	logger.Info("migncps3 get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-NCP-S3",
+		NCPRegions: GetNCPRegions(),
+		OS:         runtime.GOOS,
+		AWSRegions: GetAWSRegions(),
+		Error:      nil,
+	})
+}
+
+func MigrationNCPToGCPGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migncpgcp")
+	logger.Info("migncpgcp get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-NCP-GCP",
+		NCPRegions: GetNCPRegions(),
+		OS:         runtime.GOOS,
+		GCPRegions: GetGCPRegions(),
+		Error:      nil,
+	})
+}
+
+// No-SQL
+// AWS DynamoDB to others
+
+func MigrationDynamoDBToFirestoreGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migDNFS")
+	logger.Info("migDNFS get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-DynamoDB-Firestore",
+		AWSRegions: GetAWSRegions(),
+		OS:         runtime.GOOS,
+		GCPRegions: GetGCPRegions(),
+		Error:      nil,
+	})
+}
+
+func MigrationDynamoDBToMongoDBGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migDNMG")
+	logger.Info("migDNMG get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-DynamoDB-MongoDB",
+		Regions: GetAWSRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+// No-SQL
+// GCP Firestore to others
+
+func MigrationFirestoreToDynamoDBGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migFSDN")
+	logger.Info("migFSDN get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content:    "Migration-Firestore-DynamoDB",
+		AWSRegions: GetAWSRegions(),
+		OS:         runtime.GOOS,
+		GCPRegions: GetGCPRegions(),
+		Error:      nil,
+	})
+}
+
+func MigrationFirestoreToMongoDBGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migFSMG")
+	logger.Info("migFSMG get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-Firestore-MongoDB",
+		Regions: GetGCPRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+// No-SQL
+// NCP MongoDB to others
+
+func MigrationMongoDBToDynamoDBGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migMGDN")
+	logger.Info("migMGDN get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-MongoDB-DynamoDB",
+		Regions: GetAWSRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
+	})
+}
+
+func MigrationMongoDBToFirestoreGetHandler(ctx echo.Context) error {
+
+	logger := getLogger("migMGFS")
+	logger.Info("migMGFS get page accessed")
+	return ctx.Render(http.StatusOK, "index.html", models.BasicPageResponse{
+		Content: "Migration-MongoDB-Firestore",
+		Regions: GetGCPRegions(),
+		OS:      runtime.GOOS,
+		Error:   nil,
 	})
 }
diff --git a/websrc/models/bagicModel.go b/websrc/models/bagicModel.go
new file mode 100644
index 0000000..89ef558
--- /dev/null
+++ b/websrc/models/bagicModel.go
@@ -0,0 +1,18 @@
+package models
+
+type BasicPageResponse struct {
+	Content string  `json:"Content"`
+	Error   *string `json:"Error"`
+	OS      string  `json:"OS"`
+	TmpPath string  `json:"TmpPath"`
+
+	Regions    []string `json:"Regions"`
+	AWSRegions []string `json:"AWSRegions"`
+	GCPRegions []string `json:"GCPRegions"`
+	NCPRegions []string `json:"NCPRegions"`
+}
+
+type BasicResponse struct {
+	Result string  `json:"Result"`
+	Error  *string `json:"Error"`
+}