feat: interact with byte core

@@ -3,9 +3,8 @@ ENV APP_DIR $GOPATH/src/character-library-metadata-bastion
 RUN mkdir -p $APP_DIR
 WORKDIR $APP_DIR/
 COPY ./pkg pkg
-COPY ./conf conf
+COPY ./config config
 COPY ./go.mod go.mod
-COPY ./go.sum go.sum
 COPY ./main.go main.go
 RUN ["ln","-sf","/usr/share/zoneinfo/Asia/Shanghai","/etc/localtime"]
 ENV GO111MODULE on

@@ -135,15 +135,15 @@
 - [x] 校验步骤日志     /log/verified-step-Log
 
 ## 数据预览
-- [ ] 表数据预览（格式）    /table/preview
-- [ ] 表数据自定义查询      /table/preview    where conditions 升序、降序 包含、不包含
-- [ ] 表数据字段可选值搜索   /table/field-optional 文本匹配
-- [ ] 表数据更新、添加、删除 /table/row-data-mutation
-- [ ] 表数据导出           /table/export-table
+- [x] 表数据预览（格式）    /table/preview
+- [x] 表数据自定义查询      /table/preview    where conditions 升序、降序 包含、不包含
+- [x] 表数据字段可选值搜索   /table/field-optional 文本匹配
+- [x] 表数据更新、添加、删除 /table/row-data-mutation
+- [x] 表数据导出           /table/export-table
 
 ## 数据验证
 
-- [] 文件验证  /data/edit-data-table
+- [x] 文件验证  /data/edit-data-table
 
 ## 底层字库接口
 
