Example #1
0
File: local.go Project: get3w/get3w
// 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
}
Example #2
0
File: save.go Project: get3w/get3w
// 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()),
		})
	}
}
Example #3
0
// 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)
	}
}
Example #4
0
File: push.go Project: get3w/get3w
// 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)
	}
}
Example #5
0
File: s3.go Project: get3w/get3w
// 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
}
Example #6
0
File: edit.go Project: get3w/get3w
// 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)
	}
}
Example #7
0
// 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)
	}
}
Example #8
0
File: load.go Project: get3w/get3w
// 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)
	}
}
Example #9
0
File: local.go Project: get3w/get3w
// 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
}
Example #10
0
File: add.go Project: get3w/get3w
// 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)
	}
}
Example #11
0
// 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)
	}
}