// GetFiles return all files by appname and prefix
func (service Service) GetFiles(prefix string) ([]*get3w.File, error) {
files := []*get3w.File{}
fileInfos, err := ioutil.ReadDir(prefix)
if err != nil {
return nil, err
}
rootPath := service.GetRootPrefix("")
rel, _ := filepath.Rel(rootPath, prefix)
rel = strings.Replace(rel, (string)(os.PathSeparator), "/", -1)
for _, fileInfo := range fileInfos {
isDir := fileInfo.IsDir()
name := fileInfo.Name()
path := path.Join(rel, name)
size := fileInfo.Size()
checksum := ""
if !isDir {
checksum, _ = service.Checksum(path)
}
lastModified := fileInfo.ModTime()
file := &get3w.File{
IsDir: isDir,
Path: path,
Name: name,
Size: size,
Checksum: checksum,
LastModified: timeutils.ToString(lastModified),
}
files = append(files, file)
}
return files, nil
}
// Save app
func Save() echo.HandlerFunc {
return func(c echo.Context) error {
appPath := c.Param("app_path")
if appPath == "" {
return api.ErrorNotFound(c, nil)
}
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
input := &get3w.AppSaveInput{}
err := api.LoadRequestInput(c, input)
if err != nil {
return api.ErrorBadRequest(c, err)
}
parser, err := storage.NewLocalParser(api.Owner(c), appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
err = parser.APISave(input.Payloads)
if err != nil {
return api.ErrorInternal(c, err)
}
return c.JSON(http.StatusOK, &get3w.AppSaveOutput{
LastModified: timeutils.ToString(time.Now()),
})
}
}
// Delete file
func Delete() echo.HandlerFunc {
return func(c echo.Context) error {
appPath := c.Param("app_path")
if appPath == "" {
return api.ErrorNotFound(c, nil)
}
path := c.P(1)
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
app, err := api.GetApp(appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
if app == nil {
return api.ErrorNotFound(c, nil)
}
parser, err := storage.NewLocalParser(api.Owner(c), appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
parser.Storage.Delete(parser.Storage.GetSourceKey(path))
output := &get3w.FileDeleteOutput{
LastModified: timeutils.ToString(time.Now()),
}
return c.JSON(http.StatusOK, output)
}
}
// Push file content
func Push() echo.HandlerFunc {
return func(c echo.Context) error {
appPath := c.Param("app_path")
if appPath == "" {
return api.ErrorNotFound(c, nil)
}
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
input := &get3w.FilesPushInput{}
err := api.LoadRequestInput(c, input)
if err != nil {
return api.ErrorBadRequest(c, err)
}
app, err := api.GetApp(appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
if app == nil {
return api.ErrorNotFound(c, nil)
}
parser, err := storage.NewLocalParser(api.Owner(c), appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
data, err := base64.StdEncoding.DecodeString(input.Blob)
if err != nil {
return api.ErrorInternal(c, err)
}
pathBytesMap, err := ioutils.UnPack(data)
if err != nil {
return api.ErrorInternal(c, err)
}
for _, addedPath := range input.Added {
parser.Storage.Write(parser.Storage.GetSourceKey(addedPath), pathBytesMap[addedPath])
}
for _, modifiedPath := range input.Modified {
parser.Storage.Write(parser.Storage.GetSourceKey(modifiedPath), pathBytesMap[modifiedPath])
}
for _, removedPath := range input.Removed {
parser.Storage.Delete(parser.Storage.GetSourceKey(removedPath))
}
output := &get3w.FileEditOutput{
LastModified: timeutils.ToString(time.Now()),
}
return c.JSON(http.StatusOK, output)
}
}
// GetFiles return all files by appname and prefix
func (service Service) GetFiles(prefix string) ([]*get3w.File, error) {
files := []*get3w.File{}
params := &s3.ListObjectsInput{
Bucket: aws.String(service.bucketSource), // Required
Prefix: aws.String(prefix),
Delimiter: aws.String("/"),
}
resp, err := service.instance.ListObjects(params)
if err != nil {
return nil, err
}
for _, commonPrefix := range resp.CommonPrefixes {
filePath := strings.Trim(strings.Replace(*commonPrefix.Prefix, service.prefix, "", 1), "/")
name := path.Base(filePath)
dir := &get3w.File{
IsDir: true,
Path: filePath,
Name: name,
}
files = append(files, dir)
}
for _, content := range resp.Contents {
if strings.HasSuffix(*content.Key, "/") {
continue
}
filePath := strings.Trim(strings.Replace(*content.Key, service.prefix, "", 1), "/")
name := path.Base(filePath)
size := *content.Size
checksum := strings.Trim(*content.ETag, "\"")
lastModified := *content.LastModified
file := &get3w.File{
IsDir: false,
Path: filePath,
Name: name,
Size: size,
Checksum: checksum,
LastModified: timeutils.ToString(lastModified),
}
files = append(files, file)
}
return files, nil
}
// Edit file content
func Edit() echo.HandlerFunc {
return func(c echo.Context) error {
appPath := c.Param("app_path")
if appPath == "" {
return api.ErrorNotFound(c, nil)
}
path := c.P(1)
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
input := &get3w.FileEditInput{}
err := api.LoadRequestInput(c, input)
if err != nil {
return api.ErrorBadRequest(c, err)
}
app, err := api.GetApp(appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
if app == nil {
return api.ErrorNotFound(c, nil)
}
parser, err := storage.NewLocalParser(api.Owner(c), appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
data, err := base64.StdEncoding.DecodeString(input.Content)
if err != nil {
return api.ErrorInternal(c, err)
}
err = parser.Storage.Write(parser.Storage.GetSourceKey(path), data)
if err != nil {
return api.ErrorInternal(c, err)
}
output := &get3w.FileEditOutput{
LastModified: timeutils.ToString(time.Now()),
}
return c.JSON(http.StatusOK, output)
}
}
// Create create folder
func Create() echo.HandlerFunc {
return func(c echo.Context) error {
appPath := c.Param("app_path")
if appPath == "" {
return api.ErrorNotFound(c, nil)
}
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
input := &get3w.FolderCreateInput{}
err := api.LoadRequestInput(c, input)
if err != nil {
return api.ErrorBadRequest(c, err)
}
if input.Path == "" {
return api.ErrorBadRequest(c, nil)
}
app, err := api.GetApp(appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
if app == nil {
return api.ErrorNotFound(c, nil)
}
parser, err := storage.NewLocalParser(api.Owner(c), appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
parser.Storage.NewFolder(parser.Storage.GetSourcePrefix(input.Path))
output := &get3w.FolderCreateOutput{
LastModified: timeutils.ToString(time.Now()),
}
return c.JSON(http.StatusOK, output)
}
}
// Load app
func Load() echo.HandlerFunc {
return func(c echo.Context) error {
appPath := c.Param("app_path")
if appPath == "" {
return api.ErrorNotFound(c, nil)
}
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
input := &get3w.AppLoadInput{}
err := api.LoadRequestInput(c, input)
if err != nil {
return api.ErrorBadRequest(c, err)
}
app, err := api.GetApp(appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
if app == nil {
return api.ErrorNotFound(c, nil)
}
parser, err := storage.NewLocalParser(api.Owner(c), appPath)
if err != nil {
return api.ErrorBadRequest(c, err)
}
parser.APILoad()
output := &get3w.AppLoadOutput{
LastModified: timeutils.ToString(time.Now()),
App: app,
Config: parser.Config,
Sites: parser.Sites,
}
return c.JSON(http.StatusOK, output)
}
}
// GetAllFiles return all files by appname
func (service Service) GetAllFiles(prefix string) ([]*get3w.File, error) {
files := []*get3w.File{}
if !service.IsExist(prefix) {
return files, nil
}
err := filepath.Walk(prefix, func(p string, fileInfo os.FileInfo, err error) error {
isDir := fileInfo.IsDir()
name := fileInfo.Name()
path := p[len(service.SourcePath):]
path = filepath.ToSlash(path)
path = strings.Trim(strings.Replace(path, "//", "/", -1), "/")
size := fileInfo.Size()
checksum := ""
if !isDir {
checksum, _ = service.Checksum(path)
}
lastModified := fileInfo.ModTime()
file := &get3w.File{
IsDir: isDir,
Path: path,
Name: name,
Size: size,
Checksum: checksum,
LastModified: timeutils.ToString(lastModified),
}
files = append(files, file)
return nil
})
if err != nil {
return nil, err
}
return files, nil
}
// Add app, for open and clone operation
func Add() echo.HandlerFunc {
return func(c echo.Context) error {
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
owner := api.Owner(c)
input := &get3w.AppAddInput{}
err := api.LoadRequestInput(c, input)
if err != nil {
return api.ErrorBadRequest(c, err)
}
dirPath := input.DirPath
dirExists := true
if dirPath == "" {
dirExists = false
} else {
stat, err := os.Lstat(dirPath)
if err != nil {
dirExists = false
} else if !stat.IsDir() {
dirExists = false
}
}
if !dirExists {
return api.ErrorNotFound(c, nil)
}
config, err := home.LoadConfig()
if err != nil {
return api.ErrorBadRequest(c, err)
}
success := true
configExists := true
var app *get3w.App
var appPath string
if input.Origin != "" {
appPath, err = addFromCloud(dirPath, input.Origin, &config.AuthConfig)
if err != nil {
return api.ErrorBadRequest(c, err)
}
} else {
appPath, configExists, err = addFromLocal(dirPath, config)
if err != nil {
return api.ErrorBadRequest(c, err)
}
}
if input.Check && !configExists {
success = false
}
if success {
parser, err := storage.NewLocalParser(config.AuthConfig.Username, appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
app = &get3w.App{
Owner: owner,
Name: parser.Name,
Description: parser.Config.Description,
Tags: "",
Path: appPath,
Private: false,
CreatedAt: timeutils.ToString(time.Now()),
UpdatedAt: timeutils.ToString(time.Now()),
}
exists := false
for _, app := range config.Apps {
if app.Path == appPath {
exists = true
break
}
}
if !exists {
config.Apps = append(config.Apps, app)
config.Save()
}
}
output := &get3w.AppAddOutput{
Config: configExists,
App: app,
}
return c.JSON(http.StatusOK, output)
}
}
// Upload files
func Upload() echo.HandlerFunc {
return func(c echo.Context) error {
appPath := c.Param("app_path")
if appPath == "" {
return api.ErrorNotFound(c, nil)
}
if api.IsAnonymous(c) {
return api.ErrorUnauthorized(c, nil)
}
location := c.Query("location")
app, err := api.GetApp(appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
if app == nil {
return api.ErrorNotFound(c, nil)
}
parser, err := storage.NewLocalParser(api.Owner(c), appPath)
if err != nil {
return api.ErrorInternal(c, err)
}
req := c.Request().(*standard.Request)
mr, err := req.MultipartReader()
if err != nil {
return api.ErrorInternal(c, err)
}
files := []*get3w.File{}
for {
part, err := mr.NextPart()
if err != nil {
if err == io.EOF {
break
}
return api.ErrorInternal(c, err)
}
defer part.Close()
data, err := ioutil.ReadAll(part)
if err != nil {
return api.ErrorInternal(c, err)
}
filename := part.FileName()
err = parser.Storage.Write(parser.Storage.GetSourceKey(location, filename), data)
if err != nil {
return api.ErrorInternal(c, err)
}
file := &get3w.File{
IsDir: false,
Path: strings.Trim(path.Join(location, filename), "/"),
Name: filename,
Size: 0,
Checksum: "",
LastModified: timeutils.ToString(time.Now()),
}
files = append(files, file)
}
return c.JSON(http.StatusOK, files)
}
}