wip

Author: orltom

.gitignore

@@ -30,4 +30,5 @@ go.work.sum
 
 # build
 /ocs
+/ocsctl
 /demo.json

README.md

@@ -2,18 +2,22 @@
 [![License](https://img.shields.io/github/license/orltom/on-call-schedule)](/LICENSE)
 
 # On-Call Schedule
-It helps to create or synchronize on-call schedules for team members, allowing users to define custom rules or use 
+It helps to create or synchronize on-call schedules, allowing users to define custom rules or use 
 predefined ones. Important factors, such as absences due to holidays or other time off, are automatically considered.
 
-## Usage
+## Create on-call schedule plan
+
+
+### Usage
 Here is an example of how to create an on-call duty plan
 ```shell
-> cat > demo.json << EOL
+cat > demo.json << EOL
 {
   "employees": [
     {"id": "joe@example.com", "name": "Joe"},
     {"id": "jan@example.com", "name": "Jan", "vacationDays": ["2024-01-06","2024-01-07"]},
-    {"id": "lee@example.com", "name": "Lee"}
+    {"id": "lee@example.com", "name": "Lee"},
+    {"id": "eva@example.com", "name": "Eva"}
   ]
 }
 EOL

cmd/create_command.go

@@ -6,6 +6,7 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/orltom/on-call-schedule/internal/cli"
@@ -41,20 +42,22 @@ func RunCreateShiftPlan(arguments []string) error {
 		},
 	}
 
-	str := new(time.Time)
+	start := new(time.Time)
 	end := new(time.Time)
+	enabledRules := new(string)
 	duration := new(int)
 	teamFilePath := new(string)
 	transform := Table
 	var showHelp bool
 
 	createCommand := flag.NewFlagSet("create", flag.ExitOnError)
 	createCommand.BoolVar(&showHelp, "h", false, "help for ocsctl create")
-	createCommand.IntVar(duration, "duration", 7*24, "shift duration in hours.")
-	createCommand.Func("start", "(required) start time of the schedule plan", cli.TimeValueVar(str))
+	createCommand.IntVar(duration, "duration", 7*24, "shift duration in hours")
+	createCommand.Func("start", "(required) start time of the schedule plan", cli.TimeValueVar(start))
 	createCommand.Func("end", "(required) end time of the schedule plan", cli.TimeValueVar(end))
 	createCommand.Func("team-file", "(required) path to the file that contain all on-call duties", cli.FilePathVar(teamFilePath))
 	createCommand.Func("output", "output format. One of (cvs, table, json)", cli.EnumValueVar(enums, &transform))
+	createCommand.StringVar(enabledRules, "enabled-rules", "vacation", "Rule to decide which employee should be on-call for the next shift")
 	createCommand.Usage = func() {
 		fmt.Fprintf(os.Stdout, "Create on-call schedule\n")
 		fmt.Fprintf(os.Stdout, "\nUsage\n")
@@ -66,7 +69,7 @@ func RunCreateShiftPlan(arguments []string) error {
 
 	if err := createCommand.Parse(arguments); err != nil {
 		createCommand.Usage()
-		return fmt.Errorf("could not parse CLI arguments: %w", err)
+		return fmt.Errorf("could not readTeamFile CLI arguments: %w", err)
 	}
 
 	if showHelp {
@@ -75,34 +78,23 @@ func RunCreateShiftPlan(arguments []string) error {
 	}
 
 	// check that the required flags are set...
-	if !cli.IsFlagPassed(createCommand, "start") {
+	if ok, missed := cli.RequiredFlagPassed(createCommand, "start", "end", "team-file"); !ok {
 		createCommand.Usage()
-		return fmt.Errorf("%w: %s", ErrMissingArguments, "start")
-	}
-
-	if !cli.IsFlagPassed(createCommand, "end") {
-		createCommand.Usage()
-		return fmt.Errorf("%w: %s", ErrMissingArguments, "end")
-	}
-
-	if !cli.IsFlagPassed(createCommand, "team-file") {
-		createCommand.Usage()
-		return fmt.Errorf("%w: %s", ErrMissingArguments, "team-file")
-	}
-
-	// validate input data...
-	if str == end {
-		createCommand.Usage()
-		return ErrInvalidArgument
+		return fmt.Errorf("%w: %s", ErrMissingArguments, strings.Join(missed, ","))
 	}
 
 	// initialize and run...
-	team, err := parse(*teamFilePath)
+	team, err := readTeamFile(*teamFilePath)
 	if err != nil {
 		return fmt.Errorf("%w: invalid team config file: %w", ErrInvalidArgument, err)
 	}
 
-	plan, err := shiftplan.NewDefaultShiftPlanner(team.Employees).Plan(*str, *end, time.Duration(*duration)*time.Hour)
+	rules, err := readRules(*enabledRules)
+	if err != nil {
+		return fmt.Errorf("%w: invalid rules: %w", ErrInvalidArgument, err)
+	}
+
+	plan, err := shiftplan.NewShiftPlanner(team.Employees, rules, rules).Plan(*start, *end, time.Duration(*duration)*time.Hour)
 	if err != nil {
 		return fmt.Errorf("can not create on-call schedule: %w", err)
 	}
@@ -114,16 +106,37 @@ func RunCreateShiftPlan(arguments []string) error {
 	return nil
 }
 
-func parse(path string) (apis.Team, error) {
+func readTeamFile(path string) (apis.Team, error) {
 	content, err := os.ReadFile(path)
 	if err != nil {
 		return apis.Team{}, fmt.Errorf("could not read file '%s': %w", path, err)
 	}
 
 	var team apis.Team
 	if err := json.Unmarshal(content, &team); err != nil {
-		return apis.Team{}, fmt.Errorf("could not pars json file '%s': %w", path, err)
+		return apis.Team{}, fmt.Errorf("could not parse json file '%s': %w", path, err)
 	}
 
 	return team, nil
 }
+
+func readRules(value string) ([]apis.Rule, error) {
+	var rules []apis.Rule
+	for _, s := range strings.Split(value, ",") {
+		switch strings.ToLower(s) {
+		case "vacation":
+			rules = append(rules, shiftplan.NoVacationOverlap())
+		case "minimumoneshiftgap":
+			rules = append(rules, shiftplan.MinimumOneShiftGap())
+		case "minimumtwoshiftgap":
+			rules = append(rules, shiftplan.MinimumTwoShiftGap())
+		case "minimumthreeshiftgap":
+			rules = append(rules, shiftplan.MinimumThreeShiftGap())
+		case "minimumfourshiftgap":
+			rules = append(rules, shiftplan.MinimumFourShiftGap())
+		default:
+			return nil, fmt.Errorf("unknow rule: %s", s)
+		}
+	}
+	return rules, nil
+}

internal/cli/flagset_helper.go

@@ -10,14 +10,21 @@ import (
 	"time"
 )
 
-func IsFlagPassed(f *flag.FlagSet, name string) bool {
-	found := false
-	f.Visit(func(f *flag.Flag) {
-		if f.Name == name {
-			found = true
-		}
+func RequiredFlagPassed(f *flag.FlagSet, names ...string) (bool, []string) {
+	var missedFlags []string
+	visited := make(map[string]bool)
+
+	f.Visit(func(fl *flag.Flag) {
+		visited[fl.Name] = true
 	})
-	return found
+
+	for _, name := range names {
+		if !visited[name] {
+			missedFlags = append(missedFlags, name)
+		}
+	}
+
+	return len(missedFlags) == 0, missedFlags
 }
 
 func TimeValueVar(t *time.Time) func(s string) error {

internal/shiftplan/default_rules.go

@@ -6,9 +6,9 @@ import (
 	"github.com/orltom/on-call-schedule/pkg/apis"
 )
 
-var _ apis.Rule = VacationConflict()
+var _ apis.Rule = NoVacationOverlap()
 
-var _ apis.Rule = InvolvedInLastSift()
+var _ apis.Rule = MinimumOneShiftGap()
 
 type DefaultRule struct {
 	fn func(e apis.Employee, _ []apis.Shift, start time.Time, end time.Time) bool
@@ -18,7 +18,7 @@ func (d *DefaultRule) Match(employee apis.Employee, shifts []apis.Shift, start t
 	return d.fn(employee, shifts, start, end)
 }
 
-func VacationConflict() *DefaultRule {
+func NoVacationOverlap() *DefaultRule {
 	return &DefaultRule{
 		fn: func(e apis.Employee, _ []apis.Shift, start time.Time, end time.Time) bool {
 			days := e.VacationDays
@@ -33,13 +33,29 @@ func VacationConflict() *DefaultRule {
 	}
 }
 
-func InvolvedInLastSift() *DefaultRule {
+func MinimumOneShiftGap() *DefaultRule {
+	return minimumWeekGap(1)
+}
+
+func MinimumTwoShiftGap() *DefaultRule {
+	return minimumWeekGap(2)
+}
+
+func MinimumThreeShiftGap() *DefaultRule {
+	return minimumWeekGap(3)
+}
+
+func MinimumFourShiftGap() *DefaultRule {
+	return minimumWeekGap(4)
+}
+
+func minimumWeekGap(gap int) *DefaultRule {
 	return &DefaultRule{
 		fn: func(e apis.Employee, shifts []apis.Shift, _ time.Time, _ time.Time) bool {
 			if len(shifts) == 0 {
 				return false
 			}
-			lastShift := shifts[len(shifts)-1]
+			lastShift := shifts[len(shifts)-gap]
 			if lastShift.Primary == e.ID || lastShift.Secondary == e.ID {
 				return true
 			}

internal/shiftplan/default_rules_test.go

@@ -48,7 +48,7 @@ func TestVacationConflict(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			d := VacationConflict()
+			d := NoVacationOverlap()
 			if got := d.Match(tt.args.employee, nil, tt.args.start, tt.args.end); got != tt.want {
 				t.Errorf("Match() = %v, want %v", got, tt.want)
 			}
@@ -110,7 +110,7 @@ func TestInvolvedInLastSift(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			d := InvolvedInLastSift()
+			d := MinimumOneShiftGap()
 			if got := d.Match(tt.args.employee, tt.args.shifts, time.Now(), time.Now()); got != tt.want {
 				t.Errorf("Match() = %v, want %v", got, tt.want)
 			}

internal/shiftplan/planner.go

@@ -17,8 +17,8 @@ type ShiftPlanner struct {
 func NewDefaultShiftPlanner(team []apis.Employee) *ShiftPlanner {
 	return NewShiftPlanner(
 		team,
-		[]apis.Rule{VacationConflict()},
-		[]apis.Rule{VacationConflict()},
+		[]apis.Rule{NoVacationOverlap()},
+		[]apis.Rule{NoVacationOverlap()},
 	)
 }