up

cache/redis.go

@@ -90,6 +90,21 @@ func SetUserData(userId int64, userData *viewmodel.UserData) error {
 	return SetCache(keyStr, userData, 0)
 }
 
+func GetUserData(userId int64) (*viewmodel.UserData, error) {
+	keyStr := fmt.Sprintf("user_%d", userId)
+	userData := &viewmodel.UserData{}
+	err := Instance().Get(context.Background(), keyStr).Scan(userData)
+	if err != nil {
+		return nil, err
+	}
+	return userData, nil
+}
+
+func DeleteUserData(userId int64) (int64, error) {
+	keyStr := fmt.Sprintf("user_%d", userId)
+	return Instance().Del(context.Background(), keyStr).Result()
+}
+
 func SetModelObject(objectCode string, data *viewmodel.ModelObjectInfo) error {
 	keyStr := fmt.Sprintf("model_object_%s", objectCode)
 	return SetCache(keyStr, data, 0)
@@ -334,18 +349,3 @@ func GetApiData(objectCode, oamCode string)(*viewmodel.ApiInfo, error){
 	}
 	return apiData, nil
 }
-
-func GetUserData(userId int64) (*viewmodel.UserData, error) {
-	keyStr := fmt.Sprintf("user_%d", userId)
-	userData := &viewmodel.UserData{}
-	err := Instance().Get(context.Background(), keyStr).Scan(userData)
-	if err != nil {
-		return nil, err
-	}
-	return userData, nil
-}
-
-func DeleteUserData(userId int64) (int64, error) {
-	keyStr := fmt.Sprintf("user_%d", userId)
-	return Instance().Del(context.Background(), keyStr).Result()
-}

constant/constant.go

