func listTagsForWorkingDirectory(store *storage.Storage, showCount, onePerLine bool) error {
file, err := os.Open(".")
if err != nil {
return fmt.Errorf("could not open working directory: %v", err)
}
defer file.Close()
dirNames, err := file.Readdirnames(0)
if err != nil {
return fmt.Errorf("could not list working directory contents: %v", err)
}
sort.Strings(dirNames)
for _, dirName := range dirNames {
log.Infof(2, "%v: retrieving tags.", dirName)
file, err := store.FileByPath(dirName)
if err != nil {
log.Warn(err.Error())
continue
}
if file == nil {
continue
}
fileTags, err := store.FileTagsByFileId(file.Id)
if err != nil {
return fmt.Errorf("could not retrieve file-tags: %v", err)
}
tagNames, err := lookupTagNames(store, fileTags)
if err != nil {
return err
}
if showCount {
fmt.Println(dirName + ": " + strconv.Itoa(len(tagNames)))
} else {
if onePerLine {
fmt.Println(dirName)
for _, tagName := range tagNames {
fmt.Println(tagName)
}
fmt.Println()
} else {
fmt.Println(dirName + ": " + strings.Join(tagNames, " "))
}
}
}
return nil
}
func (command UntagCommand) untagPath(store *storage.Storage, path string, tagIds []uint) error {
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("%v: could not get absolute path: %v", path, err)
}
file, err := store.FileByPath(absPath)
if err != nil {
return fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
if file == nil {
return fmt.Errorf("%v: file is not tagged.", path)
}
for _, tagId := range tagIds {
if command.verbose {
log.Infof("%v: unapplying tag #%v.", file.Path(), tagId)
}
if err := store.RemoveFileTag(file.Id, tagId); err != nil {
return fmt.Errorf("%v: could not remove tag #%v: %v", file.Path(), tagId, err)
}
}
if err := command.removeUntaggedFile(store, file); err != nil {
return err
}
if command.recursive {
childFiles, err := store.FilesByDirectory(file.Path())
if err != nil {
return fmt.Errorf("%v: could not retrieve files for directory: %v", file.Path())
}
for _, childFile := range childFiles {
for _, tagId := range tagIds {
if command.verbose {
log.Infof("%v: unapplying tag #%v.", childFile.Path(), tagId)
}
if err := store.RemoveFileTag(childFile.Id, tagId); err != nil {
return fmt.Errorf("%v: could not remove tag #%v: %v", childFile.Path(), tagId, err)
}
}
if err := command.removeUntaggedFile(store, childFile); err != nil {
return err
}
}
}
return nil
}
func listTagsForPath(store *storage.Storage, path string, showCount, onePerLine bool) error {
log.Infof(2, "%v: retrieving tags.", path)
file, err := store.FileByPath(path)
if err != nil {
return fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
var tagNames []string
if file != nil {
fileTags, err := store.FileTagsByFileId(file.Id)
if err != nil {
return fmt.Errorf("%v: could not retrieve file-tags: %v", path, err)
}
tagNames, err = lookupTagNames(store, fileTags)
if err != nil {
return err
}
} else {
_, err := os.Stat(path)
if err != nil {
switch {
case os.IsPermission(err):
return fmt.Errorf("%v: permission denied", path)
case os.IsNotExist(err):
return fmt.Errorf("%v: no such file", path)
default:
return fmt.Errorf("%v: could not stat file: %v", path, err)
}
}
}
if showCount {
fmt.Println(len(tagNames))
} else {
if onePerLine {
for _, tagName := range tagNames {
fmt.Println(tagName)
}
} else {
format.Columns(tagNames, terminalWidth())
}
}
return nil
}
func tagPath(store *storage.Storage, path string, tagValuePairs []TagValuePair, recursive bool, fingerprintAlgorithm string) error {
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("%v: could not get absolute path: %v", path, err)
}
stat, err := os.Stat(path)
if err != nil {
if os.IsNotExist(err) {
stat, err = os.Lstat(path)
if err != nil {
return err
}
} else {
return err
}
}
log.Infof(2, "%v: checking if file exists", absPath)
file, err := store.FileByPath(absPath)
if err != nil {
return fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
if file == nil {
file, err = addFile(store, absPath, stat.ModTime(), uint(stat.Size()), stat.IsDir(), fingerprintAlgorithm)
if err != nil {
return fmt.Errorf("%v: could not add file: %v", path, err)
}
}
log.Infof(2, "%v: applying tags.", file.Path())
for _, tagValuePair := range tagValuePairs {
if _, err = store.AddFileTag(file.Id, tagValuePair.TagId, tagValuePair.ValueId); err != nil {
return fmt.Errorf("%v: could not apply tags: %v", file.Path(), err)
}
}
if recursive && stat.IsDir() {
if err = tagRecursively(store, path, tagValuePairs, fingerprintAlgorithm); err != nil {
return err
}
}
return nil
}
func (command UntagCommand) untagPathAll(store *storage.Storage, path string) error {
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("%v: could not get absolute path: %v", path, err)
}
file, err := store.FileByPath(absPath)
if err != nil {
return fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
if file == nil {
return fmt.Errorf("%v: file is not tagged.", path)
}
if command.verbose {
log.Infof("%v: removing all tags.", file.Path())
}
if err := store.RemoveFileTagsByFileId(file.Id); err != nil {
return fmt.Errorf("%v: could not remove file's tags: %v", file.Path(), err)
}
if err := command.removeUntaggedFile(store, file); err != nil {
return err
}
if command.recursive {
childFiles, err := store.FilesByDirectory(file.Path())
if err != nil {
return fmt.Errorf("%v: could not retrieve files for directory: %v", file.Path())
}
for _, childFile := range childFiles {
if err := store.RemoveFileTagsByFileId(childFile.Id); err != nil {
return fmt.Errorf("%v: could not remove file's tags: %v", childFile.Path(), err)
}
if err := command.removeUntaggedFile(store, childFile); err != nil {
return err
}
}
}
return nil
}
func (command TagCommand) tagPath(store *storage.Storage, path string, tagIds []uint) error {
absPath, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("%v: could not get absolute path: %v", path, err)
}
stat, err := os.Stat(path)
if err != nil {
switch {
case os.IsPermission(err):
return fmt.Errorf("%v: permisison denied", path)
case os.IsNotExist(err):
return fmt.Errorf("%v: no such file", path)
default:
return fmt.Errorf("%v: could not stat file: %v", path, err)
}
}
file, err := store.FileByPath(absPath)
if err != nil {
return fmt.Errorf("%v: could not retrieve file: %v", path, err)
}
if file == nil {
file, err = command.addFile(store, absPath, stat.ModTime(), uint(stat.Size()), stat.IsDir())
if err != nil {
return fmt.Errorf("%v: could not add file: %v", path, err)
}
}
if command.verbose {
log.Infof("%v: applying tags.", file.Path())
}
if err = store.AddFileTags(file.Id, tagIds); err != nil {
return fmt.Errorf("%v: could not apply tags: %v", file.Path(), err)
}
if command.recursive && stat.IsDir() {
if err = command.tagRecursively(store, path, tagIds); err != nil {
return err
}
}
return nil
}
func enumerateDatabasePaths(store *storage.Storage, paths []string) (databaseFileMap, error) {
dbFiles := make(databaseFileMap, 100)
for _, path := range paths {
file, err := store.FileByPath(path)
if err != nil {
return nil, fmt.Errorf("%v: could not retrieve file from database: %v", path, err)
}
if file != nil {
dbFiles[file.Path()] = *file
}
files, err := store.FilesByDirectory(path)
if err != nil {
return nil, fmt.Errorf("%v: could not retrieve files from database: %v", path, err)
}
for _, file = range files {
dbFiles[file.Path()] = *file
}
}
return dbFiles, nil
}
func listTagsForPaths(store *storage.Storage, paths []string, showCount, onePerLine bool) error {
wereErrors := false
for _, path := range paths {
log.Infof(2, "%v: retrieving tags.", path)
file, err := store.FileByPath(path)
if err != nil {
log.Warn(err.Error())
continue
}
var tagNames []string
if file != nil {
fileTags, err := store.FileTagsByFileId(file.Id)
if err != nil {
return err
}
tagNames, err = lookupTagNames(store, fileTags)
if err != nil {
return err
}
} else {
_, err := os.Stat(path)
if err != nil {
switch {
case os.IsPermission(err):
log.Warnf("%v: permission denied", path)
wereErrors = true
continue
case os.IsNotExist(err):
log.Warnf("%v: no such file", path)
wereErrors = true
continue
default:
return fmt.Errorf("%v: could not stat file: %v", path, err)
}
}
}
if showCount {
fmt.Println(path + ": " + strconv.Itoa(len(tagNames)))
} else {
if onePerLine {
fmt.Println(path)
for _, tagName := range tagNames {
fmt.Println(tagName)
}
fmt.Println()
} else {
fmt.Println(path + ": " + strings.Join(tagNames, " "))
}
}
}
if wereErrors {
return blankError
}
return nil
}