@@ -155,19 +155,19 @@
   "params": ["产品名2"]
 }
 ```
-- [ ] 数据预览
-- [ ] 表格编辑
-- [ ] 保存校验文件 (文件地址)
-- [ ] 生成主表
-- [ ] 表复制
-- [ ] 追加数据
-- [ ] 表删除 （主表、副表、分表）
-- [ ] 表拆分
-- [ ] 更新表结构（分表）
-- [ ] 编辑、添加、删除表数据（副表）
+- [ ] 数据预览 1
+- [ ] 表格编辑 1
+- [ ] 保存校验文件 (文件地址) 1
+- [ ] 生成主表 1
+- [ ] 表复制 （副表）
+- [ ] 追加数据 （主表、副表）
+- [ ] 表删除 （主表、副表）~~、分表~~
+- [x] ~~表拆分~~
+- [x] ~~更新表结构（分表）~~
+- [ ] 编辑、添加、删除表数据（副表） 1
 - [ ] 取消校验
 
 ## 定时作业
 
-- 隔天清理校验中的文件
-- 隔天清理public临时文件
\ No newline at end of file
+- [x] 隔天清理校验中的文件
+- [x] 隔天清理public临时文件
\ No newline at end of file

@@ -2,7 +2,7 @@ apiVersion: v1
 kind: Service
 metadata:
   name: character-library-metadata-bastion
-  namespace: <replace-your-k8s-namespace>
+  namespace: mmm-suplus-dev
   labels:
     k8s-app: character-library-metadata-bastion
 spec:
@@ -17,7 +17,7 @@ apiVersion: extensions/v1beta1
 kind: Deployment
 metadata:
   name: character-library-metadata-bastion
-  namespace: <replace-your-k8s-namespace>
+  namespace: mmm-suplus-dev
   labels:
     k8s-app: character-library-metadata-bastion
 spec:
@@ -52,12 +52,69 @@ spec:
         - mountPath: /opt/logs
           name: accesslogs
         env:
+        - name: POSTGRESQL_DB_NAME
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresqlalliedcreation.dbname
+        - name: POSTGRESQL_USER
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.user
+        - name: POSTGRESQL_PASSWORD
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.password
+        - name: POSTGRESQL_HOST
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.host
+        - name: POSTGRESQL_PORT
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.port
+        - name: REDIS_HOST
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: redis.ip
+        - name: REDIS_PORT
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: redis.port
+        - name: REDIS_AUTH
+          value: ""
         - name: LOG_LEVEL
           value: "debug"
         - name: ERROR_BASE_CODE
           value: "1"
         - name: ERROR_BASE_CODE_MULTIPLE
-          value: "1000"
+          value: "2000"
+        - name: ENABLE_KAFKA_LOG
+          value: "true"
+        - name: HTTP_PORT
+          value: "8082"
+        - name: SERVICE_ENV
+          value: "dev"
+        - name: METADATA_BASTION_HOST
+          value: "http://character-library-metadata-bastion-dev.fjmaimaimai.com"
+        - name: BYTE_CORE_HOST
+          value: "http://192.168.100.34:8303"
+        - name: STARROCKS_HOST
+          value: "118.178.239.45"
+        - name: STARROCKS_PORT
+          value: "9030"
+        - name: STARROCKS_DB_NAME
+          value: "character_library_standard"
+        - name: STARROCKS_USER
+          value: "root"
+        - name: STARROCKS_PASSWORD
+          value: "eagle1010"
       volumes:
       - name: accesslogs
         emptyDir: {}
\ No newline at end of file

 #!/bin/bash
 export PATH=/root/local/bin:$PATH
-kubectl -n <replace-your-k8s-namespace> get pods | grep -q character-library-metadata-bastion
+kubectl -n mmm-suplus-dev get pods | grep -q character-library-metadata-bastion
 if [ "$?" == "1" ];then
 	kubectl create -f /tmp/dev/character-library-metadata-bastion/character-library-metadata-bastion.yaml --record
-	kubectl -n <replace-your-k8s-namespace> get svc | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get svc | grep -q character-library-metadata-bastion
 	if [ "$?" == "0" ];then
 		echo "character-library-metadata-bastion service install success!"
 	else
 		echo "character-library-metadata-bastion service install fail!"
 	fi
-	kubectl -n <replace-your-k8s-namespace> get pods | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get pods | grep -q character-library-metadata-bastion
 	if [ "$?" == "0" ];then
 		echo "character-library-metadata-bastion deployment install success!"
 	else
@@ -17,24 +17,24 @@ if [ "$?" == "1" ];then
 	fi
 else
 	kubectl delete -f /tmp/dev/character-library-metadata-bastion/character-library-metadata-bastion.yaml
-	kubectl -n <replace-your-k8s-namespace> get svc | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get svc | grep -q character-library-metadata-bastion
 	while [ "$?" == "0" ]
 	do
-	kubectl -n <replace-your-k8s-namespace> get svc | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get svc | grep -q character-library-metadata-bastion
 	done
-	kubectl -n <replace-your-k8s-namespace> get pods | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get pods | grep -q character-library-metadata-bastion
 	while [ "$?" == "0" ]
 	do
-	kubectl -n <replace-your-k8s-namespace> get pods | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get pods | grep -q character-library-metadata-bastion
 	done
 	kubectl create -f /tmp/dev/character-library-metadata-bastion/character-library-metadata-bastion.yaml --record
-	kubectl -n <replace-your-k8s-namespace> get svc | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get svc | grep -q character-library-metadata-bastion
 	if [ "$?" == "0" ];then
 		echo "character-library-metadata-bastion service update success!"
 	else
 		echo "character-library-metadata-bastion service update fail!"
 	fi
-	kubectl -n <replace-your-k8s-namespace> get pods | grep -q character-library-metadata-bastion
+	kubectl -n mmm-suplus-dev get pods | grep -q character-library-metadata-bastion
 	if [ "$?" == "0" ];then
 		echo "character-library-metadata-bastion deployment update success!"
 	else

@@ -5,14 +5,12 @@ go 1.16
 require (
 	github.com/Shopify/sarama v1.30.0 // indirect
 	github.com/ajg/form v1.5.1 // indirect
-	github.com/aswjh/excel v0.0.0-20190302031512-353c59e41f09
 	github.com/beego/beego/v2 v2.0.1
 	github.com/bwmarrin/snowflake v0.3.0
 	github.com/extrame/xls v0.0.1
 	github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072 // indirect
 	github.com/fatih/structs v1.1.0 // indirect
 	github.com/gavv/httpexpect v2.0.0+incompatible
-	github.com/go-ole/go-ole v1.2.4 // indirect
 	github.com/go-pg/pg/v10 v10.10.6
 	github.com/go-redis/redis v6.15.9+incompatible
 	github.com/google/go-cmp v0.5.7 // indirect

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"github.com/beego/beego/v2/server/web"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/crontab"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/constant"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/redis"
@@ -31,6 +32,9 @@ func main() {
 	if err := starrocks.Init(); err != nil {
 		log.Logger.Error(err.Error())
 	}
+	cron := crontab.NewCrontabService(nil)
+	cron.StartCrontabTask()
+	defer cron.StopCrontabTask()
 
 	time.Sleep(time.Second)
 	log.Logger.Info("Service:" + constant.SERVICE_NAME)

+package crontab
+
+import (
+	"context"
+	"fmt"
+	"github.com/beego/beego/v2/task"
+	"github.com/linmadan/egglib-go/utils/xtime"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/log"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+type CrontabService struct {
+}
+
+func NewCrontabService(options map[string]interface{}) *CrontabService {
+	newCrontabService := &CrontabService{}
+	return newCrontabService
+}
+
+func (crontabService *CrontabService) initTask() {
+	autoRemoveExpiredTemporaryFile := task.NewTask("定时清理过期临时文件记录", "0 10 */1 * * *", AutoRemoveExpiredTemporaryFile)
+	task.AddTask("autoRemoveExpiredTemporaryFile", autoRemoveExpiredTemporaryFile)
+
+	autoRemovePublicDownloadFile := task.NewTask("定时清理缓存文件", "0 20 */1 * * *", AutoRemovePublicDownloadFile)
+	task.AddTask("autoRemovePublicDownloadFile", autoRemovePublicDownloadFile)
+}
+
+func (crontabService *CrontabService) StartCrontabTask() {
+	crontabService.initTask()
+	task.StartTask()
+	log.Logger.Info("crontab start!")
+}
+
+func (crontabService *CrontabService) StopCrontabTask() {
+	task.StopTask()
+	log.Logger.Info("crontab stop!")
+}
+
+func AutoRemoveExpiredTemporaryFile(ctx context.Context) error {
+
+	defer func() {
+		if r := recover(); r != nil {
+			log.Logger.Error(fmt.Sprintf("%v", r), map[string]interface{}{"task": "定时清理过期临时文件记录"})
+		}
+	}()
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return err
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			log.Logger.Error("【定时清理过期临时文件记录】 失败:" + err.Error())
+		}
+		transactionContext.RollbackTransaction()
+	}()
+
+	log.Logger.Debug("【定时清理过期临时文件记录】 启动")
+	end := xtime.New(time.Now()).BeginningOfDay().Add(-time.Hour * 6)
+	begin := end.AddDate(0, 0, -7)
+	fileRepository, _, _ := factory.FastPgFile(transactionContext, 0)
+	_, files, err := fileRepository.Find(map[string]interface{}{"limit": 100, "fileType": domain.TemporaryFile.ToString(), "updatedAtBegin": begin, "updatedAtEnd": end})
+	if err != nil {
+		return err
+	}
+	deleteFileService, _ := factory.CreateDeleteFileService(transactionContext)
+	if err = deleteFileService.DeleteFiles(&domain.Context{
+		OperatorName: "系统",
+	}, files...); err != nil {
+		return err
+	}
+
+	if err = transactionContext.CommitTransaction(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func AutoRemovePublicDownloadFile(ctx context.Context) error {
+	var err error
+	defer func() {
+		if r := recover(); r != nil {
+			log.Logger.Error(fmt.Sprintf("%v", r), map[string]interface{}{"task": "定时清理缓存文件"})
+		}
+	}()
+	defer func() {
+		if err != nil {
+			log.Logger.Error("【定时清理缓存文件】 失败:" + err.Error())
+		}
+	}()
+	log.Logger.Debug("【定时清理缓存文件】 启动")
+	root := "public"
+	end := xtime.New(time.Now()).BeginningOfDay().AddDate(0, 0, -1)
+	err = filepath.Walk(root, func(path string, info fs.FileInfo, err error) error {
+		t := info.ModTime()
+		if !info.IsDir() && xtime.Before(t, end) {
+			err = os.Remove(path)
+			if err != nil {
+				return err
+			}
+			log.Logger.Info(fmt.Sprintf("[%v] 删除文件:%v 大小:%v 路径:%v 文件创建时间:%v", "系统", info.Name(), info.Size(), path, info.ModTime()))
+			return nil
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}

@@ -53,6 +53,10 @@ func CreateAppendDataToTableService(transactionContext application.TransactionCo
 	return domainService.NewAppendDataToTableService(transactionContext.(*pg.TransactionContext))
 }
 
+func CreateTableEditDataService(transactionContext application.TransactionContext) (domain.TableEditDataService, error) {
+	return domainService.NewTableEditDataService(transactionContext.(*pg.TransactionContext))
+}
+
 // 字库核心
 func CreateByteCoreService(transactionContext application.TransactionContext) (bytecore.ByteLibService, error) {
 	return domainService.ByteCore, nil

@@ -10,14 +10,26 @@ import (
 )
 
 type EditDataTableCommand struct {
-	// 文件ID
-	FileId int `cname:"文件ID" json:"fileId" valid:"Required"`
-
-	Fields []*domain.Field
+	//// 文件ID
+	//FileId int `cname:"文件ID" json:"fileId" valid:"Required"`
+	//
+	//Fields []*domain.Field
+	domain.EditTableRequest
 }
 
 func (editDataTableCommand *EditDataTableCommand) Valid(validation *validation.Validation) {
-
+	if len(editDataTableCommand.ProcessFields) == 0 {
+		validation.Error("未选择操作列")
+		return
+	}
+	if len(editDataTableCommand.Action) == 0 {
+		validation.Error("未知操作类型:" + editDataTableCommand.Action)
+		return
+	}
+	if editDataTableCommand.FileId == 0 {
+		validation.Error("文件ID不能为空")
+		return
+	}
 }
 
 func (editDataTableCommand *EditDataTableCommand) ValidateCommand() error {

@@ -11,11 +11,8 @@ import (
 
 type LoadDataTableCommand struct {
 	// 文件ID
-	FileId int `cname:"文件ID" json:"objectId" valid:"Required"`
-	// 页号
-	//PageNumber int `cname:"页号" json:"pageNumber"`
-	// 页号
-	//PageSize int `cname:"数量" json:"pageSize"`
+	FileId int             `cname:"文件ID" json:"objectId" valid:"Required"`
+	Fields []*domain.Field `json:"fields"`
 	domain.Where
 }
 

@@ -24,7 +24,7 @@ func (fileService *FileService) FilePreview(ctx *domain.Context, loadDataTableCo
 	}()
 
 	loadDataTableService, _ := factory.CreateLoadDataTableService(transactionContext)
-	data, err := loadDataTableService.Preview(ctx, loadDataTableCommand.FileId, loadDataTableCommand.Where)
+	data, err := loadDataTableService.Preview(ctx, loadDataTableCommand.FileId, loadDataTableCommand.Fields, loadDataTableCommand.Where)
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
@@ -53,6 +53,11 @@ func (fileService *FileService) EditDataTable(ctx *domain.Context, editDataTable
 		transactionContext.RollbackTransaction()
 	}()
 
+	editDataTableService, _ := factory.CreateEditDataTableService(transactionContext)
+	_, err = editDataTableService.Edit(ctx, editDataTableCommand.EditTableRequest)
+	if err != nil {
+		return nil, factory.FastError(err)
+	}
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}

@@ -12,21 +12,23 @@ type MappingRuleDto struct {
 	// 文件ID
 	FileId int `json:"fileId"`
 	// 主表列
-	MainTableFields []*domain.Field `json:"mainTableFields"`
+	MainTableFields []*domain.Field `json:"mainTableFields,omitempty"`
 	// 校验文件列
-	VerifiedFileFields []*domain.Field `json:"verifiedFileFields"`
+	VerifiedFileFields []*domain.Field `json:"verifiedFileFields,omitempty"`
 	// 校验文件列
-	MappingFields []*domain.MappingField `json:"mappingFields"`
+	MappingFields []*domain.MappingField `json:"mappingFields,omitempty"`
 }
 
-func (d *MappingRuleDto) Load(m *domain.MappingRule) {
+func (d *MappingRuleDto) Load(m *domain.MappingRule, detail bool) {
 	d.MappingRuleId = m.MappingRuleId
 	d.Name = m.Name
 	d.TableId = m.TableId
 	d.FileId = m.FileId
-	d.MainTableFields = m.MainTableFields
-	d.VerifiedFileFields = m.VerifiedFileFields
-	d.MappingFields = m.MappingFields
+	if detail {
+		d.MainTableFields = m.MainTableFields
+		d.VerifiedFileFields = m.VerifiedFileFields
+		d.MappingFields = m.MappingFields
+	}
 }
 
 func (d *MappingRuleDto) LoadFromTableAndFile(m *domain.Table, f *domain.File, fm *domain.Table) {

@@ -14,7 +14,7 @@ type GetMappingRuleQuery struct {
 }
 
 func (getMappingRuleQuery *GetMappingRuleQuery) Valid(validation *validation.Validation) {
-	validation.SetError("CustomValid", "未实现的自定义认证")
+	//validation.SetError("CustomValid", "未实现的自定义认证")
 }
 
 func (getMappingRuleQuery *GetMappingRuleQuery) ValidateQuery() error {

@@ -62,6 +62,12 @@ func (mappingRuleService *MappingRuleService) CreateMappingRule(ctx *domain.Cont
 		UpdatedAt:          time.Now(),
 		Context:            ctx,
 	}
+
+	// 使用默认匹配
+	if len(cmd.MappingFields) == 0 {
+		newMappingRule.MappingFields = domain.NewMappingFields(mainTable.Fields(false), fileTable.Fields(false))
+	}
+
 	if newMappingRule, err = mappingRuleRepository.Save(newMappingRule); err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
@@ -69,7 +75,10 @@ func (mappingRuleService *MappingRuleService) CreateMappingRule(ctx *domain.Cont
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
-	return struct{}{}, nil
+
+	result := &dto.MappingRuleDto{}
+	result.Load(newMappingRule, true)
+	return result, nil
 }
 
 // 返回匹配规则服务
@@ -91,11 +100,13 @@ func (mappingRuleService *MappingRuleService) GetMappingRule(getMappingRuleQuery
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
+	result := &dto.MappingRuleDto{}
+	result.Load(mappingRule, true)
 
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
-	return mappingRule, nil
+	return result, nil
 }
 
 // 返回匹配规则服务列表
@@ -235,7 +246,7 @@ func (mappingRuleService *MappingRuleService) Search(searchCommand *command.Sear
 	var result = make([]*dto.MappingRuleDto, 0)
 	for _, r := range rules {
 		var item = &dto.MappingRuleDto{}
-		item.Load(r)
+		item.Load(r, false)
 		result = append(result, item)
 	}
 

+package command
+
+import (
+	"fmt"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"reflect"
+	"strings"
+
+	"github.com/beego/beego/v2/core/validation"
+)
+
+type RowEditCommand struct {
+	// 表Id
+	TableId int `cname:"表Id" json:"tableId" valid:"Required"`
+	// 数据列
+	UpdateList []*domain.FieldValues `json:"updateList"`
+	RemoveList []*domain.FieldValues `json:"removeList"`
+	AddList    []*domain.FieldValues `json:"addList"`
+	Where      domain.Where          `json:"where"`
+}
+
+func (cmd *RowEditCommand) Valid(validation *validation.Validation) {
+
+}
+
+func (cmd *RowEditCommand) ValidateCommand() error {
+	valid := validation.Validation{}
+	b, err := valid.Valid(cmd)
+	if err != nil {
+		return err
+	}
+	if !b {
+		elem := reflect.TypeOf(cmd).Elem()
+		for _, validErr := range valid.Errors {
+			field, isExist := elem.FieldByName(validErr.Field)
+			if isExist {
+				return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1))
+			} else {
+				return fmt.Errorf(validErr.Message)
+			}
+		}
+	}
+	return nil
+}

@@ -31,4 +31,7 @@ func (d *TableDetailDto) Load(m *domain.Table, mainTable *domain.Table) {
 	}
 	d.Fields = m.Fields(false)
 	d.ManualFields = m.ManualFields
+	if len(d.ManualFields) == 0 {
+		d.ManualFields = make([]*domain.Field, 0)
+	}
 }

+package service
+
+import (
+	"github.com/linmadan/egglib-go/core/application"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/application/table/command"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+)
+
+func (tableService *TableService) RowEdit(ctx *domain.Context, cmd *command.RowEditCommand) (interface{}, error) {
+	if err := cmd.ValidateCommand(); err != nil {
+		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
+	}
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+
+	editDataService, _ := factory.CreateTableEditDataService(transactionContext)
+	_, err = editDataService.RowEdit(ctx, domain.EditDataRequest{
+		TableId:    cmd.TableId,
+		Where:      cmd.Where,
+		UpdateList: cmd.UpdateList,
+		AddList:    cmd.AddList,
+		RemoveList: cmd.RemoveList,
+	})
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if err := transactionContext.CommitTransaction(); err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	return struct{}{}, nil
+}

@@ -17,25 +17,25 @@ type TableService struct {
 }
 
 // 批量编辑分表
-func (tableService *TableService) BatchEditSubTable(batchEditSubTableCommand *command.BatchEditSubTableCommand) (interface{}, error) {
-	if err := batchEditSubTableCommand.ValidateCommand(); err != nil {
-		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
-	}
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-	if err := transactionContext.CommitTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	return nil, nil
-}
+//func (tableService *TableService) BatchEditSubTable(batchEditSubTableCommand *command.BatchEditSubTableCommand) (interface{}, error) {
+//	if err := batchEditSubTableCommand.ValidateCommand(); err != nil {
+//		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
+//	}
+//	transactionContext, err := factory.CreateTransactionContext(nil)
+//	if err != nil {
+//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+//	}
+//	if err := transactionContext.StartTransaction(); err != nil {
+//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+//	}
+//	defer func() {
+//		transactionContext.RollbackTransaction()
+//	}()
+//	if err := transactionContext.CommitTransaction(); err != nil {
+//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+//	}
+//	return nil, nil
+//}
 
 // 表复制
 func (tableService *TableService) CopyDataTable(ctx *domain.Context, cmd *command.CopyDataTableCommand) (interface{}, error) {
@@ -132,6 +132,36 @@ func (tableService *TableService) GetTable(getTableQuery *query.GetTableQuery) (
 	return tableDetailDto, nil
 }
 
+// 返回表服务
+func (tableService *TableService) PrepareSubTable(getTableQuery *query.GetTableQuery) (interface{}, error) {
+	if err := getTableQuery.ValidateQuery(); err != nil {
+		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
+	}
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	_, table, err := factory.FastPgTable(transactionContext, getTableQuery.TableId)
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	tableDetailDto := dto.TableDetailDto{}
+	tableDetailDto.Load(table, table)
+	tableDetailDto.TableType = domain.SubTable.ToString()
+	tableDetailDto.TableId = 0
+	tableDetailDto.ParentId = table.TableId
+	if err := transactionContext.CommitTransaction(); err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	return tableDetailDto, nil
+}
+
 // 返回表服务列表
 func (tableService *TableService) ListTable(listTableQuery *query.ListTableQuery) (interface{}, error) {
 	if err := listTableQuery.ValidateQuery(); err != nil {
@@ -233,25 +263,25 @@ func (tableService *TableService) Search(searchQuery *query.SearchTableQuery) (i
 }
 
 // 表拆分
-func (tableService *TableService) SplitDataTable(splitDataTableCommand *command.SplitDataTableCommand) (interface{}, error) {
-	if err := splitDataTableCommand.ValidateCommand(); err != nil {
-		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
-	}
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-	if err := transactionContext.CommitTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	return nil, nil
-}
+//func (tableService *TableService) SplitDataTable(splitDataTableCommand *command.SplitDataTableCommand) (interface{}, error) {
+//	if err := splitDataTableCommand.ValidateCommand(); err != nil {
+//		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
+//	}
+//	transactionContext, err := factory.CreateTransactionContext(nil)
+//	if err != nil {
+//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+//	}
+//	if err := transactionContext.StartTransaction(); err != nil {
+//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+//	}
+//	defer func() {
+//		transactionContext.RollbackTransaction()
+//	}()
+//	if err := transactionContext.CommitTransaction(); err != nil {
+//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+//	}
+//	return nil, nil
+//}
 
 // 更新表服务
 func (tableService *TableService) UpdateTable(updateTableCommand *command.UpdateTableCommand) (interface{}, error) {
@@ -339,13 +369,16 @@ func (tableService *TableService) AddTableStruct(ctx *domain.Context, cmd *comma
 	}()
 
 	AddTableStructService, _ := factory.CreateAddTableStructService(transactionContext)
-	if _, err := AddTableStructService.AddTableStruct(ctx, cmd.TableId, cmd.Fields, cmd.Name); err != nil {
+	table, err := AddTableStructService.AddTableStruct(ctx, cmd.TableId, cmd.Fields, cmd.Name)
+	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
-	return struct{}{}, nil
+	tableDetailDto := dto.TableDetailDto{}
+	tableDetailDto.Load(table, nil)
+	return tableDetailDto, nil
 }
 
 func NewTableService(options map[string]interface{}) *TableService {

@@ -18,14 +18,11 @@ var PPROF_ON = true
 //天联共创用户模块
 var ALLIED_CREATION_USER_HOST = "http://localhost:8081" //"http://allied-creation-user-dev.fjmaimaimai.com"
 
-//天联共创业务模块
-//var ALLIED_CREATION_COOPERATION_HOST = "http://localhost:8082" // "http://allied-creation-cooperation-dev.fjmaimaimai.com"
-
 var MMM_BYTE_BANK_HOST = "http://220.250.41.79:8301"
 
 var METADATA_BASTION_HOST = "http://127.0.0.1:8080"
 
-var BYTE_CORE_HOST = "http://127.0.0.1:8080"
+var BYTE_CORE_HOST = "http://192.168.100.34:8303"
 
 //var CUSTOMER_ACCOUNT = []int64{3129687560814592, 3129687690100739, 3492238958608384}
 
@@ -41,7 +38,6 @@ func init() {
 	LOG_LEVEL = Configurator.DefaultString("LOG_LEVEL", LOG_LEVEL)
 	//ALLIED_CREATION_BASIC_HOST = Configurator.DefaultString("ALLIED_CREATION_BASIC_HOST", ALLIED_CREATION_BASIC_HOST)
 	ALLIED_CREATION_USER_HOST = Configurator.DefaultString("ALLIED_CREATION_USER_HOST", ALLIED_CREATION_USER_HOST)
-	//ALLIED_CREATION_COOPERATION_HOST = Configurator.DefaultString("ALLIED_CREATION_COOPERATION_HOST", ALLIED_CREATION_COOPERATION_HOST)
 	MMM_BYTE_BANK_HOST = Configurator.DefaultString("MMM_BYTE_BANK_HOST", MMM_BYTE_BANK_HOST)
 	BYTE_CORE_HOST = Configurator.DefaultString("BYTE_CORE_HOST", BYTE_CORE_HOST)
 	SERVICE_ENV = Configurator.DefaultString("SERVICE_ENV", SERVICE_ENV)

-// go:build !local
-//go:build !local
-// +build !local
+//go:build windows
+// +build windows
 
 package constant
 

-// go:build local
-//go:build local
-// +build local
+//go:build linux
+// +build linux
 
 package constant
 

@@ -6,7 +6,7 @@ type ByteLibService interface {
 	LoadDataTable(param ReqLoadDataTable) (*DataLoadDataTable, error)
 	EditTable(param ReqEditDataTable) (*DataEditDataTable, error)
 	SaveTable(param ReqSaveTable) (*DataSaveTable, error)
-	GenerateTable(param ReqGenerateTable) (*DataGenerateTable, error)
+	GenerateTable(ctx *domain.Context, param ReqGenerateTable) (*DataGenerateTable, error)
 	CopyTable(param ReqCopyTable) (*DataCopyTable, error)
 	AppendData(param ReqAppendData) (*DataAppendData, error)
 	DeleteTable(param ReqDeleteTable) (*DataDeleteTable, error)
@@ -16,11 +16,19 @@ type ByteLibService interface {
 
 type (
 	ReqLoadDataTable struct {
-		FileId   int
-		FileName string
-		Url      string
-		Ext      string
+		FileId   int    `json:"file_id"`
+		FileName string `json:"file_name"`
+		Url      string `json:"url"`
+		Ext      string `json:"ext"`
 		domain.Where
+		OriginalTableId     string         `json:"originalTableId"`
+		IsFromOriginalTable bool           `json:"isFromOriginalTable"`
+		TableFileUrl        string         `json:"tableFileUrl"`
+		ColumnSchemas       []ColumnSchema `json:"columnSchemas"`
+		//PageNumber          int                    `json:"pageNumber"`
+		//PageSize            int                    `json:"pageSize"`
+		QueryParameters map[string]interface{} `json:"queryParameters"`
+		SortParameters  map[string]interface{} `json:"sortParameters"`
 	}
 
 	DataLoadDataTable struct {
@@ -79,13 +87,13 @@ func (table DataLoadDataTable) Filter(where domain.Where) *DataLoadDataTable {
 
 type (
 	ReqEditDataTable struct {
-		FileId   int
-		FileName string
-		Url      string
-		Ext      string
-		Fields   []*Field
-		Action   string
-		Params   []interface{}
+		FileId        int                    `json:"fileId"`
+		PageNumber    int                    `json:"pageNumber"`
+		PageSize      int                    `json:"pageSize"`
+		Fields        []*Field               `json:"fields"`
+		ProcessFields []*Field               `json:"processFields"`
+		Action        string                 `json:"action"`
+		Params        map[string]interface{} `json:"params"`
 	}
 
 	DataEditDataTable struct {
@@ -95,6 +103,7 @@ type (
 
 type (
 	ReqSaveTable struct {
+		FileId int
 	}
 
 	DataSaveTable struct {
@@ -104,9 +113,13 @@ type (
 
 type (
 	ReqGenerateTable struct {
+		FileId  int
+		FileUrl string
+		Table   *domain.Table
 	}
 
 	DataGenerateTable struct {
+		TableName string
 	}
 )
 
@@ -149,3 +162,20 @@ type (
 	DataEditTableData struct {
 	}
 )
+
+type ColumnSchema struct {
+	ColumnName string `json:"columnName"`
+	ColumnType string `json:"columnType"`
+}
+
+func ToFields(fields []*domain.Field) []*Field {
+	result := make([]*Field, 0)
+	for _, f := range fields {
+		result = append(result, &Field{
+			Index: f.Index,
+			Name:  f.Name,
+			Type:  f.SQLType,
+		})
+	}
+	return result
+}

@@ -12,6 +12,13 @@ type Where struct {
 	Conditions []Condition `json:"conditions"`
 }
 
+func (w Where) Offset() int {
+	if w.PageNumber == 0 && w.PageSize == 0 {
+		return 0
+	}
+	return (w.PageNumber - 1) * w.PageSize
+}
+
 type Condition struct {
 	Field *Field        `json:"field"`
 	Like  string        `json:"like"`

 package domain
 
 type FileTableService interface {
-	Preview(ctx *Context, fileId int, where Where) (interface{}, error)
+	Preview(ctx *Context, fileId int, fields []*Field, where Where) (interface{}, error)
 	Edit()
 	Flush(ctx *Context, fileId int, table *Table) (interface{}, error)
 	DeleteFiles(ctx *Context, files ...*File) error
@@ -18,11 +18,13 @@ type TableService interface {
 }
 
 type PreviewDataTableService interface {
-	Preview(ctx *Context, fileId int, where Where) (interface{}, error)
+	Preview(ctx *Context, fileId int, fields []*Field, where Where) (interface{}, error)
 	GetFileId() int
 }
 
-type EditDataTableService interface{}
+type EditDataTableService interface {
+	Edit(ctx *Context, param EditTableRequest) (interface{}, error)
+}
 
 type FlushDataTableService interface {
 	Flush(ctx *Context, fileId int, table *Table) (interface{}, error)
@@ -56,5 +58,25 @@ type UpdateTableStructService interface {
 }
 
 type AddTableStructService interface {
-	AddTableStruct(ctx *Context, parentTableId int, fields []*Field, name string) (interface{}, error)
+	AddTableStruct(ctx *Context, parentTableId int, fields []*Field, name string) (*Table, error)
+}
+
+type EditTableRequest struct {
+	FileId        int                    `json:"objectId"`
+	Fields        []*Field               `json:"fields"`
+	ProcessFields []*Field               `json:"processFields"`
+	Where         Where                  `json:"where"`
+	Action        string                 `json:"action"`
+	Params        map[string]interface{} `json:"params"`
+}
+
+type TableEditDataService interface {
+	RowEdit(ctx *Context, request EditDataRequest) (interface{}, error)
+}
+type EditDataRequest struct {
+	TableId    int            `json:"tableId"`
+	UpdateList []*FieldValues `json:"updateList"`
+	RemoveList []*FieldValues `json:"removeList"`
+	AddList    []*FieldValues `json:"addList"`
+	Where      Where          `json:"where"`
 }

@@ -19,6 +19,8 @@ var (
 	DeleteTable       OperationType = "DeleteTable"       // 表删除
 	FileUpload        OperationType = "FileUpload"        // 文件上传
 	FileVerify        OperationType = "FileVerify"        // 文件校验
+
+	ExcelTableEdit OperationType = "ExcelTableEdit" // 文档表格编辑
 )
 
 var OperationTypeMap = map[string]string{
@@ -31,6 +33,7 @@ var OperationTypeMap = map[string]string{
 	DeleteTable.ToString():       "表删除",
 	FileUpload.ToString():        "文件上传",
 	FileVerify.ToString():        "文件校验",
+	ExcelTableEdit.ToString():    "文档表格编辑",
 }
 
 var (
@@ -72,11 +75,11 @@ var (
 )
 
 var (
-	String   SQLType = "string"
-	Int      SQLType = "int"
-	Float    SQLType = "float"
-	Date     SQLType = "date"
-	Datetime SQLType = "datetime"
+	String   SQLType = "STRING"
+	Int      SQLType = "INT"
+	Float    SQLType = "FLOAT"
+	Date     SQLType = "DATE"
+	Datetime SQLType = "DATETIME"
 )
 
 var SQLTypeMap = map[string]string{

 package domain
 
-import "fmt"
+import (
+	"fmt"
+	"github.com/linmadan/egglib-go/utils/xtime"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/utils"
+	"strings"
+)
 
 // Field 字段
 type Field struct {
@@ -21,7 +26,7 @@ type Field struct {
 }
 
 func (f *Field) Valid() error {
-	if _, ok := SQLTypeMap[f.SQLType]; !ok {
+	if _, ok := SQLTypeMap[strings.ToUpper(f.SQLType)]; !ok {
 		return fmt.Errorf("unknown sql type:%v", f.SQLType)
 	}
 	if f.Index == 0 && f.Flag == ManualField {
@@ -97,3 +102,66 @@ func FieldsChange(oldFields []*Field, newFields []*Field) (reserve []*Field, del
 	}
 	return
 }
+
+type FieldValues struct {
+	Number      int           `json:"number"`
+	FieldValues []*FieldValue `json:"fieldValues"`
+}
+
+func (f *FieldValues) Valid() error {
+	for _, item := range f.FieldValues {
+		if err := item.Valid(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type FieldValue struct {
+	*Field
+	// 字段值(当前)
+	Value string `json:"value,omitempty"`
+	// 字段值(旧的,更新时有效)
+	OldValue string `json:"oldValue,omitempty"`
+
+	typeValue interface{}
+}
+
+func (f *FieldValue) CheckValue() error {
+	val, err := ValueToType(f.Value, f.SQLType)
+	if err != nil {
+		return err
+	}
+	f.typeValue = val
+	return nil
+}
+
+func (f *FieldValue) TypeValue() interface{} {
+	if f.typeValue == nil {
+		f.typeValue, _ = ValueToType(f.Value, f.SQLType)
+	}
+	return f.typeValue
+}
+
+func ValueToType(value string, sqlType string) (interface{}, error) {
+	var toTypeVal interface{}
+	var err error
+	numberString := utils.NewNumberString(value)
+	switch sqlType {
+	case String.ToString():
+		toTypeVal = value
+	case Int.ToString():
+		toTypeVal, err = numberString.Int()
+	case Float.ToString():
+		toTypeVal, err = numberString.Float64()
+	case Date.ToString():
+		toTypeVal, err = xtime.Parse(value)
+		return nil, nil
+	case Datetime.ToString():
+		toTypeVal, err = xtime.Parse(value)
+		return nil, nil
+	default:
+		return nil, fmt.Errorf("unknow sql type :%v", sqlType)
+	}
+	return toTypeVal, err
+}

@@ -44,6 +44,16 @@ func (file *File) Identify() interface{} {
 	return file.FileId
 }
 
+func (file *File) UpdateFileUrl(url string) {
+	if len(url) == 0 {
+		return
+	}
+	if url == file.FileInfo.Url {
+		return
+	}
+	file.FileInfo.Url = url
+}
+
 func (file *File) Update(data map[string]interface{}) error {
 	return nil
 }

@@ -74,7 +74,7 @@ func (gateway BaseServiceGateway) FastDoRequest(url, method string, param interf
 			result = err.Error()
 		}
 		if gateway.Interceptor != nil {
-			gateway.Interceptor(fmt.Sprintf("%v | %v | %v : %v \n request:%v \n response:%v", time.Since(begin), url, strings.ToUpper(method),
+			gateway.Interceptor(fmt.Sprintf("【网关】%v | %v | %v : %v \nRequest:%v \nResponse:%v", time.Since(begin), url, strings.ToUpper(method),
 				result,
 				string(jsonParam),
 				string(jsonData),

 package bytelib
 
 import (
+	"fmt"
+	"github.com/beego/beego/v2/core/logs"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain/bytecore"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/api"
-	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/log"
 	"time"
 )
 
@@ -18,7 +19,8 @@ func NewApiByteLib(host string) *ApiByteLib {
 	gt.ConnectTimeout = 10 * time.Second
 	gt.ReadWriteTimeout = 10 * time.Second
 	gt.Interceptor = func(msg string) {
-		log.Logger.Info(msg)
+		//log.Logger.Info(msg)
+		logs.Debug(msg)
 	}
 	return &ApiByteLib{
 		BaseServiceGateway: gt,
@@ -28,43 +30,68 @@ func NewApiByteLib(host string) *ApiByteLib {
 // 加载数据
 
 func (gateway ApiByteLib) LoadDataTable(param bytecore.ReqLoadDataTable) (*bytecore.DataLoadDataTable, error) {
-	return nil, nil
+	url := gateway.Host() + "/checkout-tables/query"
+	method := "post"
+	var data DataCheckoutTables
+	request := NewRequestCheckoutTablesQuery(param)
+	err := gateway.FastDoRequest(url, method, request, &data)
+	if err != nil {
+		return nil, err
+	}
+
+	response := ToDataLoadDataTable(data)
+	return response, nil
 }
 
 // EditTable 编辑表格
 func (gateway ApiByteLib) EditTable(param bytecore.ReqEditDataTable) (*bytecore.DataEditDataTable, error) {
-	url := gateway.Host() + "/table/edit"
+	url := gateway.Host() + "/checkout-tables/pre-proccess"
 	method := "post"
-	var data bytecore.DataEditDataTable
-	err := gateway.FastDoRequest(url, method, param, &data)
+	var data DataCheckoutTables
+	request := NewRequestCheckoutTablesPreProccess(param)
+	err := gateway.FastDoRequest(url, method, request, &data)
 	if err != nil {
 		return nil, err
 	}
-	return &data, nil
+
+	response := ToDataLoadDataTable(data)
+	return &bytecore.DataEditDataTable{
+		DataLoadDataTable: *response,
+	}, nil
 }
 
 // SaveTable 保存校验文件 (文件地址)
 func (gateway ApiByteLib) SaveTable(param bytecore.ReqSaveTable) (*bytecore.DataSaveTable, error) {
-	url := gateway.Host() + "/table/save"
+	url := gateway.Host() + "/checkout-tables/save"
 	method := "post"
-	var data bytecore.DataSaveTable
-	err := gateway.FastDoRequest(url, method, param, &data)
+	var data ResponseCheckoutTablesSave
+	var request = RequestCheckoutTablesSave{
+		OriginalTableId: fmt.Sprintf("%v", param.FileId),
+	}
+	err := gateway.FastDoRequest(url, method, request, &data)
 	if err != nil {
 		return nil, err
 	}
-	return &data, nil
+	var response = &bytecore.DataSaveTable{
+		Url: data.CheckoutTableUrl,
+	}
+	return response, nil
 }
 
 // GenerateTable 生成主表
 func (gateway ApiByteLib) GenerateTable(param bytecore.ReqGenerateTable) (*bytecore.DataGenerateTable, error) {
-	url := gateway.Host() + "/table/generate"
+	url := gateway.Host() + "/checkout-tables/generate-master-table"
 	method := "post"
-	var data bytecore.DataGenerateTable
-	err := gateway.FastDoRequest(url, method, param, &data)
+	var data DataCheckoutTablesGenerateMasterTable
+	request := NewRequestCheckoutTablesGenerateMasterTable(param)
+	err := gateway.FastDoRequest(url, method, request, &data)
 	if err != nil {
 		return nil, err
 	}
-	return &data, nil
+	var response = bytecore.DataGenerateTable{
+		TableName: data.MasterTableName,
+	}
+	return &response, nil
 }
 
 // CopyTable 表复制

+package bytelib
+
+import (
+	"fmt"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain/bytecore"
+)
+
+type RequestCheckoutTablesQuery struct {
+	OriginalTableId     string                  `json:"originalTableId"`
+	IsFromOriginalTable bool                    `json:"isFromOriginalTable"`
+	TableFileUrl        string                  `json:"tableFileUrl"`
+	ColumnSchemas       []bytecore.ColumnSchema `json:"columnSchemas"`
+	PageNumber          int                     `json:"pageNumber"`
+	PageSize            int                     `json:"pageSize"`
+	QueryParameters     map[string]interface{}  `json:"queryParameters"`
+	SortParameters      map[string]interface{}  `json:"sortParameters"`
+}
+
+type DataCheckoutTables struct {
+	OriginalTableId         string                  `json:"originalTableId"`
+	ColumnSchemas           []bytecore.ColumnSchema `json:"columnSchemas"`
+	PageNumber              int                     `json:"pageNumber"`
+	PageSize                int                     `json:"pageSize"`
+	DataCount               int                     `json:"dataCount"`
+	ShowData                [][]string              `json:"showData"`
+	AbnormalProccessIndexes [][]interface{}         `json:"abnormalProccessIndexes"`
+}
+
+func NewRequestCheckoutTablesQuery(param bytecore.ReqLoadDataTable) RequestCheckoutTablesQuery {
+	return RequestCheckoutTablesQuery{
+		OriginalTableId:     param.OriginalTableId,
+		IsFromOriginalTable: param.IsFromOriginalTable,
+		TableFileUrl:        param.TableFileUrl,
+		ColumnSchemas:       param.ColumnSchemas,
+		PageNumber:          param.PageNumber,
+		PageSize:            param.PageSize,
+		QueryParameters:     param.QueryParameters,
+		SortParameters:      param.SortParameters,
+	}
+}
+
+type RequestCheckoutTablesPreProccess struct {
+	OriginalTableId                  string                  `json:"originalTableId"`
+	ColumnSchemas                    []bytecore.ColumnSchema `json:"columnSchemas"`
+	PreProccessColumnNames           []string                `json:"preProccessColumnNames"`
+	PreProccessActionName            string                  `json:"preProccessActionName"`
+	PreProccessActionParameterValues map[string]string       `json:"preProccessActionParameterValues"`
+	PageNumber                       int                     `json:"pageNumber"`
+	PageSize                         int                     `json:"pageSize"`
+	QueryParameters                  map[string]interface{}  `json:"queryParameters"`
+	SortParameters                   map[string]interface{}  `json:"sortParameters"`
+}
+
+func NewRequestCheckoutTablesPreProccess(param bytecore.ReqEditDataTable) RequestCheckoutTablesPreProccess {
+	req := RequestCheckoutTablesPreProccess{
+		OriginalTableId:                  fmt.Sprintf("%v", param.FileId),
+		ColumnSchemas:                    FieldsToColumnSchemas(param.Fields),
+		PreProccessActionName:            param.Action,
+		PreProccessActionParameterValues: make(map[string]string),
+		PageNumber:                       param.PageNumber,
+		PageSize:                         param.PageSize,
+		QueryParameters:                  make(map[string]interface{}),
+		SortParameters:                   make(map[string]interface{}),
+	}
+
+	for _, v := range param.ProcessFields {
+		req.PreProccessColumnNames = append(req.PreProccessColumnNames, v.Name)
+	}
+
+	return req
+}
+
+type RequestCheckoutTablesSave struct {
+	OriginalTableId string `json:"originalTableId"`
+}
+
+type ResponseCheckoutTablesSave struct {
+	CheckoutTableUrl string `json:"checkoutTableUrl"`
+}
+
+func FieldsToColumnSchemas(fields []*bytecore.Field) []bytecore.ColumnSchema {
+	result := make([]bytecore.ColumnSchema, 0)
+
+	for _, f := range fields {
+		result = append(result, bytecore.ColumnSchema{
+			ColumnName: f.Name,
+			ColumnType: f.Type,
+		})
+	}
+	return result
+}
+
+func DomainFieldsToColumnSchemas(fields []*domain.Field) []bytecore.ColumnSchema {
+	result := make([]bytecore.ColumnSchema, 0)
+
+	for _, f := range fields {
+		result = append(result, bytecore.ColumnSchema{
+			ColumnName: f.Name,
+			ColumnType: f.SQLType,
+		})
+	}
+	return result
+}
+
+func ToDataLoadDataTable(data DataCheckoutTables) *bytecore.DataLoadDataTable {
+	response := &bytecore.DataLoadDataTable{
+		PageNumber: data.PageNumber,
+		Data:       data.ShowData,
+		Total:      data.DataCount,
+	}
+	for i, f := range data.ColumnSchemas {
+		response.Fields = append(response.Fields, &bytecore.Field{
+			Index: i + 1,
+			Name:  f.ColumnName,
+			Type:  f.ColumnType,
+		})
+	}
+	return response
+}
+
+type (
+	RequestCheckoutTablesGenerateMasterTable struct {
+		OriginalTableId      string                  `json:"originalTableId"`
+		CheckoutTableFileUrl string                  `json:"checkoutTableFileUrl"`
+		ColumnSchemas        []bytecore.ColumnSchema `json:"columnSchemas"`
+		MasterTableName      string                  `json:"masterTableName"`
+		FieldSchemas         []FieldSchema           `json:"fieldSchemas"`
+		KeyFieldEnNames      []string                `json:"keyFieldEnNames"`
+	}
+	DataCheckoutTablesGenerateMasterTable struct {
+		MasterTableName string `json:"masterTableName"`
+	}
+	FieldSchema struct {
+		FieldZhName      string `json:"fieldZhName"`
+		FieldEnName      string `json:"fieldEnName"`
+		FieldType        string `json:"fieldType"`
+		FieldDescription string `json:"fieldDescription"`
+		IsAllowNull      bool   `json:"isAllowNull"`
+	}
+)
+
+func NewRequestCheckoutTablesGenerateMasterTable(param bytecore.ReqGenerateTable) RequestCheckoutTablesGenerateMasterTable {
+	request := RequestCheckoutTablesGenerateMasterTable{
+		OriginalTableId:      fmt.Sprintf("%v", param.FileId),
+		CheckoutTableFileUrl: param.FileUrl,
+		ColumnSchemas:        DomainFieldsToColumnSchemas(param.Table.DataFields),
+		MasterTableName:      param.Table.SQLName,
+		FieldSchemas:         ToFieldSchemas(param.Table.DataFields),
+		KeyFieldEnNames:      []string{param.Table.PK.SQLName},
+	}
+	return request
+}
+
+func ToFieldSchemas(fields []*domain.Field) []FieldSchema {
+	result := make([]FieldSchema, 0)
+	for _, f := range fields {
+		result = append(result, FieldSchema{
+			FieldZhName:      f.Name,
+			FieldEnName:      f.SQLName,
+			FieldType:        f.SQLType,
+			FieldDescription: f.Description,
+			IsAllowNull:      false,
+		})
+	}
+	return result
+}
+
+func ToFieldSchemaEnNames(fields []*domain.Field) []string {
+	result := make([]string, 0)
+	for _, f := range fields {
+		result = append(result, f.SQLName)
+	}
+	return result
+}

 package api
 
+import "fmt"
+
 var (
 	JsonUnMarshError int = 1000
 )
@@ -10,7 +12,7 @@ type ErrCodeMsg struct {
 }
 
 func (e ErrCodeMsg) Error() string {
-	return e.Msg
+	return fmt.Sprintf("错误码:%v 错误信息:%v", e.Code, e.Msg)
 }
 
 func NewErrCodeMsg(code int, msg string) ErrCodeMsg {

@@ -3,8 +3,10 @@ package domainService
 import (
 	"bytes"
 	"github.com/beego/beego/v2/client/httplib"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/constant"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain/bytecore"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/api/bytelib"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/excel"
 )
 
@@ -12,7 +14,7 @@ type ByteCoreService struct {
 	TempDataTable map[int]*bytecore.DataLoadDataTable
 }
 
-var ByteCore = &ByteCoreService{} //bytecore.ByteLibService
+var ByteCore bytecore.ByteLibService = &WrapByteCoreService{} //&ByteCoreService{}
 
 var _ bytecore.ByteLibService = (*ByteCoreService)(nil)
 
@@ -51,7 +53,8 @@ func (ptr *ByteCoreService) LoadDataTable(param bytecore.ReqLoadDataTable) (*byt
 }
 
 func (ptr *ByteCoreService) EditTable(param bytecore.ReqEditDataTable) (*bytecore.DataEditDataTable, error) {
-	return nil, nil
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.EditTable(param)
 }
 
 func (ptr *ByteCoreService) save(fileId int, dataTable *bytecore.DataLoadDataTable) {
@@ -80,37 +83,57 @@ func columnToField(cols []string) []*bytecore.Field {
 }
 
 func (ptr *ByteCoreService) SaveTable(param bytecore.ReqSaveTable) (*bytecore.DataSaveTable, error) {
-	return nil, nil
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.SaveTable(param)
 }
 
-func (ptr *ByteCoreService) GenerateTable(param bytecore.ReqGenerateTable) (*bytecore.DataGenerateTable, error) {
-	return nil, nil
+func (ptr *ByteCoreService) GenerateTable(ctx *domain.Context, param bytecore.ReqGenerateTable) (*bytecore.DataGenerateTable, error) {
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.GenerateTable(param)
 }
 
 func (ptr *ByteCoreService) CopyTable(param bytecore.ReqCopyTable) (*bytecore.DataCopyTable, error) {
-	return nil, nil
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.CopyTable(param)
 }
 
 func (ptr *ByteCoreService) AppendData(param bytecore.ReqAppendData) (*bytecore.DataAppendData, error) {
-	return nil, nil
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.AppendData(param)
 }
 
 func (ptr *ByteCoreService) DeleteTable(param bytecore.ReqDeleteTable) (*bytecore.DataDeleteTable, error) {
-	return nil, nil
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.DeleteTable(param)
 }
 
 func (ptr *ByteCoreService) CancelFile(param bytecore.ReqCancelFile) (*bytecore.DataCancelFile, error) {
-	return nil, nil
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.CancelFile(param)
 }
 
 func (ptr *ByteCoreService) EditTableData(param bytecore.ReqEditTableData) (*bytecore.DataEditTableData, error) {
-	return nil, nil
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.EditTableData(param)
 }
 
 //////////////
 // 字库核心
 //////////////
 
-func CreateByteCoreService() (*ByteCoreService, error) {
+func CreateByteCoreService() (bytecore.ByteLibService, error) {
 	return ByteCore, nil
 }
+
+type WrapByteCoreService struct {
+	ByteCoreService
+}
+
+func (ptr *WrapByteCoreService) LoadDataTable(param bytecore.ReqLoadDataTable) (*bytecore.DataLoadDataTable, error) {
+	apiByteLib := bytelib.NewApiByteLib(constant.BYTE_CORE_HOST)
+	return apiByteLib.LoadDataTable(param)
+}
+
+func (ptr *WrapByteCoreService) GenerateTable(ctx *domain.Context, param bytecore.ReqGenerateTable) (*bytecore.DataGenerateTable, error) {
+	return nil, nil
+}

@@ -5,6 +5,7 @@ import (
 	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/dao"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/log"
 )
 
 type DeleteFileService struct {
@@ -24,14 +25,14 @@ func NewDeleteFileService(transactionContext *pgTransaction.TransactionContext)
 // DeleteFiles 文件删除
 func (ptr *DeleteFileService) DeleteFiles(ctx *domain.Context, files ...*domain.File) error {
 	for _, file := range files {
-		if err := ptr.delete(file); err != nil {
+		if err := ptr.delete(ctx, file); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (ptr *DeleteFileService) delete(file *domain.File) error {
+func (ptr *DeleteFileService) delete(ctx *domain.Context, file *domain.File) error {
 	// delete file
 	if err := dao.FileDelete(ptr.transactionContext, file.FileId, domain.FileType(file.FileType)); err != nil {
 		return err
@@ -46,5 +47,6 @@ func (ptr *DeleteFileService) delete(file *domain.File) error {
 	if err := dao.LogDirectDelete(ptr.transactionContext, file.FileId, domain.VerifiedStepLog); err != nil {
 		return err
 	}
+	log.Logger.Info(fmt.Sprintf("[%v] 删除文件:%v 文件类型:%v", ctx.OperatorName, file.FileInfo.Name, file.FileType))
 	return nil
 }

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain/bytecore"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/repository"
 )
 
@@ -12,49 +13,41 @@ type EditDataTableService struct {
 }
 
 // Edit 表结构编辑  【data-table】
-func (ptr *EditDataTableService) Edit(ctx *domain.Context, fileId int, tableId int, mappingFields []*domain.MappingField) (interface{}, error) {
+func (ptr *EditDataTableService) Edit(ctx *domain.Context, req domain.EditTableRequest) (interface{}, error) {
 	fileRepository, _ := repository.NewFileRepository(ptr.transactionContext)
-	file, err := fileRepository.FindOne(map[string]interface{}{"fileId": fileId})
+	file, err := fileRepository.FindOne(map[string]interface{}{"fileId": req.FileId})
 	if err != nil {
 		return nil, fmt.Errorf("文件不存在")
 	}
-
-	tableRepository, _ := repository.NewTableRepository(ptr.transactionContext)
-	table, err := tableRepository.FindOne(map[string]interface{}{"tableId": tableId})
-	if err != nil {
-		return nil, fmt.Errorf("表不存在")
-	}
-
-	excelTable, err := tableRepository.FindOne(map[string]interface{}{"tableId": file.FileInfo.TableId})
-	if err != nil {
+	if file.FileType != domain.TemporaryFile.ToString() {
 		return nil, fmt.Errorf("文件未校验")
 	}
-
-	if !(table.TableType == domain.MainTable.ToString() || table.TableType == domain.SideTable.ToString()) {
-		return nil, fmt.Errorf("只能追加数据到主表或者副表")
-	}
-	var subTables []*domain.Table
-	_, subTables, err = tableRepository.Find(map[string]interface{}{"parentId": tableId, "tableTypes": []string{domain.SubTable.ToString()}})
-	if err != nil {
-		return nil, err
-	}
-
+	// TODO：操作名映射
+	var operateName string = req.Action
 	// 日志
-	if err = FastLog(ptr.transactionContext, domain.CommonLog, table.TableId, &AppendDataToTableLog{
-		LogEntry:  domain.NewLogEntry(table.Name, domain.MainTable.ToString(), domain.AppendData, ctx),
-		File:      file,
-		Table:     table,
-		SubTables: subTables,
-		RowCount:  excelTable.RowCount,
+	if err = FastLog(ptr.transactionContext, domain.VerifiedStepLog, file.FileId, &ExcelTableEditLog{
+		LogEntry:      domain.NewLogEntry(file.FileInfo.Name, domain.VerifiedFile.ToString(), domain.FileVerify, ctx),
+		ProcessFields: req.ProcessFields,
+		OperateName:   operateName,
 	}); err != nil {
 		return nil, err
 	}
+	// 通知底层进行文件表编辑
+
+	response, err := ByteCore.EditTable(bytecore.ReqEditDataTable{
+		FileId:        file.FileId,
+		PageNumber:    req.Where.PageNumber,
+		PageSize:      req.Where.PageSize,
+		Fields:        bytecore.ToFields(req.Fields),
+		ProcessFields: bytecore.ToFields(req.ProcessFields),
+		Action:        req.Action,
+		Params:        req.Params,
+	})
+	if err != nil {
+		return nil, err
+	}
 
-	// 通知底层进行追加数据
-
-	return map[string]interface{}{
-		"result": fmt.Sprintf("源数据%v条，成功追加%v条;", excelTable.RowCount, excelTable.RowCount),
-	}, nil
+	return response, nil
 }
 
 func NewEditDataTableService(transactionContext *pgTransaction.TransactionContext) (*EditDataTableService, error) {

@@ -6,8 +6,10 @@ import (
 	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
 	"github.com/linmadan/egglib-go/utils/tool_funs"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain/bytecore"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/dao"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/repository"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/log"
 	"time"
 )
 
@@ -29,15 +31,25 @@ func (ptr *FlushDataTableService) Flush(ctx *domain.Context, fileId int, table *
 	}
 	// New Table
 	table = NewTable(domain.ExcelTable, file.FileInfo.Name, table.DataFields, table.RowCount).WithContext(ctx)
+	// 通知底层保存、进行回调
+	response, _ := ByteCore.SaveTable(bytecore.ReqSaveTable{FileId: fileId})
+	if err != nil {
+		return nil, err
+	}
 	// 来自源文件的
 	// 临时文件 -》校验文件
+	var newUrl string
+	if response != nil {
+		newUrl = response.Url
+	}
+	log.Logger.Info("更新文件地址", map[string]interface{}{"from_url": file.FileInfo.Url, "to_url": newUrl, "sourceFileId": file.SourceFileId})
 	switch sourceFile.FileType {
 	case domain.SourceFile.ToString():
-		if err = ptr.flushSourceFile(ctx, table, file, sourceFile, fileRepository); err != nil {
+		if err = ptr.flushSourceFile(ctx, table, file, sourceFile, fileRepository, newUrl); err != nil {
 			return nil, err
 		}
 	case domain.VerifiedFile.ToString():
-		if err = ptr.flushVerifiedFile(ctx, table, file, sourceFile, fileRepository); err != nil {
+		if err = ptr.flushVerifiedFile(ctx, table, file, sourceFile, fileRepository, newUrl); err != nil {
 			return nil, err
 		}
 	}
@@ -48,12 +60,11 @@ func (ptr *FlushDataTableService) Flush(ctx *domain.Context, fileId int, table *
 	}); err != nil {
 		return nil, err
 	}
-	// 通知底层保存、进行回调
 
 	return struct{}{}, nil
 }
 
-func (ptr *FlushDataTableService) flushSourceFile(ctx *domain.Context, table *domain.Table, file *domain.File, sourceFile *domain.File, fileRepository domain.FileRepository) error {
+func (ptr *FlushDataTableService) flushSourceFile(ctx *domain.Context, table *domain.Table, file *domain.File, sourceFile *domain.File, fileRepository domain.FileRepository, url string) error {
 	var err error
 	// 新增
 	tableRepository, _ := repository.NewTableRepository(ptr.transactionContext)
@@ -63,6 +74,7 @@ func (ptr *FlushDataTableService) flushSourceFile(ctx *domain.Context, table *do
 	}
 	file.FileInfo.TableId = table.TableId
 	file.FileType = domain.VerifiedFile.ToString()
+	file.UpdateFileUrl(url)
 	if file, err = fileRepository.Save(file); err != nil {
 		return err
 	}
@@ -77,7 +89,7 @@ func (ptr *FlushDataTableService) flushSourceFile(ctx *domain.Context, table *do
 	return nil
 }
 
-func (ptr *FlushDataTableService) flushVerifiedFile(ctx *domain.Context, table *domain.Table, file *domain.File, sourceFile *domain.File, fileRepository domain.FileRepository) error {
+func (ptr *FlushDataTableService) flushVerifiedFile(ctx *domain.Context, table *domain.Table, file *domain.File, sourceFile *domain.File, fileRepository domain.FileRepository, url string) error {
 	var err error
 	temporaryFileTableId := table.TableId
 	// 校验文件对应的表更新
@@ -86,6 +98,10 @@ func (ptr *FlushDataTableService) flushVerifiedFile(ctx *domain.Context, table *
 	if err = dao.ChangeStepLogOwner(ptr.transactionContext, file.FileId, sourceFile.FileId); err != nil {
 		return err
 	}
+	sourceFile.UpdateFileUrl(url)
+	if sourceFile, err = fileRepository.Save(sourceFile); err != nil {
+		return err
+	}
 	// 删除中间文件
 	if err = dao.FileDelete(ptr.transactionContext, file.FileId, domain.TemporaryFile); err != nil {
 		return err
@@ -144,7 +160,7 @@ func PK() *domain.Field {
 		Index:       0,
 		Name:        "序号",
 		SQLName:     "id",
-		SQLType:     domain.Int.ToString(),
+		SQLType:     domain.String.ToString(),
 		Description: "主键",
 		Flag:        domain.PKField,
 	}

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain/bytecore"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/repository"
 )
 
@@ -42,6 +43,10 @@ func (ptr *GenerateMainTableService) GenerateTable(ctx *domain.Context, fileId i
 	}); err != nil {
 		return nil, err
 	}
+
+	if _, err = ByteCore.GenerateTable(ctx, bytecore.ReqGenerateTable{FileId: fileId, FileUrl: file.FileInfo.Url, Table: table}); err != nil {
+		return nil, err
+	}
 	return struct{}{}, nil
 }
 

@@ -5,6 +5,7 @@ import (
 	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain/bytecore"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/api/bytelib"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/repository"
 )
 
@@ -14,19 +15,22 @@ type PreviewDataTableService struct {
 }
 
 // Preview 预览  【data-table】
-func (ptr *PreviewDataTableService) Preview(ctx *domain.Context, fileId int, where domain.Where) (interface{}, error) {
+func (ptr *PreviewDataTableService) Preview(ctx *domain.Context, fileId int, fields []*domain.Field, where domain.Where) (interface{}, error) {
 	fileRepository, _ := repository.NewFileRepository(ptr.transactionContext)
 	file, err := fileRepository.FindOne(map[string]interface{}{"fileId": fileId})
 	if err != nil {
 		return nil, fmt.Errorf("文件不存在")
 	}
-
+	isSourceFile := false
+	fileUrl := ""
 	// Copy to TemporaryFile
 	if file.FileType != domain.TemporaryFile.ToString() {
 		file = file.CopyTo(domain.TemporaryFile, ctx)
 		if file, err = fileRepository.Save(file); err != nil {
 			return nil, err
 		}
+		isSourceFile = true
+		fileUrl = file.FileInfo.Url
 	}
 	//TEST
 	ptr.FileId = file.FileId
@@ -39,22 +43,23 @@ func (ptr *PreviewDataTableService) Preview(ctx *domain.Context, fileId int, whe
 		Url:      file.FileInfo.Url,
 		Ext:      file.FileInfo.Ext,
 		Where:    where,
+
+		OriginalTableId:     fmt.Sprintf("%v", file.FileId),
+		IsFromOriginalTable: isSourceFile,
+		TableFileUrl:        fileUrl,
+		ColumnSchemas:       bytelib.DomainFieldsToColumnSchemas(fields),
+		QueryParameters:     make(map[string]interface{}),
+		SortParameters:      make(map[string]interface{}),
 	})
 	if err != nil {
 		return nil, err
 	}
 	response.ObjectType = domain.ObjectFile
+	response.FileId = file.FileId
 	response.TableType = domain.ExcelTable.ToString()
 	return response, nil
 }
 
-//func convert(from *bytecore.DataLoadDataTable)(to *domain.DataTable){
-//	to = &domain.DataTable{
-//
-//	}
-//	return
-//}
-
 func (ptr *PreviewDataTableService) GetFileId() int {
 	return ptr.FileId
 }

@@ -187,6 +187,51 @@ func (l *CopyTableLog) Content() string {
 	return msg
 }
 
+// 7.编辑记录
+type RowAddLog struct {
+	domain.LogEntry
+}
+
+func (l *RowAddLog) Content() string {
+	msg := fmt.Sprintf("新增行数据")
+	return msg
+}
+
+type RowUpdateLog struct {
+	domain.LogEntry
+	FieldValue []*domain.FieldValue
+	Where      domain.Where
+	Number     int
+}
+
+func (l *RowUpdateLog) Content() string {
+	change := ""
+	index := l.Number + l.Where.Offset()
+	for _, f := range l.FieldValue {
+		if f.OldValue != f.Value {
+			change += fmt.Sprintf("%v字段%v行的值从%v更改为%v;", f.Field.Name, index, f.OldValue, f.Value)
+		}
+	}
+	if len(change) == 0 {
+		return "更新数据内容"
+	}
+	msg := fmt.Sprintf("更改数据内容：%v", change)
+	return msg
+}
+
+type RowRemoveLog struct {
+	domain.LogEntry
+	FieldValue *domain.FieldValues
+	Where      domain.Where
+}
+
+func (l *RowRemoveLog) Content() string {
+	index := l.FieldValue.Number + l.Where.Offset()
+	//msg := fmt.Sprintf("删除%v行数据；筛选件：%v",index,"")
+	msg := fmt.Sprintf("删除%v行数据;", index)
+	return msg
+}
+
 // 8.表删除日志
 type DeleteTableLog struct {
 	domain.LogEntry
@@ -228,3 +273,21 @@ func (l *AppendDataToTableLog) Content() string {
 	}
 	return msg
 }
+
+/*步骤日志*/
+type ExcelTableEditLog struct {
+	domain.LogEntry
+	// 操作名称
+	OperateName string
+	// 操作列
+	ProcessFields []*domain.Field
+}
+
+func (l *ExcelTableEditLog) Content() string {
+	fieldsName := make([]string, 0)
+	for _, f := range l.ProcessFields {
+		fieldsName = append(fieldsName, fmt.Sprintf("【%v】", f.Name))
+	}
+	msg := fmt.Sprintf("%v：%v", l.OperateName, strings.Join(fieldsName, "、"))
+	return msg
+}

@@ -21,7 +21,7 @@ func NewAddTableStructService(transactionContext *pgTransaction.TransactionConte
 	}
 }
 
-func (ptr *AddTableStructService) AddTableStruct(ctx *domain.Context, parentTableId int, fields []*domain.Field, name string) (interface{}, error) {
+func (ptr *AddTableStructService) AddTableStruct(ctx *domain.Context, parentTableId int, fields []*domain.Field, name string) (*domain.Table, error) {
 	tableRepository, _ := repository.NewTableRepository(ptr.transactionContext)
 	mainTable, err := tableRepository.FindOne(map[string]interface{}{"tableId": parentTableId})
 	if err != nil {
@@ -38,19 +38,20 @@ func (ptr *AddTableStructService) AddTableStruct(ctx *domain.Context, parentTabl
 	}
 
 	fields = MappingFields(mainTable, fields)
-	dataFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": 1})
-	manualFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": 2})
+	dataFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": domain.MainTableField})
+	manualFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": domain.ManualField})
 	table := NewTable(domain.SubTable, name, fields, mainTable.RowCount).WithContext(ctx)
 	table.DataFieldIndex = mainTable.DataFieldIndex
 	table.DataFields = dataFields
 	table.ManualFields = manualFields
 	table.ParentId = parentTableId
+	table.SQLName = mainTable.SQLName // 主表名跟分表名相同
 	reserves, deletes, adds := domain.FieldsChange(table.Fields(false), fields)
 
 	if err = domain.ValidFields(fields); err != nil {
 		return nil, err
 	}
-	if _, err = tableRepository.Save(table); err != nil {
+	if table, err = tableRepository.Save(table); err != nil {
 		return nil, err
 	}
 	if _, err = tableRepository.Save(mainTable); err != nil {
@@ -70,5 +71,5 @@ func (ptr *AddTableStructService) AddTableStruct(ctx *domain.Context, parentTabl
 	}
 
 	// 通知底层
-	return struct{}{}, nil
+	return table, nil
 }

+package domainService
+
+import (
+	"fmt"
+	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/repository"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/starrocks"
+)
+
+type TableEditDataService struct {
+	transactionContext *pgTransaction.TransactionContext
+}
+
+func NewTableEditDataService(transactionContext *pgTransaction.TransactionContext) (*TableEditDataService, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	} else {
+		return &TableEditDataService{
+			transactionContext: transactionContext,
+		}, nil
+	}
+}
+
+func (ptr *TableEditDataService) RowEdit(ctx *domain.Context, request domain.EditDataRequest) (interface{}, error) {
+	tableRepository, _ := repository.NewTableRepository(ptr.transactionContext)
+	table, err := tableRepository.FindOne(map[string]interface{}{"tableId": request.TableId})
+	if err != nil {
+		return nil, err
+	}
+	if table.TableType != domain.SideTable.ToString() {
+		return nil, fmt.Errorf("副表才允许编辑数据")
+	}
+	//if table.TableType == domain.SubTable.ToString(){
+	//	mainTable, err := tableRepository.FindOne(map[string]interface{}{"tableId": request.TableId})
+	//	if err != nil {
+	//		return nil, err
+	//	}
+	//	table.SQLName = mainTable.SQLName
+	//}
+
+	for _, l := range request.AddList {
+		ptr.add(ctx, table, l, request.Where)
+	}
+	for _, l := range request.RemoveList {
+		ptr.remove(ctx, table, l, request.Where)
+	}
+	for _, l := range request.UpdateList {
+		ptr.update(ctx, table, l, request.Where)
+	}
+
+	return nil, nil
+}
+
+func (ptr *TableEditDataService) add(ctx *domain.Context, table *domain.Table, list *domain.FieldValues, where domain.Where) error {
+	var err error
+
+	// 日志
+	if err = FastLog(ptr.transactionContext, domain.CommonLog, table.TableId, &RowAddLog{
+		LogEntry: domain.NewLogEntry(table.Name, table.TableType, domain.RowEdit, ctx),
+	}); err != nil {
+		return err
+	}
+
+	// 添加记录
+	if err = starrocks.Insert(starrocks.DB, table.SQLName, list.FieldValues); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (ptr *TableEditDataService) remove(ctx *domain.Context, table *domain.Table, list *domain.FieldValues, where domain.Where) error {
+	var err error
+
+	// 日志
+	if err = FastLog(ptr.transactionContext, domain.CommonLog, table.TableId, &RowRemoveLog{
+		LogEntry:   domain.NewLogEntry(table.Name, table.TableType, domain.RowEdit, ctx),
+		FieldValue: list,
+		Where:      where,
+	}); err != nil {
+		return err
+	}
+
+	// 删除记录
+	if err = starrocks.Delete(starrocks.DB, table.SQLName, list.FieldValues); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (ptr *TableEditDataService) update(ctx *domain.Context, table *domain.Table, list *domain.FieldValues, where domain.Where) error {
+	var err error
+
+	// 日志
+	if err = FastLog(ptr.transactionContext, domain.CommonLog, table.TableId, &RowUpdateLog{
+		LogEntry: domain.NewLogEntry(table.Name, table.TableType, domain.RowEdit, ctx),
+	}); err != nil {
+		return err
+	}
+
+	// 更新记录
+	if err = starrocks.Update(starrocks.DB, table.SQLName, list.FieldValues); err != nil {
+		return err
+	}
+	return nil
+}

@@ -38,8 +38,8 @@ func (ptr *UpdateTableStructService) UpdateTableStruct(ctx *domain.Context, tabl
 
 	fields = MappingFields(mainTable, fields)
 	reserves, deletes, adds := domain.FieldsChange(table.Fields(false), fields)
-	dataFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": 1})
-	manualFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": 2})
+	dataFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": domain.MainTableField})
+	manualFields := (domain.Fields)(fields).Select(map[string]interface{}{"flag": domain.ManualField})
 	table.DataFieldIndex = mainTable.DataFieldIndex
 	table.DataFields = dataFields
 	table.ManualFields = manualFields
@@ -76,17 +76,18 @@ func MappingFields(table *domain.Table, fields []*domain.Field) []*domain.Field
 	tableFieldsMap := (domain.Fields)(tableFields).ToMap()
 	for i := range fields {
 		f := fields[i]
-		if v, ok := tableFieldsMap[fields[i].Name]; ok {
+		if v, ok := tableFieldsMap[f.Name]; ok {
 			fields[i].Name = v.Name
 			fields[i].SQLName = v.SQLName
 			fields[i].Index = v.Index
 			fields[i].SQLType = v.SQLType
-			fields[i].Description = v.Description
+			fields[i].Description = f.Description
 			fields[i].Flag = v.Flag
 		} else {
 			if f.Flag == domain.ManualField && f.Index == 0 {
 				table.DataFieldIndex += 1
 				fields[i] = DataField(f.Name, f.SQLType, domain.ManualField, table.DataFieldIndex)
+				fields[i].Description = f.Description
 			}
 		}
 	}

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/csv"
 	"fmt"
-	"github.com/aswjh/excel"
 	"github.com/xuri/excelize/v2"
 	"io"
 	"os"
@@ -156,70 +155,70 @@ func NewCSVWriterTo(title []string, data [][]string) *CSVWriterTo {
 	}
 }
 
-type XlSWriterTo struct {
-	data  [][]string
-	title []string
-}
-
-func (xw *XlSWriterTo) WriteTo(w io.Writer) (n int64, err error) {
-	var file = bytes.NewBuffer(nil)
-	err = xw.write(file)
-	if err != nil {
-		return 0, nil
-	}
-	return file.WriteTo(w)
-}
-
-func (xw *XlSWriterTo) Save(fileName string) error {
-	if err := checkPath(fileName); err != nil {
-		return err
-	}
-	option := excel.Option{"Visible": true, "DisplayAlerts": true, "ScreenUpdating": true}
-	xl, err := excel.New(option) //xl, _ := excel.Open("test_excel.xls", option)
-	if err != nil {
-		return err
-	}
-	defer xl.Quit()
-
-	sheet, _ := xl.Sheet(1) //xl.Sheet("sheet1")
-	defer sheet.Release()
-
-	index := 1
-	sheet.PutRange(excelRange(index, xw.title), toInterface(xw.title)...)
-	for _, item := range xw.data {
-		row := toInterface(item)
-		index += 1
-		sheet.PutRange(excelRange(index, item), row)
-	}
-	errs := xl.SaveAs(fileName)
-	if len(errs) > 0 {
-		return errs[0]
-	}
-	return nil
-}
-
-func excelRange(index int, data []string) string {
-	var begin byte = 'a'
-	r := fmt.Sprintf("%c%d:%c%d", begin, index, begin+byte(len(data)), index)
-	return r
-}
-
-func toInterface(data []string) []interface{} {
-	row := make([]interface{}, len(data))
-	for i := range data {
-		row[i] = data[i]
-	}
-	return row
-}
-
-func (xw *XlSWriterTo) write(w io.Writer) error {
-
-	return nil
-}
-
-func NewXlSWriterTo(title []string, data [][]string) *XlSWriterTo {
-	return &XlSWriterTo{
-		data:  data,
-		title: title,
-	}
-}
+//type XlSWriterTo struct {
+//	data  [][]string
+//	title []string
+//}
+//
+//func (xw *XlSWriterTo) WriteTo(w io.Writer) (n int64, err error) {
+//	var file = bytes.NewBuffer(nil)
+//	err = xw.write(file)
+//	if err != nil {
+//		return 0, nil
+//	}
+//	return file.WriteTo(w)
+//}
+//
+//func (xw *XlSWriterTo) Save(fileName string) error {
+//	if err := checkPath(fileName); err != nil {
+//		return err
+//	}
+//	option := excel.Option{"Visible": true, "DisplayAlerts": true, "ScreenUpdating": true}
+//	xl, err := excel.New(option) //xl, _ := excel.Open("test_excel.xls", option)
+//	if err != nil {
+//		return err
+//	}
+//	defer xl.Quit()
+//
+//	sheet, _ := xl.Sheet(1) //xl.Sheet("sheet1")
+//	defer sheet.Release()
+//
+//	index := 1
+//	sheet.PutRange(excelRange(index, xw.title), toInterface(xw.title)...)
+//	for _, item := range xw.data {
+//		row := toInterface(item)
+//		index += 1
+//		sheet.PutRange(excelRange(index, item), row)
+//	}
+//	errs := xl.SaveAs(fileName)
+//	if len(errs) > 0 {
+//		return errs[0]
+//	}
+//	return nil
+//}
+//
+//func excelRange(index int, data []string) string {
+//	var begin byte = 'a'
+//	r := fmt.Sprintf("%c%d:%c%d", begin, index, begin+byte(len(data)), index)
+//	return r
+//}
+//
+//func toInterface(data []string) []interface{} {
+//	row := make([]interface{}, len(data))
+//	for i := range data {
+//		row[i] = data[i]
+//	}
+//	return row
+//}
+//
+//func (xw *XlSWriterTo) write(w io.Writer) error {
+//
+//	return nil
+//}
+//
+//func NewXlSWriterTo(title []string, data [][]string) *XlSWriterTo {
+//	return &XlSWriterTo{
+//		data:  data,
+//		title: title,
+//	}
+//}

@@ -3,9 +3,13 @@ package transform
 import (
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg/models"
+	"strings"
 )
 
 func TransformToTableDomainModelFromPgModels(tableModel *models.Table) (*domain.Table, error) {
+	for _, f := range tableModel.DataFields {
+		f.SQLType = strings.ToUpper(f.SQLType)
+	}
 	return &domain.Table{
 		TableId:        tableModel.TableId,
 		TableType:      tableModel.TableType,

@@ -9,6 +9,7 @@ import (
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg/models"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/pg/transform"
+	"time"
 )
 
 type FileRepository struct {
@@ -142,7 +143,12 @@ func (repository *FileRepository) Find(queryOptions map[string]interface{}) (int
 	if v, ok := queryOptions["notInFileIds"]; ok && len(v.([]int)) > 0 {
 		query.Where(`file_id not in (?)`, pg.In(v.([]int)))
 	}
-
+	if v, ok := queryOptions["updatedAtBegin"]; ok && !v.(time.Time).IsZero() {
+		query.Where(`updated_at>?`, v.(time.Time))
+	}
+	if v, ok := queryOptions["updatedAtEnd"]; ok && !v.(time.Time).IsZero() {
+		query.Where(`updated_at<?`, v.(time.Time))
+	}
 	query.SetOffsetAndLimit(20)
 	query.SetOrderDirect("file_id", "DESC")
 	if count, err := query.SelectAndCount(); err != nil {

@@ -165,7 +165,7 @@ func (repository *LogRepository) Find(queryOptions map[string]interface{}) (int6
 	}
 
 	query.SetOffsetAndLimit(20)
-	query.SetOrderDirect("log_id", "DESC")
+	query.SetOrderDirect("log_id", "ASC")
 	if count, err := query.SelectAndCount(); err != nil {
 		return 0, logs, err
 	} else {

+package starrocks
+
+import (
+	"fmt"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
+	"gorm.io/gorm"
+)
+
+func Insert(db *gorm.DB, tableName string, fields []*domain.FieldValue) error {
+	value := map[string]interface{}{}
+	for _, f := range fields {
+		if f.Field.Flag == domain.PKField && f.Value == "" {
+			continue
+		}
+		value[f.Field.SQLName] = f.TypeValue()
+	}
+	//tx := db.Table(tableName).Create(value)
+	//return tx.Error
+	sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
+		return tx.Table(tableName).Create(value)
+	})
+	tx := db.Exec(sql)
+	return tx.Error
+}
+
+func Update(db *gorm.DB, tableName string, fields []*domain.FieldValue) error {
+	value := map[string]interface{}{}
+	var pk *domain.FieldValue
+	for _, f := range fields {
+		if f.Field.Flag == domain.PKField && f.Value != "" {
+			pk = f
+		}
+		value[f.Field.SQLName] = f.TypeValue()
+	}
+	if pk == nil && pk.Value != "" && pk.TypeValue() != nil {
+		return fmt.Errorf("主键不能为空")
+	}
+	//tx := db.Table(tableName).Where("? = ?", pk.Field.SQLName, pk.Value).Updates(value)
+	//return tx.Error
+	sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
+		return tx.Table(tableName).Create(value)
+	})
+	tx := db.Exec(sql)
+	return tx.Error
+}
+
+func Delete(db *gorm.DB, tableName string, fields []*domain.FieldValue) error {
+	var pk *domain.FieldValue
+	for _, f := range fields {
+		if f.Field.Flag == domain.PKField && f.Value != "" {
+			pk = f
+		}
+	}
+	if pk == nil {
+		return fmt.Errorf("主键不能为空")
+	}
+	//tx := db.Table(tableName).Delete("? = ?", pk.Field.SQLName, pk.Value)
+	//return tx.Error
+	sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
+		return tx.Table(tableName).Delete("? = ?", pk.Field.SQLName, pk.Value)
+	})
+	tx := db.Exec(sql)
+	return tx.Error
+}

@@ -8,8 +8,8 @@ import (
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
-	rawlog "log"
-	"os"
+	//rawlog "log"
+	//"os"
 	"reflect"
 	"time"
 )
@@ -19,7 +19,7 @@ var DB *gorm.DB
 func Init() error {
 	var err error
 	newLogger := logger.New(
-		rawlog.New(os.Stdout, "\r\n", rawlog.LstdFlags), // io writer
+		log.GormLogWriter{Module: "【StarRocks】"}, //rawlog.New(os.Stdout, "\r\n", rawlog.LstdFlags), // io writer
 		logger.Config{
 			SlowThreshold:             time.Second, // Slow SQL threshold
 			LogLevel:                  logger.Info, // Log level

+package utils
+
+import "strconv"
+
+type NumberString string
+
+func (s NumberString) String() string {
+	return string(s)
+}
+
+func (s NumberString) Int() (int, error) {
+	v, err := strconv.Atoi(s.String())
+	return v, err
+}
+
+func (s NumberString) MustInt() int {
+	v, _ := s.Int()
+	return v
+}
+
+func (s NumberString) UInt32() (uint32, error) {
+	v, err := strconv.Atoi(s.String())
+	return uint32(v), err
+}
+
+func (s NumberString) MustUInt32() uint32 {
+	v, _ := s.UInt32()
+	return v
+}
+
+func (s NumberString) Int64() (int64, error) {
+	v, err := strconv.ParseInt(s.String(), 10, 64)
+	return v, err
+}
+
+func (s NumberString) MustInt64() int64 {
+	v, _ := s.Int64()
+	return v
+}
+
+func (s NumberString) Float64() (float64, error) {
+	return strconv.ParseFloat(s.String(), 64)
+}
+
+func (s NumberString) MustFloat64() float64 {
+	v, _ := strconv.ParseFloat(s.String(), 64)
+	return v
+}
+
+func NewNumberString(str string) NumberString {
+	return NumberString(str)
+}

+package log
+
+import "github.com/beego/beego/v2/core/logs"
+
+type GormLogWriter struct {
+	Module string
+}
+
+func (w GormLogWriter) Printf(msg string, args ...interface{}) {
+	logs.Info(w.Module+msg, args...)
+}

 package beego
 
 import (
+	"fmt"
+	"github.com/beego/beego/v2/core/logs"
 	"github.com/beego/beego/v2/server/web"
+	"github.com/beego/beego/v2/server/web/context"
 	"github.com/linmadan/egglib-go/web/beego/filters"
 	"os"
 	"strconv"
@@ -26,7 +29,32 @@ func init() {
 			web.BConfig.Listen.HTTPPort = port
 		}
 	}
+
+	//https支持
+	web.BConfig.Listen.EnableHTTPS = true
+	web.BConfig.Listen.HTTPSPort = 443
+
+	//进程内监控
+	//web.BConfig.Listen.EnableAdmin = true
+	//web.BConfig.Listen.AdminPort = 8088
+	if os.Getenv("HTTPS_PORT") != "" {
+		portStr := os.Getenv("HTTPS_PORT")
+		if port, err := strconv.Atoi(portStr); err == nil {
+			web.BConfig.Listen.HTTPSPort = port
+		}
+	}
+
 	web.InsertFilter("/*", web.BeforeRouter, filters.AllowCors())
-	web.InsertFilter("/*", web.BeforeExec, filters.CreateRequstLogFilter(Logger))
+	web.InsertFilter("/*", web.BeforeExec, filters.CreateRequstLogFilter(Logger)) //  CreateRequestLogFilter(true)
 	web.InsertFilter("/*", web.AfterExec, filters.CreateResponseLogFilter(Logger), web.WithReturnOnOutput(false))
 }
+
+func CreateRequestLogFilter(console bool) func(ctx *context.Context) {
+	return func(ctx *context.Context) {
+		msg := fmt.Sprintf("beego | %v | %v \n %v", ctx.Input.Method(), ctx.Input.URL(), string(ctx.Input.RequestBody))
+		logs.Debug(msg)
+		if console {
+			fmt.Println(msg)
+		}
+	}
+}

@@ -101,7 +101,7 @@ func (controller *FileController) FilePreview() {
 func (controller *FileController) EditDataTable() {
 	fileService := service.NewFileService(nil)
 	editDataTableCommand := &command.EditDataTableCommand{}
-	controller.Unmarshal(editDataTableCommand)
+	Must(controller.Unmarshal(editDataTableCommand))
 	data, err := fileService.EditDataTable(ParseContext(controller.BaseController), editDataTableCommand)
 	controller.Response(data, err)
 }

@@ -42,6 +42,15 @@ func (controller *TableController) GetTable() {
 	controller.Response(data, err)
 }
 
+func (controller *TableController) PrepareTable() {
+	tableService := service.NewTableService(nil)
+	getTableQuery := &query.GetTableQuery{}
+	tableId, _ := controller.GetInt("tableId")
+	getTableQuery.TableId = tableId
+	data, err := tableService.PrepareSubTable(getTableQuery)
+	controller.Response(data, err)
+}
+
 func (controller *TableController) RemoveTable() {
 	tableService := service.NewTableService(nil)
 	removeTableCommand := &command.RemoveTableCommand{}
@@ -63,21 +72,21 @@ func (controller *TableController) ListTable() {
 	controller.Response(data, err)
 }
 
-func (controller *TableController) SplitDataTable() {
-	tableService := service.NewTableService(nil)
-	splitDataTableCommand := &command.SplitDataTableCommand{}
-	controller.Unmarshal(splitDataTableCommand)
-	data, err := tableService.SplitDataTable(splitDataTableCommand)
-	controller.Response(data, err)
-}
-
-func (controller *TableController) BatchEditSubTable() {
-	tableService := service.NewTableService(nil)
-	batchEditSubTableCommand := &command.BatchEditSubTableCommand{}
-	controller.Unmarshal(batchEditSubTableCommand)
-	data, err := tableService.BatchEditSubTable(batchEditSubTableCommand)
-	controller.Response(data, err)
-}
+//func (controller *TableController) SplitDataTable() {
+//	tableService := service.NewTableService(nil)
+//	splitDataTableCommand := &command.SplitDataTableCommand{}
+//	controller.Unmarshal(splitDataTableCommand)
+//	data, err := tableService.SplitDataTable(splitDataTableCommand)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *TableController) BatchEditSubTable() {
+//	tableService := service.NewTableService(nil)
+//	batchEditSubTableCommand := &command.BatchEditSubTableCommand{}
+//	controller.Unmarshal(batchEditSubTableCommand)
+//	data, err := tableService.BatchEditSubTable(batchEditSubTableCommand)
+//	controller.Response(data, err)
+//}
 
 func (controller *TableController) CopyDataTable() {
 	tableService := service.NewTableService(nil)
@@ -128,17 +137,19 @@ func (controller *TableController) SearchSubTableList() {
 
 func (controller *TableController) UpdateTableStruct() {
 	tableService := service.NewTableService(nil)
-	batchEditSubTableCommand := &command.UpdateTableStructCommand{}
-	controller.Unmarshal(batchEditSubTableCommand)
-	data, err := tableService.UpdateTableStruct(ParseContext(controller.BaseController), batchEditSubTableCommand)
+	cmd := &command.UpdateTableStructCommand{}
+	controller.Unmarshal(cmd)
+	tableId, _ := controller.GetInt(":tableId")
+	cmd.TableId = tableId
+	data, err := tableService.UpdateTableStruct(ParseContext(controller.BaseController), cmd)
 	controller.Response(data, err)
 }
 
 func (controller *TableController) AddTableStruct() {
 	tableService := service.NewTableService(nil)
-	batchEditSubTableCommand := &command.AddTableStructCommand{}
-	controller.Unmarshal(batchEditSubTableCommand)
-	data, err := tableService.AddTableStruct(ParseContext(controller.BaseController), batchEditSubTableCommand)
+	cmd := &command.AddTableStructCommand{}
+	controller.Unmarshal(cmd)
+	data, err := tableService.AddTableStruct(ParseContext(controller.BaseController), cmd)
 	controller.Response(data, err)
 }
 
@@ -201,3 +212,11 @@ func (controller *TableController) Preview() {
 	}
 	controller.Response(data, err)
 }
+
+func (controller *TableController) RowEdit() {
+	tableService := service.NewTableService(nil)
+	cmd := &command.RowEditCommand{}
+	Must(controller.Unmarshal(cmd))
+	data, err := tableService.RowEdit(ParseContext(controller.BaseController), cmd)
+	controller.Response(data, err)
+}

@@ -7,8 +7,9 @@ import (
 
 func init() {
 	web.Router("/data/tables/", &controllers.TableController{}, "Post:CreateTable")
-	web.Router("/data/tables/:tableId", &controllers.TableController{}, "Put:UpdateTable")
+	//web.Router("/data/tables/:tableId", &controllers.TableController{}, "Put:UpdateTable")
 	web.Router("/data/tables/:tableId", &controllers.TableController{}, "Get:GetTable")
+	web.Router("/data/tables/prepare", &controllers.TableController{}, "Get:PrepareTable")
 	web.Router("/data/tables/:tableId", &controllers.TableController{}, "Delete:RemoveTable")
 	web.Router("/data/tables/", &controllers.TableController{}, "Get:ListTable")
 	web.Router("/data/tables/search", &controllers.TableController{}, "Post:Search")
@@ -16,14 +17,16 @@ func init() {
 	web.Router("/data/tables/search-appended-list", &controllers.TableController{}, "Post:SearchAppendedList")
 	web.Router("/data/tables/search-sub-table-list", &controllers.TableController{}, "Post:SearchSubTableList")
 
-	web.Router("/data/tables/split-data-table", &controllers.TableController{}, "Post:SplitDataTable")
-	web.Router("/data/tables/batch-edit-sub-table", &controllers.TableController{}, "Post:BatchEditSubTable")
+	//web.Router("/data/tables/split-data-table", &controllers.TableController{}, "Post:SplitDataTable")
+	//web.Router("/data/tables/batch-edit-sub-table", &controllers.TableController{}, "Post:BatchEditSubTable")
 	web.Router("/data/tables/copy-data-table", &controllers.TableController{}, "Post:CopyDataTable")
-	web.Router("/data/tables/update-table-struct", &controllers.TableController{}, "Post:UpdateTableStruct")
+	web.Router("/data/tables/update-table-struct/:tableId", &controllers.TableController{}, "Put:UpdateTableStruct")
 	web.Router("/data/tables/add-sub-table", &controllers.TableController{}, "Post:AddTableStruct")
 	web.Router("/data/tables/export-table", &controllers.TableController{}, "Post:ExportDataTable")
 
 	web.Router("/data/tables/table-preview", &controllers.TableController{}, "Post:TablePreview")
+	web.Router("/data/tables/row-edit", &controllers.TableController{}, "Post:RowEdit")
+
 	web.Router("/data/field-optional-values", &controllers.TableController{}, "Post:FieldOptionalValues")
 
 	web.Router("/business/db-table-preview", &controllers.TableController{}, "Post:DBTablePreview")