Admin UI: Add policies (#6968)

* add policies to UI, accessing filer directly

* view, edit policies

* add back buttons for "users" page

* remove unused

* fix ui dark mode when modal is closed

* bucket view details button

* fix browser buttons

* filer action button works

* clean up masters page

* fix volume servers action buttons

* fix collections page action button

* fix properties page

* more obvious

* fix directory creation file mode

* Update file_browser_handlers.go

* directory permission

1 files changed, 0 insertions, 319 deletions

diff --git a/weed/worker/tasks/erasure_coding/ui_templ.go b/weed/worker/tasks/erasure_coding/ui_templ.go
deleted file mode 100644
index 12c3d199e..000000000
--- a/weed/worker/tasks/erasure_coding/ui_templ.go
+++ /dev/null
@@ -1,319 +0,0 @@
-package erasure_coding
-
-import (
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/seaweedfs/seaweedfs/weed/admin/view/components"
-	"github.com/seaweedfs/seaweedfs/weed/glog"
-	"github.com/seaweedfs/seaweedfs/weed/worker/types"
-)
-
-// Helper function to format seconds as duration string
-func formatDurationFromSeconds(seconds int) string {
-	d := time.Duration(seconds) * time.Second
-	return d.String()
-}
-
-// Helper function to convert value and unit to seconds
-func valueAndUnitToSeconds(value float64, unit string) int {
-	switch unit {
-	case "days":
-		return int(value * 24 * 60 * 60)
-	case "hours":
-		return int(value * 60 * 60)
-	case "minutes":
-		return int(value * 60)
-	default:
-		return int(value * 60) // Default to minutes
-	}
-}
-
-// UITemplProvider provides the templ-based UI for erasure coding task configuration
-type UITemplProvider struct {
-	detector  *EcDetector
-	scheduler *Scheduler
-}
-
-// NewUITemplProvider creates a new erasure coding templ UI provider
-func NewUITemplProvider(detector *EcDetector, scheduler *Scheduler) *UITemplProvider {
-	return &UITemplProvider{
-		detector:  detector,
-		scheduler: scheduler,
-	}
-}
-
-// ErasureCodingConfig is defined in ui.go - we reuse it
-
-// GetTaskType returns the task type
-func (ui *UITemplProvider) GetTaskType() types.TaskType {
-	return types.TaskTypeErasureCoding
-}
-
-// GetDisplayName returns the human-readable name
-func (ui *UITemplProvider) GetDisplayName() string {
-	return "Erasure Coding"
-}
-
-// GetDescription returns a description of what this task does
-func (ui *UITemplProvider) GetDescription() string {
-	return "Converts replicated volumes to erasure-coded format for efficient storage"
-}
-
-// GetIcon returns the icon CSS class for this task type
-func (ui *UITemplProvider) GetIcon() string {
-	return "fas fa-shield-alt text-info"
-}
-
-// RenderConfigSections renders the configuration as templ section data
-func (ui *UITemplProvider) RenderConfigSections(currentConfig interface{}) ([]components.ConfigSectionData, error) {
-	config := ui.getCurrentECConfig()
-
-	// Detection settings section
-	detectionSection := components.ConfigSectionData{
-		Title:       "Detection Settings",
-		Icon:        "fas fa-search",
-		Description: "Configure when erasure coding tasks should be triggered",
-		Fields: []interface{}{
-			components.CheckboxFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:        "enabled",
-					Label:       "Enable Erasure Coding Tasks",
-					Description: "Whether erasure coding tasks should be automatically created",
-				},
-				Checked: config.Enabled,
-			},
-			components.DurationInputFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:        "scan_interval",
-					Label:       "Scan Interval",
-					Description: "How often to scan for volumes needing erasure coding",
-					Required:    true,
-				},
-				Seconds: config.ScanIntervalSeconds,
-			},
-			components.DurationInputFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:        "volume_age_threshold",
-					Label:       "Volume Age Threshold",
-					Description: "Only apply erasure coding to volumes older than this age",
-					Required:    true,
-				},
-				Seconds: config.VolumeAgeHoursSeconds,
-			},
-		},
-	}
-
-	// Erasure coding parameters section
-	paramsSection := components.ConfigSectionData{
-		Title:       "Erasure Coding Parameters",
-		Icon:        "fas fa-cogs",
-		Description: "Configure erasure coding scheme and performance",
-		Fields: []interface{}{
-			components.NumberFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:        "data_shards",
-					Label:       "Data Shards",
-					Description: "Number of data shards in the erasure coding scheme",
-					Required:    true,
-				},
-				Value: float64(config.ShardCount),
-				Step:  "1",
-				Min:   floatPtr(1),
-				Max:   floatPtr(16),
-			},
-			components.NumberFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:        "parity_shards",
-					Label:       "Parity Shards",
-					Description: "Number of parity shards (determines fault tolerance)",
-					Required:    true,
-				},
-				Value: float64(config.ParityCount),
-				Step:  "1",
-				Min:   floatPtr(1),
-				Max:   floatPtr(16),
-			},
-			components.NumberFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:        "max_concurrent",
-					Label:       "Max Concurrent Tasks",
-					Description: "Maximum number of erasure coding tasks that can run simultaneously",
-					Required:    true,
-				},
-				Value: float64(config.MaxConcurrent),
-				Step:  "1",
-				Min:   floatPtr(1),
-			},
-		},
-	}
-
-	// Performance impact info section
-	infoSection := components.ConfigSectionData{
-		Title:       "Performance Impact",
-		Icon:        "fas fa-info-circle",
-		Description: "Important information about erasure coding operations",
-		Fields: []interface{}{
-			components.TextFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:  "durability_info",
-					Label: "Durability",
-					Description: fmt.Sprintf("With %d+%d configuration, can tolerate up to %d shard failures",
-						config.ShardCount, config.ParityCount, config.ParityCount),
-				},
-				Value: "High durability with space efficiency",
-			},
-			components.TextFieldData{
-				FormFieldData: components.FormFieldData{
-					Name:        "performance_info",
-					Label:       "Performance Note",
-					Description: "Erasure coding is CPU and I/O intensive. Consider running during off-peak hours",
-				},
-				Value: "Schedule during low-traffic periods",
-			},
-		},
-	}
-
-	return []components.ConfigSectionData{detectionSection, paramsSection, infoSection}, nil
-}
-
-// ParseConfigForm parses form data into configuration
-func (ui *UITemplProvider) ParseConfigForm(formData map[string][]string) (interface{}, error) {
-	config := &ErasureCodingConfig{}
-
-	// Parse enabled checkbox
-	config.Enabled = len(formData["enabled"]) > 0 && formData["enabled"][0] == "on"
-
-	// Parse volume age threshold
-	if valueStr := formData["volume_age_threshold"]; len(valueStr) > 0 {
-		if value, err := strconv.ParseFloat(valueStr[0], 64); err != nil {
-			return nil, fmt.Errorf("invalid volume age threshold value: %v", err)
-		} else {
-			unit := "hours" // default
-			if unitStr := formData["volume_age_threshold_unit"]; len(unitStr) > 0 {
-				unit = unitStr[0]
-			}
-			config.VolumeAgeHoursSeconds = valueAndUnitToSeconds(value, unit)
-		}
-	}
-
-	// Parse scan interval
-	if valueStr := formData["scan_interval"]; len(valueStr) > 0 {
-		if value, err := strconv.ParseFloat(valueStr[0], 64); err != nil {
-			return nil, fmt.Errorf("invalid scan interval value: %v", err)
-		} else {
-			unit := "hours" // default
-			if unitStr := formData["scan_interval_unit"]; len(unitStr) > 0 {
-				unit = unitStr[0]
-			}
-			config.ScanIntervalSeconds = valueAndUnitToSeconds(value, unit)
-		}
-	}
-
-	// Parse data shards
-	if shardsStr := formData["data_shards"]; len(shardsStr) > 0 {
-		if shards, err := strconv.Atoi(shardsStr[0]); err != nil {
-			return nil, fmt.Errorf("invalid data shards: %v", err)
-		} else if shards < 1 || shards > 16 {
-			return nil, fmt.Errorf("data shards must be between 1 and 16")
-		} else {
-			config.ShardCount = shards
-		}
-	}
-
-	// Parse parity shards
-	if shardsStr := formData["parity_shards"]; len(shardsStr) > 0 {
-		if shards, err := strconv.Atoi(shardsStr[0]); err != nil {
-			return nil, fmt.Errorf("invalid parity shards: %v", err)
-		} else if shards < 1 || shards > 16 {
-			return nil, fmt.Errorf("parity shards must be between 1 and 16")
-		} else {
-			config.ParityCount = shards
-		}
-	}
-
-	// Parse max concurrent
-	if concurrentStr := formData["max_concurrent"]; len(concurrentStr) > 0 {
-		if concurrent, err := strconv.Atoi(concurrentStr[0]); err != nil {
-			return nil, fmt.Errorf("invalid max concurrent: %v", err)
-		} else if concurrent < 1 {
-			return nil, fmt.Errorf("max concurrent must be at least 1")
-		} else {
-			config.MaxConcurrent = concurrent
-		}
-	}
-
-	return config, nil
-}
-
-// GetCurrentConfig returns the current configuration
-func (ui *UITemplProvider) GetCurrentConfig() interface{} {
-	return ui.getCurrentECConfig()
-}
-
-// ApplyConfig applies the new configuration
-func (ui *UITemplProvider) ApplyConfig(config interface{}) error {
-	ecConfig, ok := config.(*ErasureCodingConfig)
-	if !ok {
-		return fmt.Errorf("invalid config type, expected *ErasureCodingConfig")
-	}
-
-	// Apply to detector
-	if ui.detector != nil {
-		ui.detector.SetEnabled(ecConfig.Enabled)
-		ui.detector.SetVolumeAgeHours(ecConfig.VolumeAgeHoursSeconds)
-		ui.detector.SetScanInterval(time.Duration(ecConfig.ScanIntervalSeconds) * time.Second)
-	}
-
-	// Apply to scheduler
-	if ui.scheduler != nil {
-		ui.scheduler.SetMaxConcurrent(ecConfig.MaxConcurrent)
-		ui.scheduler.SetEnabled(ecConfig.Enabled)
-	}
-
-	glog.V(1).Infof("Applied erasure coding configuration: enabled=%v, age_threshold=%ds, max_concurrent=%d",
-		ecConfig.Enabled, ecConfig.VolumeAgeHoursSeconds, ecConfig.MaxConcurrent)
-
-	return nil
-}
-
-// getCurrentECConfig gets the current configuration from detector and scheduler
-func (ui *UITemplProvider) getCurrentECConfig() *ErasureCodingConfig {
-	config := &ErasureCodingConfig{
-		// Default values (fallback if detectors/schedulers are nil)
-		Enabled:               true,
-		VolumeAgeHoursSeconds: int((24 * time.Hour).Seconds()),
-		ScanIntervalSeconds:   int((2 * time.Hour).Seconds()),
-		MaxConcurrent:         1,
-		ShardCount:            10,
-		ParityCount:           4,
-	}
-
-	// Get current values from detector
-	if ui.detector != nil {
-		config.Enabled = ui.detector.IsEnabled()
-		config.VolumeAgeHoursSeconds = ui.detector.GetVolumeAgeHours()
-		config.ScanIntervalSeconds = int(ui.detector.ScanInterval().Seconds())
-	}
-
-	// Get current values from scheduler
-	if ui.scheduler != nil {
-		config.MaxConcurrent = ui.scheduler.GetMaxConcurrent()
-	}
-
-	return config
-}
-
-// floatPtr is a helper function to create float64 pointers
-func floatPtr(f float64) *float64 {
-	return &f
-}
-
-// RegisterUITempl registers the erasure coding templ UI provider with the UI registry
-func RegisterUITempl(uiRegistry *types.UITemplRegistry, detector *EcDetector, scheduler *Scheduler) {
-	uiProvider := NewUITemplProvider(detector, scheduler)
-	uiRegistry.RegisterUI(uiProvider)
-
-	glog.V(1).Infof("✅ Registered erasure coding task templ UI provider")
-}