feat: adjusting the interface execution logic via json

pkg/cmd/delete/edge_storage/bucket.go

@@ -51,16 +51,20 @@ func (b *bucket) runE(cmd *cobra.Command, _ []string) error {
 	err := client.DeleteBucket(ctx, b.name)
 	if err != nil {
 		if msg.ERROR_NO_EMPTY_BUCKET == err.Error() {
-			if utils.Confirm(b.factory.GlobalFlagAll, msg.ASK_NOT_EMPTY_BUCKET, false) || b.force {
-				logger.Info("Delete all objects bucket", zap.Any("bucket-name", b.name))
-				if err := deleteAllObjects(client, ctx, b.name, ""); err != nil {
-					return err
-				}
-				err := client.DeleteBucket(ctx, b.name)
-				if msg.ERROR_NO_EMPTY_BUCKET == err.Error() {
-					return schedule.NewSchedule(b.name, schedule.DeleteBucket{Name: b.name, Factory: b.factory})	
+			if !b.force {
+				if !utils.Confirm(b.factory.GlobalFlagAll, msg.ASK_NOT_EMPTY_BUCKET, false) {
+					return nil
 				}
 			}
+			logger.Info("Delete all objects bucket", zap.Any("bucket-name", b.name))
+			if err := deleteAllObjects(client, ctx, b.name, ""); err != nil {
+				return err
+			}
+			err := client.DeleteBucket(ctx, b.name)
+			if msg.ERROR_NO_EMPTY_BUCKET == err.Error() {
+				logger.Info("schedules a delete for the bucket", zap.Any("bucket-name", b.name))
+				return schedule.NewSchedule(b.name, schedule.DELETE_BUCKET)	
+			}
 			return nil
 		}
 		return fmt.Errorf(msg.ERROR_DELETE_BUCKET, err.Error())
@@ -81,16 +85,10 @@ func (f *bucket) addFlags(flags *pflag.FlagSet) {
 }
 
 func deleteAllObjects(client *api.Client, ctx context.Context, name, continuationToken string) error {
-	// maxWorkers := 10 
-	// workerChan := make(chan struct{}, maxWorkers)
-
 	objects, err := client.ListObject(ctx, name, &contracts.ListOptions{ContinuationToken: continuationToken})
 	if err != nil {
 		return err
 	}
-
-	// errChan := make(chan error, len(objects.GetResults()))
-
 	if len(objects.GetResults()) > 0 {
 		for _, o := range objects.GetResults() {
 			err := client.DeleteObject(ctx, name, o.GetKey())

pkg/cmd/root/root.go

@@ -79,7 +79,7 @@ func NewCobraCmd(rootCmd *RootCmd, f *cmdutil.Factory) *cobra.Command {
 			if strings.HasPrefix(configFlag, PREFIX_FLAG) {
 				return msg.ErrorPrefix
 			}
-			schedule.ExecSchedules()
+			schedule.ExecSchedules(f)
 			return doPreCommandCheck(cmd, f, PreCmd{
 				config: configFlag,
 				token:  tokenFlag,

pkg/schedule/bucket.go

@@ -8,16 +8,13 @@ import (
 	api "github.com/aziontech/azion-cli/pkg/api/storage"
 )
 
-type DeleteBucket struct {
-	Factory *cmdutil.Factory
-	Name    string
-}
+const DELETE_BUCKET = "DeleteBucket" 
 
-func (b DeleteBucket) TriggerEvent() error {
+func TriggerDeleteBucket(f *cmdutil.Factory, name string) error {
 	client := api.NewClient(
-		b.Factory.HttpClient,
-		b.Factory.Config.GetString("storage_url"),
-		b.Factory.Config.GetString("token"))
+		f.HttpClient,
+		f.Config.GetString("storage_url"),
+		f.Config.GetString("token"))
 	ctx := context.Background()
-	return client.DeleteBucket(ctx, b.Name)
+	return client.DeleteBucket(ctx, name)
 }

pkg/schedule/schedule.go

@@ -2,32 +2,27 @@ package schedule
 
 import (
 	"encoding/json"
-	"fmt"
 	"os"
 	"path/filepath"
-	"sync"
 	"time"
 
+	"github.com/aziontech/azion-cli/pkg/cmdutil"
 	"github.com/aziontech/azion-cli/pkg/config"
 	"github.com/aziontech/azion-cli/pkg/logger"
 	"go.uber.org/zap"
 )
 
 type Schedule struct {
-	Name   string           `json:"name"`
-	Time   time.Time        `json:"time"` // schedule creation time
-	Object SheduleInterface `json:"object"`
+	Name string    `json:"name"`
+	Time time.Time `json:"time"` // schedule creation time
+	Kind string    `json:"kind"`
 }
 
-type SheduleInterface interface {
-	TriggerEvent() error
-}
-
-func NewSchedule(name string, object SheduleInterface) error {
+func NewSchedule(name string, kind string) error {
 	schedule := Schedule{
-		Name:   name,
-		Time:   time.Now(),
-		Object: object,
+		Name: name,
+		Time: time.Now(),
+		Kind: kind,
 	}
 
 	schedules, err := readFileShedule()
@@ -46,19 +41,15 @@ func NewSchedule(name string, object SheduleInterface) error {
 }
 
 func createFileShedule(shedule []Schedule) error {
-	fmt.Println(">> here: ", shedule)
 	b, err := json.MarshalIndent(shedule, "	", " ")
 	if err != nil {
-		fmt.Println(">>> err:", err.Error())
 		return err
 	}
-	fmt.Println(">> b: ", b)
 	configPath, err := config.Dir()
 	if err != nil {
 		return err
 	}
 	path := filepath.Join(configPath.Dir, configPath.Schedule)
-	fmt.Println(">> path: ", path)
 	return os.WriteFile(path, b, os.FileMode(os.O_CREATE))
 }
 
@@ -101,39 +92,27 @@ func readFileShedule() ([]Schedule, error) {
 	return schedules, nil
 }
 
-func ExecSchedules() {
+func ExecSchedules(factory *cmdutil.Factory) {
 	schedules, err := readFileShedule()
 	if err != nil {
 		logger.Debug("read shedule error", zap.Error(err))
 		return
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(len(schedules))
-	errChan := make(chan error, len(schedules))
+	}	
 
 	for _, s := range schedules {
-		go func(s Schedule) {
-			defer wg.Done()
-
-			// Checks if the current time is before 24 hours after the time 's'.
-			if time.Now().Before(s.Time.Add(24*time.Hour)) {
-				if err := s.Object.TriggerEvent(); err != nil {
-					errChan <- err
+		if CheckIf24HoursPassed(s.Time) {
+			if s.Kind == DELETE_BUCKET {
+				if err := TriggerDeleteBucket(factory, s.Name); err != nil {
+					logger.Debug("event execution error", zap.Error(err))
 				}
 			}
-		}(s)
+		}
 	}
-	wg.Wait()
-
-	go func() {
-		wg.Wait()
-		close(errChan)
-	}()
+}
 
-	go func() {
-		for err := range errChan {
-			logger.Debug("event execution error", zap.Error(err))
-		}
-	}()
+// CheckIf24HoursPassed Checks if the current time is before 24 hours after the time 's'.
+func CheckIf24HoursPassed(passed time.Time) bool {
+	now := time.Now()
+	diff := now.Sub(passed)
+	return diff >= 24*time.Hour
 }