@@ -15,6 +15,11 @@ const (
 )
 
 const (
+	DOC_DIR_TEMP  = 10000;
+	DOC_DIR_APP   = 10001;
+)
+
+const (
 	DATA_TYPE_INT      = 1
 	DATA_TYPE_VARCHAR  = 2
 	DATA_TYPE_DECIMAL  = 4

service/app_permit_service.go

@@ -15,6 +15,7 @@ type AppPermitService interface {
 	Create(permit *datamodel.AppPermit) error
 	Update(permit *datamodel.AppPermit) error
 	Delete(m map[string]interface{}) error
+	
 }
 
 type appPermitService struct {

service/app_service.go

@@ -14,39 +14,49 @@ type AppService interface {
 	Create(d *datamodel.App) error
 	Update(d *datamodel.App) error
 	Delete(m map[string]interface{}) error
+	GetPermit(roleId int64, appKey string) ([]viewmodel.AppPermitInfo, error)
 }
 
 type appService struct {
-	repo *repositories.AppRepo
+	appRepo *repositories.AppRepo
+	appPermitRepo *repositories.AppPermitRepo
 }
 
 func NewAppService() AppService {
 	return &appService{
-		repo: repositories.NewAppRepo(datasource.InstanceMaster()),
+		appRepo: repositories.NewAppRepo(datasource.InstanceMaster()),
+		appPermitRepo: repositories.NewAppPermitRepo(datasource.InstanceMaster()),
 	}
 }
 
 func (s *appService) GetList(m map[string]interface{}) ([]viewmodel.AppInfo, error) {
-	return s.repo.GetList(m)
+	return s.appRepo.GetList(m)
 }
 
 func (s *appService) GetPage(m map[string]interface{}) (*viewmodel.PageResult, error) {
-	return s.repo.GetPage(m)
+	return s.appRepo.GetPage(m)
 }
 
 func (s *appService) GetById(appId int64) (*viewmodel.AppInfo, error) {
-	return s.repo.GetById(appId)
+	return s.appRepo.GetById(appId)
 }
 
 func (s *appService) Create(App *datamodel.App) error {
 	App.AppId = NewID()
-	return s.repo.Create(App)
+	return s.appRepo.Create(App)
 }
 
 func (s *appService) Update(App *datamodel.App) error {
-	return s.repo.Update(App)
+	return s.appRepo.Update(App)
 }
 
 func (s *appService) Delete(m map[string]interface{}) error {
-	return s.repo.Delete(m)
+	return s.appRepo.Delete(m)
+}
+
+func (s *appService) GetPermit(roleId int64, appKey string) ([]viewmodel.AppPermitInfo, error) {
+	m := make(map[string]interface{}, 0)
+	m["appKey"] = appKey
+	m["roleId"] = roleId
+	return s.appPermitRepo.GetList(m)
 }

service/upload_service.go

@@ -1,14 +1,117 @@
 package service
 
-type UploadService interface {}
+import (
+    "time"
+    "xps/datamodel"
+    "xps/datasource"
+    "xps/repositories"
+    minio "xps/three_party"
+)
 
-type uploadService struct {
+type TargetFile struct {
+    FileName string
+    FilePath string
+}
 
+type UploadService interface {
+    UploadFile(ocId, userId, dirId int64, file TargetFile)(*datamodel.DocFile, error)
+    UploadFiles(ocId, userId, dirId int64, files []TargetFile)([]datamodel.DocFile, error)
+    
 }
 
+type uploadService struct {
+    repo *repositories.DocFileRepo
+}
 
 func NewUploadService() UploadService {
     return &uploadService{
+        repo: repositories.NewDocFileRepo(datasource.InstanceMaster()),
+    }
+}
+
+func (s* uploadService) UploadFile(ocId, userId, dirId int64, file TargetFile) (*datamodel.DocFile, error) {
+
+    dFile, err1 := minio.UploadFile(file.FileName, file.FilePath)
+    if err1 != nil {
+        return nil, err1
+    }
+    
+    fileId := NewID()
+    docFile := &datamodel.DocFile{
+        OcId:         ocId,
+        FileId:       fileId,
+        FileTitle:    dFile.FileName,
+        FileIcon:     "",
+        FileExt:      dFile.FileExt,
+        DirId:        dirId,
+        FileUrl:      dFile.FileUrl,
+        FileSize:     dFile.FileSize,
+        FileAuthor:   "",
+        FileMimeType: dFile.FileMimeType,
+        FileDesc:     "",
+        UploadedAt:   time.Time{},
+        UploadedBy:   0,
+        CreatedBy:    userId,
+        CreatedAt:    time.Time{},
+        UpdatedBy:    0,
+        UpdatedAt:    time.Time{},
+        DeletedFlag:  0,
+        DeletedBy:    0,
+        DeletedAt:    time.Time{},
     }
+    
+    err2 := s.repo.Create(docFile)
+    if err2 != nil {
+        return nil, err2
+    }
+    return docFile, nil
 }
 
+func (s* uploadService) UploadFiles(ocId, userId, dirId int64, files []TargetFile) ([]datamodel.DocFile, error) {
+    docFileList := make([]datamodel.DocFile, 0)
+    
+    for _, f := range files {
+        // 1. Upload to minio
+        dFile, err1 := minio.UploadFile(f.FileName, f.FilePath)
+        if err1 != nil {
+            return nil, err1
+        }
+        
+        // 2. DocFile
+        fileId := NewID()
+        docFile := datamodel.DocFile{
+            OcId:         ocId,
+            FileId:       fileId,
+            FileTitle:    dFile.FileName,
+            FileIcon:     "",
+            FileExt:      dFile.FileExt,
+            DirId:        dirId,
+            FileUrl:      dFile.FileUrl,
+            FileSize:     dFile.FileSize,
+            FileAuthor:   "",
+            FileMimeType: dFile.FileMimeType,
+            FileDesc:     "",
+            UploadedAt:   time.Time{},
+            UploadedBy:   0,
+            CreatedBy:    userId,
+            CreatedAt:    time.Time{},
+            UpdatedBy:    0,
+            UpdatedAt:    time.Time{},
+            DeletedFlag:  0,
+            DeletedBy:    0,
+            DeletedAt:    time.Time{},
+        }
+        
+        err2 := s.repo.Create(&docFile)
+        if err2 != nil {
+            return nil, err2
+        }
+        
+        // 3. DocFileList
+        docFileList = append(docFileList, docFile)
+    }
+    
+    return docFileList, nil
+}
+
+

three_party/minio.go

@@ -1,20 +1,14 @@
 package three_party
 
 import (
+    "context"
     "errors"
     "fmt"
-    uuid "github.com/iris-contrib/go.uuid"
-    "github.com/kataras/iris/v12"
     "github.com/minio/minio-go/v7"
     "github.com/minio/minio-go/v7/pkg/credentials"
-    "io"
     "log"
-    "mime/multipart"
-    "os"
-    "path/filepath"
-    "strings"
+    "path"
     "sync"
-    "time"
 )
 
 var defaultFileBucket = "file"
@@ -22,16 +16,26 @@ var defaultIconBucket = "icon"
 var defaultLocation   = "us-east-1"
 var minioServerPool *sync.Pool
 
+var defaultConfig = &MinioConfig{
+    EndPoint: "http://114.116.19.14:9000",
+    AccessKey: "root",
+    SecretKey: "Houyaf1!",
+    UseSSL: false,
+}
+
 // client version and secret, it should be from client side
 const (
     UploadDir    string = "./public/upload/"
     UrlBase      string = "/upload/"
 )
 
-// DstFile 文件
-type DstFile struct {
-    Name string `json:"name"`
-    Src  string `json:"src"`
+// DestFile 文件
+type DestFile struct {
+    FileName     string
+    FileUrl      string
+    FileSize     int64
+    FileExt      string
+    FileMimeType string
 }
 
 func init() {
@@ -43,29 +47,23 @@ func init() {
 }
 
 type MinioFileObject struct {
-    BucketName  string
     ObjectName  string
     FilePath    string
     ContentType string
-    Config      MinioConfig
 }
 
 type MinioConfig struct {
-    MinioHost  string `json:"minioHost"`
-    MinioPort  int64  `json:"minioPort"`
+    EndPoint   string `json:"endPoint"`
     AccessKey  string `json:"accessKey"`
     SecretKey  string `json:"secretKey"`
     UseSSL     bool   `json:"useSSL"`
 }
 
 
+
 func (c *MinioConfig) Validate() error {
-    if c.MinioHost == "" {
-        return errors.New("minio host not specified")
-    }
-    
-    if c.MinioPort <= 0 {
-        return errors.New("minio port not specified")
+    if c.EndPoint == "" {
+        return errors.New("EndPoint host not specified")
     }
     
     if c.AccessKey == "" {
@@ -83,16 +81,15 @@ func (c *MinioConfig) GetClient()(*minio.Client, error) {
         return nil, err
     }
     
-    endPoint := fmt.Sprintf("%s:%d", c.MinioHost, c.MinioPort)
     minioClient, err := minio.New(
-        endPoint,
+        c.EndPoint,
         &minio.Options{
             Creds: credentials.NewStaticV4(c.AccessKey, c.SecretKey, ""),
             Secure: c.UseSSL,
         })
     
     if err != nil {
-        log.Fatalf("connect minio server fail %s url %s", err.Error(), endPoint)
+        log.Fatalf("connect minio server fail %s url %s", err.Error(), c.EndPoint)
     }
     return minioClient, nil
 }
@@ -115,7 +112,7 @@ func (m *MinioServe) Reset() {
     m.Client = nil
 }
 
-func (m *MinioServe) checkBucket(ctx iris.Context, bucketName string) bool {
+func (m *MinioServe) checkBucket(ctx context.Context, bucketName string) bool {
     isExist, err1 := m.Client.BucketExists(ctx, bucketName)
     if err1 != nil {
         log.Fatalf("checkBucket error " + err1.Error())
@@ -132,27 +129,40 @@ func (m *MinioServe) checkBucket(ctx iris.Context, bucketName string) bool {
     return true
 }
 
-func (m *MinioServe) CheckBuckets(ctx iris.Context) bool {
+func (m *MinioServe) CheckBuckets(ctx context.Context) bool {
     b1 := m.checkBucket(ctx, defaultFileBucket)
     b2 := m.checkBucket(ctx, defaultIconBucket)
     return b1&&b2
 }
 
-func (m *MinioServe) UploadFile(ctx iris.Context, obj *MinioFileObject)(*minio.UploadInfo, error) {
+func (m *MinioServe) UploadFile(objectName, filePath string)(*DestFile, error) {
+    ctx := context.Background()
     bBucketExist := m.CheckBuckets(ctx)
     if !bBucketExist {
-        return nil, nil
+        return nil , errors.New("Bucket不存在")
     }
     
-    info, err := m.Client.FPutObject(ctx, obj.BucketName, obj.ObjectName, obj.FilePath, minio.PutObjectOptions{
-        ContentType: obj.ContentType,
+    contentType := "application/octet-stream"
+    uinfo, err := m.Client.FPutObject(ctx, defaultFileBucket, objectName, filePath, minio.PutObjectOptions{
+        ContentType: contentType,
     })
     
     if err != nil {
-        return &info, err
+        return nil, err
     }
     
-    return &info, nil
+    fileExt := path.Ext(objectName)
+    
+    url := fmt.Sprintf("%s/%s/%s", defaultConfig.EndPoint, defaultFileBucket, objectName)
+    targetFile := &DestFile{
+        FileName:     objectName,
+        FileUrl:      url,
+        FileSize:     uinfo.Size,
+        FileExt:      fileExt,
+        FileMimeType: "",
+    }
+    
+    return targetFile, nil
 }
 
 
@@ -166,115 +176,17 @@ func releaseMinioServer(m *MinioServe) {
 }
 
 
-func UploadFile(ctx iris.Context) (*DstFile,error){
-    file ,info ,err := ctx.FormFile("uploadfile")
-    if err != nil {
-        return nil ,err
-    }
-    defer file.Close()
-    
-    oldFileName := info.Filename
-    destFile, url := GenerateNewFileName(oldFileName)
-    
-    out, err := os.OpenFile(destFile, os.O_WRONLY|os.O_CREATE, 0666)
-    if err != nil{
-        return nil, err
-    }
+func UploadFile(fileName, filePath string) (*DestFile,error){
+    m := acquireMinioServer()
     
-    defer out.Close()
-    _ ,err = io.Copy(out, file)
+    client, err := defaultConfig.GetClient()
     if err != nil {
         return nil, err
     }
-    
-    outfile := &DstFile{Name: oldFileName ,Src:url }
-    
-    return outfile, nil
-}
-
-// UploadMultiFiles Upload Multi Files
-func UploadMultiFiles(ctx iris.Context)(int, []DstFile, error){
-    
-    maxSize := ctx.Application().ConfigurationReadOnly().GetPostMaxMemory()
-    
-    err := ctx.Request().ParseMultipartForm(maxSize)
-    if err != nil {
-        return 0 , nil, err
-    }
-    
-    form     := ctx.Request().MultipartForm
-    files    := form.File["files[]"]
-    count    := len(files)
-    
-    failures := 0
-    dstIndex := 1
-    
-    outFiles := []DstFile{}
-    for _, file := range files {
-        url, err := SaveUploadFile(file)
-        if err != nil {
-            failures++
-        }else{
-            out := DstFile{Name: file.Filename ,Src:url}
-            outFiles = append(outFiles, out)
-            dstIndex++
-        }
-    }
-    
-    num := count - failures
-    
-    return  num ,outFiles ,nil
-}
-
-func SaveUploadFile(fh *multipart.FileHeader)(string, error){
-    src ,err := fh.Open()
-    if err != nil {
-        return "" ,err
-    }
-    defer src.Close()
-    
-    oldFileName := fh.Filename
-    srcFile, urlFile := GenerateNewFileName(oldFileName)
-    
-    out, err := os.OpenFile(srcFile ,os.O_WRONLY|os.O_CREATE ,os.FileMode(0666))
-    if err != nil {
-        return "" ,err
-    }
-    
-    defer out.Close()
-    
-    _, err = io.Copy(out, src)
-    
-    return urlFile, err
-}
-
-// CreateDateDir Create date directory
-func CreateDateDir() (srcPath, urlPath string) {
-    folderName := time.Now().Format("20060102")
-    src  := filepath.Join(UploadDir, folderName)
-    url  := filepath.Join(UrlBase, folderName)
-    _, err := os.Stat(srcPath)
-    if os.IsNotExist(err ){
-        _ = os.Mkdir(src, os.ModePerm)
-        _ = os.Chmod(src, os.ModePerm)
-    }
-    
-    return src ,url
-}
-
-// GenerateNewFileName Generate new file name
-func GenerateNewFileName(oldFileName string) (srcPath, urlPath string) {
-    u1, _ := uuid.NewV4()
-    newFileName := u1.String()
-    src , url := CreateDateDir()
-    
-    dotIndex := strings.LastIndex(oldFileName, ".")
-    if dotIndex != -1 && dotIndex != 0 {
-        newFileName += oldFileName[dotIndex:]
-    }
-    
-    src = filepath.Join(src, newFileName)
-    url = filepath.Join(url, newFileName)
-    
-    return src, url
+    defer func() {
+        releaseMinioServer(m)
+    }()
+    m.Client = client
+    objName := ""
+    return m.UploadFile(objName, filePath)
 }

web/controller/app_controller.go

@@ -12,12 +12,13 @@ type AppController struct {
 }
 
 func (c *AppController) BeforeActivation(b mvc.BeforeActivation) {
-	b.Handle("GET",         "/",                     "GetList"   )
-	b.Handle("GET",         "/page",                 "GetPage"   )
-	b.Handle("GET",         "/{appId:int64}",        "GetById"   )
-	b.Handle("POST",        "/add",                  "Create"    )
-	b.Handle("PUT",         "/update",               "Update"    )
-	b.Handle("DELETE",      "/{appId:int64}",        "DeleteByID")
+	b.Handle("GET",         "/",                                "GetList"       )
+	b.Handle("GET",         "/page",                            "GetPage"       )
+	b.Handle("GET",         "/{appId:int64}",                   "GetById"       )
+	b.Handle("POST",        "/add",                             "Create"        )
+	b.Handle("PUT",         "/update",                          "Update"        )
+	b.Handle("DELETE",      "/{appId:int64}",                   "DeleteByID"    )
+	b.Handle("GET",     "/user/permit",                         "GetPermit"     )
 }
 
 func (c *AppController) GetList() *JsonResult {
@@ -95,3 +96,14 @@ func (c *AppController) DeleteByID(appId int64) *JsonResult {
 		return ResultOk("删除成功", nil)
 	}
 }
+
+func (c *AppController) GetPermit() *JsonResult {
+	roleId := c.GetCurUserRoleId()
+	appKey := c.GetAppKey()
+	data, err := c.Service.GetPermit(roleId, appKey)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}

web/controller/base_controller.go

@@ -93,6 +93,15 @@ func (b *Base) GetOcTypeId() int64 {
 	return ocTypeId
 }
 
+func (b *Base) GetCurUserRoleId() int64 {
+	userId, _ := b.Ctx.Values().GetInt64("userId")
+	userData := GetCurUser(userId)
+	if userData != nil {
+		return userData.RoleId
+	}
+	return 0
+}
+
 func (b *Base) GetAppKey() string {
 	appKey := b.Ctx.Values().GetString("appKey")
 	return appKey

web/controller/upload1_controller.go

@@ -0,0 +1,65 @@
+package controller
+
+import (
+	"github.com/kataras/iris/v12"
+	"github.com/kataras/iris/v12/mvc"
+    services "xps/service"
+	"xps/utils"
+)
+
+type DstFile1 struct {
+	Name string `json:"name"`
+	Src  string `json:"src"`
+}
+
+type Upload1Controller struct {
+	Ctx iris.Context
+	Service   services.UploadService
+}
+
+func (c *Upload1Controller) BeforeActivation(b mvc.BeforeActivation) {
+	b.Handle("POST",    "/file",            "UploadFile"    )
+	b.Handle("POST",    "/files",           "UploadFiles"   )
+	b.Handle("POST",    "/image",           "UploadImage"   )
+	b.Handle("POST",    "/images",          "UploadImages"  )
+}
+
+// UploadFile :Single Upload
+func (c *Upload1Controller) UploadFile() *JsonResult {
+	file, err := utils.UploadFile(c.Ctx)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", file)
+	}
+}
+
+// UploadFiles :Multiple Upload
+func (c *Upload1Controller) UploadFiles() *JsonResult {
+	_, files, err := utils.UploadMultiFiles(c.Ctx)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", files)
+	}
+}
+
+// UploadImage UploadFile :Single Image Upload
+func (c *Upload1Controller) UploadImage() *JsonResult {
+	file, err := utils.UploadFile(c.Ctx)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", file)
+	}
+}
+
+// UploadImages UploadFiles :Multiple Upload
+func (c *Upload1Controller) UploadImages() *JsonResult {
+	_, files, err := utils.UploadMultiFiles(c.Ctx)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", files)
+	}
+}

web/controller/upload_controller.go

@@ -1,65 +1,63 @@
 package controller
 
 import (
-	"github.com/kataras/iris/v12"
-	"github.com/kataras/iris/v12/mvc"
+    "github.com/kataras/iris/v12/mvc"
+    "mime/multipart"
+    "path/filepath"
+    "xps/constant"
     services "xps/service"
-	"xps/utils"
+    "xps/utils"
 )
 
-type DstFile struct {
-	Name string `json:"name"`
-	Src  string `json:"src"`
+type FileData struct {
+    FileInfo *multipart.FileHeader
+    FileData *multipart.File
 }
 
 type UploadController struct {
-	Ctx iris.Context
-	Service   services.UploadService
+    Base
+    Service   services.UploadService
 }
 
 func (c *UploadController) BeforeActivation(b mvc.BeforeActivation) {
-	b.Handle("POST", "/file", "UploadFile")
-	b.Handle("POST", "/files", "UploadFiles")
-	b.Handle("POST", "/image", "UploadImage")
-	b.Handle("POST", "/images", "UploadImages")
+    b.Handle("POST", "/file", "UploadFile")
+    b.Handle("POST", "/files", "UploadFiles")
 }
 
 // UploadFile :Single Upload
 func (c *UploadController) UploadFile() *JsonResult {
-	file, err := utils.UploadFile(c.Ctx)
-	if err != nil {
-		return ResultErr(err.Error(), nil)
-	} else {
-		return ResultOk("获取成功", file)
-	}
+    ocId   := c.GetCurOcId()
+    userId := c.GetCurUserId()
+    f, fh, err := c.Ctx.FormFile("uploadfile")
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    defer f.Close()
+    
+    _, err = c.Ctx.SaveFormFile(fh, filepath.Join("./public/uploads/temp", fh.Filename))
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    
+    fileFullPath := filepath.Join("./public/uploads/temp/", fh.Filename)
+    targetFile := services.TargetFile{
+        FileName: fh.Filename,
+        FilePath: fileFullPath,
+    }
+    file, err := c.Service.UploadFile(ocId, userId, constant.DOC_DIR_TEMP, targetFile)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", file)
+    }
 }
 
 // UploadFiles :Multiple Upload
 func (c *UploadController) UploadFiles() *JsonResult {
-	_, files, err := utils.UploadMultiFiles(c.Ctx)
-	if err != nil {
-		return ResultErr(err.Error(), nil)
-	} else {
-		return ResultOk("获取成功", files)
-	}
-}
-
-// UploadImage UploadFile :Single Image Upload
-func (c *UploadController) UploadImage() *JsonResult {
-	file, err := utils.UploadFile(c.Ctx)
-	if err != nil {
-		return ResultErr(err.Error(), nil)
-	} else {
-		return ResultOk("获取成功", file)
-	}
-}
-
-// UploadImages UploadFiles :Multiple Upload
-func (c *UploadController) UploadImages() *JsonResult {
-	_, files, err := utils.UploadMultiFiles(c.Ctx)
-	if err != nil {
-		return ResultErr(err.Error(), nil)
-	} else {
-		return ResultOk("获取成功", files)
-	}
+    _, files, err := utils.UploadMultiFiles(c.Ctx)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", files)
+    }
 }