appydave-tools 0.16.0 → 0.17.0

data/lib/appydave/tools/configuration/models/brands_config.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Configuration
+      module Models
+        # Brands configuration for video project management
+        class BrandsConfig < ConfigBase
+          # Retrieve brand information by brand key (string or symbol)
+          def get_brand(brand_key)
+            brand_key = brand_key.to_s
+            info = data['brands'][brand_key] || default_brand_info
+            BrandInfo.new(brand_key, info)
+          end
+
+          # Set brand information
+          def set_brand(brand_key, brand_info)
+            data['brands'] ||= {}
+            data['brands'][brand_key.to_s] = brand_info.to_h
+          end
+
+          # Retrieve a list of all brands
+          def brands
+            data['brands'].map do |key, info|
+              BrandInfo.new(key, info)
+            end
+          end
+
+          # Get brands for a specific user
+          def get_brands_for_user(user_key)
+            user_key = user_key.to_s
+            brands.select { |brand| brand.team.include?(user_key) }
+          end
+
+          # Get user information
+          def get_user(user_key)
+            user_key = user_key.to_s
+            info = data['users'][user_key] || default_user_info
+            UserInfo.new(user_key, info)
+          end
+
+          # Set user information
+          def set_user(user_key, user_info)
+            data['users'] ||= {}
+            data['users'][user_key.to_s] = user_info.to_h
+          end
+
+          # Retrieve a list of all users
+          def users
+            data['users'].map do |key, info|
+              UserInfo.new(key, info)
+            end
+          end
+
+          def key?(key)
+            key = key.to_s
+            data['brands'].key?(key)
+          end
+
+          def shortcut?(shortcut)
+            shortcut = shortcut.to_s
+            data['brands'].values.any? { |info| info['shortcut'] == shortcut }
+          end
+
+          def print
+            log.heading 'Brands Configuration'
+
+            print_brands = brands.map do |brand|
+              {
+                key: brand.key,
+                name: brand.name,
+                shortcut: brand.shortcut,
+                type: brand.type,
+                youtube_channels: brand.youtube_channels.join(', '),
+                team: brand.team.join(', '),
+                video_projects: print_location(brand.locations.video_projects),
+                ssd_backup: print_location(brand.locations.ssd_backup),
+                aws_profile: brand.aws.profile
+              }
+            end
+
+            tp print_brands, :key, :name, :shortcut, :type, :youtube_channels, :team, :video_projects, :ssd_backup, :aws_profile
+          end
+
+          private
+
+          def print_location(location)
+            return 'Not Set' unless location
+            return 'Not Set' if location.empty?
+
+            File.exist?(location) ? 'TRUE' : 'false'
+          end
+
+          def default_data
+            { 'brands' => {}, 'users' => {} }
+          end
+
+          def default_brand_info
+            {
+              'name' => '',
+              'shortcut' => '',
+              'type' => 'owned',
+              'youtube_channels' => [],
+              'team' => [],
+              'locations' => {
+                'video_projects' => '',
+                'ssd_backup' => ''
+              },
+              'aws' => {
+                'profile' => '',
+                'region' => 'ap-southeast-1',
+                's3_bucket' => '',
+                's3_prefix' => ''
+              },
+              'settings' => {
+                's3_cleanup_days' => 90
+              }
+            }
+          end
+
+          def default_user_info
+            {
+              'name' => '',
+              'email' => '',
+              'role' => 'team_member',
+              'default_aws_profile' => ''
+            }
+          end
+
+          # Type-safe class to access brand properties
+          class BrandInfo
+            attr_accessor :key, :name, :shortcut, :type, :youtube_channels, :team, :locations, :aws, :settings
+
+            def initialize(key, data)
+              @key = key
+              @name = data['name']
+              @shortcut = data['shortcut']
+              @type = data['type'] || 'owned'
+              @youtube_channels = data['youtube_channels'] || []
+              @team = data['team'] || []
+              @locations = BrandLocation.new(data['locations'] || {})
+              @aws = BrandAws.new(data['aws'] || {})
+              @settings = BrandSettings.new(data['settings'] || {})
+            end
+
+            def to_h
+              {
+                'name' => @name,
+                'shortcut' => @shortcut,
+                'type' => @type,
+                'youtube_channels' => @youtube_channels,
+                'team' => @team,
+                'locations' => @locations.to_h,
+                'aws' => @aws.to_h,
+                'settings' => @settings.to_h
+              }
+            end
+          end
+
+          # Type-safe class to access brand location properties
+          class BrandLocation
+            attr_accessor :video_projects, :ssd_backup
+
+            def initialize(data)
+              @video_projects = data['video_projects']
+              @ssd_backup = data['ssd_backup']
+            end
+
+            def to_h
+              {
+                'video_projects' => @video_projects,
+                'ssd_backup' => @ssd_backup
+              }
+            end
+          end
+
+          # Type-safe class to access brand AWS properties
+          class BrandAws
+            attr_accessor :profile, :region, :s3_bucket, :s3_prefix
+
+            def initialize(data)
+              @profile = data['profile']
+              @region = data['region'] || 'ap-southeast-1'
+              @s3_bucket = data['s3_bucket']
+              @s3_prefix = data['s3_prefix']
+            end
+
+            def to_h
+              {
+                'profile' => @profile,
+                'region' => @region,
+                's3_bucket' => @s3_bucket,
+                's3_prefix' => @s3_prefix
+              }
+            end
+          end
+
+          # Type-safe class to access brand settings
+          class BrandSettings
+            attr_accessor :s3_cleanup_days
+
+            def initialize(data)
+              @s3_cleanup_days = data['s3_cleanup_days'] || 90
+            end
+
+            def to_h
+              {
+                's3_cleanup_days' => @s3_cleanup_days
+              }
+            end
+          end
+
+          # Type-safe class to access user properties
+          class UserInfo
+            attr_accessor :key, :name, :email, :role, :default_aws_profile
+
+            def initialize(key, data)
+              @key = key
+              @name = data['name']
+              @email = data['email']
+              @role = data['role'] || 'team_member'
+              @default_aws_profile = data['default_aws_profile']
+            end
+
+            def to_h
+              {
+                'name' => @name,
+                'email' => @email,
+                'role' => @role,
+                'default_aws_profile' => @default_aws_profile
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/configuration/models/config_base.rb

@@ -20,6 +20,13 @@ module Appydave
           end
 
           def save
+            # Create backup if file exists
+            if File.exist?(config_path)
+              backup_path = "#{config_path}.backup.#{Time.now.strftime('%Y%m%d-%H%M%S')}"
+              FileUtils.cp(config_path, backup_path)
+              log.info "Backup created: #{backup_path}" if respond_to?(:log)
+            end
+
             File.write(config_path, JSON.pretty_generate(data))
           end
 

data/lib/appydave/tools/configuration/models/settings_config.rb

@@ -16,6 +16,10 @@ module Appydave
 
           # Well known settings
 
+          def video_projects_root
+            get('video-projects-root')
+          end
+
           def ecamm_recording_folder
             get('ecamm-recording-folder')
           end

data/lib/appydave/tools/vat/config.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Vat
+      # VatConfig - Configuration management for Video Asset Tools
+      #
+      # Manages VIDEO_PROJECTS_ROOT and brand path resolution
+      class Config
+        class << self
+          # Get the root directory for all video projects
+          # @return [String] Absolute path to video-projects directory
+          def projects_root
+            # Use settings.json configuration
+            Appydave::Tools::Configuration::Config.configure
+            root = Appydave::Tools::Configuration::Config.settings.video_projects_root
+
+            return root if root && !root.empty? && Dir.exist?(root)
+
+            # Fall back to auto-detection if not configured
+            detect_projects_root
+          end
+
+          # Get the full path to a brand directory
+          # @param brand_key [String] Brand key (e.g., 'appydave', 'voz')
+          # @return [String] Absolute path to brand directory
+          def brand_path(brand_key)
+            Appydave::Tools::Configuration::Config.configure
+            brand_info = Appydave::Tools::Configuration::Config.brands.get_brand(brand_key)
+
+            # If brand has configured video_projects path, use it
+            return brand_info.locations.video_projects if brand_info.locations.video_projects && !brand_info.locations.video_projects.empty? && Dir.exist?(brand_info.locations.video_projects)
+
+            # Fall back to projects_root + expanded brand name
+            brand = expand_brand(brand_key)
+            path = File.join(projects_root, brand)
+
+            raise "Brand directory not found: #{path}\nAvailable brands: #{available_brands.join(', ')}" unless Dir.exist?(path)
+
+            path
+          end
+
+          # Expand brand shortcut to full brand name
+          # Reads from brands.json if available, falls back to hardcoded shortcuts
+          # @param shortcut [String] Brand shortcut (e.g., 'appydave')
+          # @return [String] Full brand name (e.g., 'v-appydave')
+          def expand_brand(shortcut)
+            return shortcut if shortcut.start_with?('v-')
+
+            # Try to read from brands.json
+            Appydave::Tools::Configuration::Config.configure
+            brands_config = Appydave::Tools::Configuration::Config.brands
+
+            # Check if this shortcut exists in brands.json
+            if brands_config.shortcut?(shortcut)
+              brand = brands_config.brands.find { |b| b.shortcut == shortcut }
+              return "v-#{brand.key}" if brand
+            end
+
+            # Fall back to hardcoded shortcuts for backwards compatibility
+            case shortcut
+            when 'joy' then 'v-beauty-and-joy'
+            when 'ss' then 'v-supportsignal'
+            else
+              "v-#{shortcut}"
+            end
+          end
+
+          # Get list of available brands
+          # Reads from brands.json if available, falls back to filesystem scan
+          # @return [Array<String>] List of brand shortcuts
+          def available_brands
+            Appydave::Tools::Configuration::Config.configure
+            brands_config = Appydave::Tools::Configuration::Config.brands
+
+            # If brands are configured in brands.json, use those
+            configured_brands = brands_config.brands
+            return configured_brands.map(&:shortcut).sort unless configured_brands.empty?
+
+            # Fall back to filesystem scan
+            root = projects_root
+            return [] unless Dir.exist?(root)
+
+            Dir.glob("#{root}/v-*")
+               .select { |path| File.directory?(path) }
+               .reject { |path| File.basename(path) == 'v-shared' } # Exclude infrastructure
+               .select { |path| valid_brand?(path) }
+               .map { |path| File.basename(path) }
+               .map { |brand| brand.sub(/^v-/, '') }
+               .sort
+          end
+
+          # Check if directory is a valid brand
+          # @param brand_path [String] Full path to potential brand directory
+          # @return [Boolean] true if valid brand
+          def valid_brand?(brand_path)
+            # A valid brand is a v-* directory that contains project subdirectories
+            # (This allows brands in development without .video-tools.env yet)
+
+            # Must have at least one subdirectory that looks like a project
+            Dir.glob("#{brand_path}/*")
+               .select { |path| File.directory?(path) }
+               .reject { |path| File.basename(path).start_with?('.', '_') }
+               .any?
+          end
+
+          # Validate that VIDEO_PROJECTS_ROOT is configured
+          # @return [Boolean] true if configured and exists
+          def configured?
+            Appydave::Tools::Configuration::Config.configure
+            root = Appydave::Tools::Configuration::Config.settings.video_projects_root
+            !root.nil? && !root.empty? && Dir.exist?(root)
+          end
+
+          private
+
+          # Auto-detect projects root by finding git repos
+          # @return [String] Detected path or raises error
+          def detect_projects_root
+            # Try to find v-shared in parent directories
+            current = Dir.pwd
+            5.times do
+              test_path = File.join(current, 'v-shared')
+              return File.dirname(test_path) if Dir.exist?(test_path) && Dir.exist?(File.join(test_path, 'video-asset-tools'))
+
+              parent = File.dirname(current)
+              break if parent == current
+
+              current = parent
+            end
+
+            raise <<~ERROR
+              ❌ VIDEO_PROJECTS_ROOT not configured!
+
+              Configure it using:
+                ad_config -e
+
+              Then add to settings.json:
+                "video-projects-root": "/path/to/your/video-projects"
+
+              Or use ad_config command:
+                # (From Ruby console)
+                config = Appydave::Tools::Configuration::Config
+                config.configure
+                config.settings.set('video-projects-root', '/path/to/your/video-projects')
+                config.save
+            ERROR
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/vat/config_loader.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Vat
+      # Configuration loader for video asset tools
+      # Loads settings from .video-tools.env file in the repository root
+      #
+      # Usage:
+      #   config = ConfigLoader.load_from_repo(repo_path)
+      #   ssd_base = config['SSD_BASE']
+      class ConfigLoader
+        class ConfigNotFoundError < StandardError; end
+        class InvalidConfigError < StandardError; end
+
+        CONFIG_FILENAME = '.video-tools.env'
+        REQUIRED_KEYS = %w[SSD_BASE].freeze
+
+        class << self
+          # Load configuration from a repository path
+          # @param repo_path [String] Path to the video project repository
+          # @return [Hash] Configuration hash
+          def load_from_repo(repo_path)
+            config_path = File.join(repo_path, CONFIG_FILENAME)
+
+            unless File.exist?(config_path)
+              raise ConfigNotFoundError, <<~ERROR
+                ❌ Configuration file not found: #{config_path}
+
+                Create a .video-tools.env file in your repository root with:
+
+                SSD_BASE=/Volumes/T7/youtube-PUBLISHED/appydave
+
+                See .env.example for a full template.
+              ERROR
+            end
+
+            config = parse_env_file(config_path)
+            validate_config!(config)
+            config
+          end
+
+          private
+
+          # Parse a .env file into a hash
+          # @param file_path [String] Path to .env file
+          # @return [Hash] Parsed key-value pairs
+          def parse_env_file(file_path)
+            config = {}
+
+            File.readlines(file_path).each do |line|
+              line = line.strip
+
+              # Skip comments and empty lines
+              next if line.empty? || line.start_with?('#')
+
+              # Parse KEY=value
+              next unless line =~ /^([A-Z_]+)=(.*)$/
+
+              key = ::Regexp.last_match(1)
+              value = ::Regexp.last_match(2)
+
+              # Remove quotes if present
+              value = value.gsub(/^["']|["']$/, '')
+
+              config[key] = value
+            end
+
+            config
+          end
+
+          # Validate required configuration keys
+          # @param config [Hash] Configuration to validate
+          # @raise [InvalidConfigError] if required keys are missing
+          def validate_config!(config)
+            missing_keys = REQUIRED_KEYS - config.keys
+
+            return if missing_keys.empty?
+
+            raise InvalidConfigError, <<~ERROR
+              ❌ Missing required configuration keys: #{missing_keys.join(', ')}
+
+              Your .video-tools.env must include:
+              #{REQUIRED_KEYS.map { |k| "  #{k}=..." }.join("\n")}
+            ERROR
+          end
+        end
+      end
+    end
+  end
+end