feat:implement-include-type (#10)

* feat:implement-include-type

* bugfix:deal with duplicate extensions

* bugfix:extract code from prerun

* bugfix:import DefaultSupportedMedia from supported.go

* feat:use set function instead of prerun

* refactor: Implement IncludeType

A type IncludeType has been implemented as the type for the possible
values for the include-type flag. The conversion to extensions to
include is done in a PreRun function. A function has been added
 to get the DefaultSupportedMedia as a map from a media type to a list
of extensions.

* docs: Add documentation for functions and reorder code

Add simple explanation for funciton calls and reorder to keep the types
at the top to introduce the types before the user reads them. Also
document undocumented public functions or functions with importance to
reduce code complexity overhead.

close issue#9 #5 
---------

Co-authored-by: Hugo Sacilotto <[email protected]>
Co-authored-by: Hex4C <[email protected]>

Author: 3 people

internal/cliFlags/extensionList.go

@@ -1,22 +1,54 @@
 package cliflags
 
 import (
+	"fmt"
 	"slices"
 	"strings"
 
+	"github.com/simulot/immich-go/internal/filetypes"
 	"github.com/spf13/cobra"
 )
 
 type InclusionFlags struct {
 	ExcludedExtensions ExtensionList
 	IncludedExtensions ExtensionList
+	IncludedType       IncludeType
 	DateRange          DateRange
 }
 
+// An IncludeType is either of the constants below which
+// represents a collection of extensions.
+type IncludeType string
+
+const (
+	IncludeAll   IncludeType = ""
+	IncludeVideo IncludeType = "VIDEO"
+	IncludeImage IncludeType = "IMAGE"
+)
+
 func AddInclusionFlags(cmd *cobra.Command, flags *InclusionFlags) {
 	cmd.Flags().Var(&flags.DateRange, "date-range", "Only import photos taken within the specified date range")
 	cmd.Flags().Var(&flags.ExcludedExtensions, "exclude-extensions", "Comma-separated list of extension to exclude. (e.g. .gif,.PM) (default: none)")
 	cmd.Flags().Var(&flags.IncludedExtensions, "include-extensions", "Comma-separated list of extension to include. (e.g. .jpg,.heic) (default: all)")
+	cmd.Flags().Var(&flags.IncludedType, "include-type", "Single file type to include. (VIDEO or IMAGE) (default: all)")
+	cmd.PreRun = func(cmd *cobra.Command, args []string) {
+		if cmd.Flags().Changed("include-type") {
+			setIncludeTypeExtensions(flags)
+		}
+	}
+}
+
+// Add the approprite extensions flags given the user inclusion flag
+func setIncludeTypeExtensions(flags *InclusionFlags) {
+	mediaToExtensionsMap := filetypes.MediaToExtensions()
+
+	switch flags.IncludedType {
+	case IncludeVideo:
+		flags.IncludedExtensions = append(flags.IncludedExtensions, mediaToExtensionsMap[filetypes.TypeVideo]...)
+	case IncludeImage:
+		flags.IncludedExtensions = append(flags.IncludedExtensions, mediaToExtensionsMap[filetypes.TypeImage]...)
+	}
+	flags.IncludedExtensions = append(flags.IncludedExtensions, mediaToExtensionsMap[filetypes.TypeSidecar]...)
 }
 
 // Validate validates the common flags.
@@ -25,6 +57,26 @@ func (flags *InclusionFlags) Validate() {
 	flags.IncludedExtensions = flags.IncludedExtensions.Validate()
 }
 
+// Implements the flag interface
+func (t *IncludeType) Set(v string) error {
+	v = strings.TrimSpace(strings.ToUpper(v))
+	switch v {
+	case string(IncludeVideo), string(IncludeImage):
+		*t = IncludeType(v)
+	default:
+		return fmt.Errorf("invalid value for include type, expected %s or %s", IncludeVideo, IncludeImage)
+	}
+	return nil
+}
+
+func (t IncludeType) String() string {
+	return string(t)
+}
+
+func (t IncludeType) Type() string {
+	return "IncludeType"
+}
+
 // An ExtensionList is a list of file extensions, where each extension is a string that starts with a dot (.) and is in lowercase.
 type ExtensionList []string
 

internal/filetypes/supported.go

@@ -73,6 +73,18 @@ func (sm SupportedMedia) IsIgnoredExt(ext string) bool {
 	return t == ""
 }
 
+// MediaToExtensions defines a map from mediaType to mediaExtensions
+// returns the map with the format map[mediatype] = extensions
+func MediaToExtensions() map[string][]string {
+	reversedMap := make(map[string][]string)
+
+	for ext, mediaType := range DefaultSupportedMedia {
+		reversedMap[mediaType] = append(reversedMap[mediaType], ext)
+	}
+
+	return reversedMap
+}
+
 // rawExtensions defines the supported RAW file extensions
 // https://github.com/immich-app/immich/blob/39b571a95c99cbc4183e5d389e6d682cd8e903d9/server/src/utils/mime-types.ts#L1-L55
 // source: https://en.wikipedia.org/wiki/Raw_image_format