add create record command

cli/create.go

@@ -17,6 +17,7 @@ func createCommand(t *core.Timetrace) *cobra.Command {
 	}
 
 	create.AddCommand(createProjectCommand(t))
+	create.AddCommand(createRecordCommand(t))
 
 	return create
 }
@@ -44,3 +45,73 @@ func createProjectCommand(t *core.Timetrace) *cobra.Command {
 
 	return createProject
 }
+
+func createRecordCommand(t *core.Timetrace) *cobra.Command {
+	var options startOptions
+	createRecord := &cobra.Command{
+		Use:   "record <PROJECT KEY>{<YYYY-MM-DD>|today|yesterday}<HH-MM><HH-MM>",
+		Short: "Create a new record",
+		Run: func(cmd *cobra.Command, args []string) {
+			key := args[0]
+			project, err := t.LoadProject(key)
+			if err != nil {
+				out.Err("Failed to get project: %s", key)
+				return
+			}
+
+			date, err := t.Formatter().ParseDate(args[1])
+			if err != nil {
+				out.Err("failed to parse date: %s", err.Error())
+				return
+			}
+
+			start, err := t.Formatter().ParseTime(args[2])
+			if err != nil {
+				out.Err("failed to parse start time: %s", err.Error())
+				return
+			}
+			start = t.Formatter().CombineDateAndTime(date, start)
+
+			end, err := t.Formatter().ParseTime(args[3])
+			if err != nil {
+				out.Err("failed to parse end time: %s", err.Error())
+				return
+			}
+			end = t.Formatter().CombineDateAndTime(date, end)
+
+			if end.Before(start) {
+				out.Err("end time is before start time!")
+				return
+			}
+
+			record := core.Record{
+				Project:    project,
+				Start:      start,
+				End:        &end,
+				IsBillable: options.isBillable,
+			}
+
+			collides, err := t.RecordCollides(record)
+			if err != nil {
+				out.Err("Error on check if record collides: %s", err.Error())
+				return
+			}
+			if collides {
+				out.Err("Record collides with other record!")
+				return
+			}
+
+			if err := t.SaveRecord(record, false); err != nil {
+				out.Err("Failed to create record: %s", err.Error())
+				return
+			}
+
+			out.Success("Created record %s in project %s", t.Formatter().TimeString(record.Start), key)
+		},
+	}
+
+	createRecord.Flags().BoolVarP(&options.isBillable, "billable", "b",
+		false, `mark tracked time as billable`)
+
+	return createRecord
+}

core/formatter.go

@@ -31,6 +31,22 @@ func (f *Formatter) ParseDate(input string) (time.Time, error) {
 	return date, nil
 }
 
+// ParseTime parses a time from an input string in the configured timeLayout
+func (f *Formatter) ParseTime(input string) (time.Time, error) {
+	date, err := time.Parse(f.timeLayout(), input)
+	if err != nil {
+		return time.Time{}, err
+	}
+	return date, nil
+}
+
+// CombineDateAndTime takes a date and a time and combines them to the time
+// struct that represents the given time on the given day
+func (f *Formatter) CombineDateAndTime(d, t time.Time) time.Time {
+	year, month, day := d.Date()
+	return time.Date(year, month, day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), time.Local)
+}
+
 const (
 	defaultTimeLayout        = "15:04"
 	default12HoursTimeLayout = "03:04PM"

core/timetrace.go

@@ -234,3 +234,36 @@ func (t *Timetrace) latestNonEmptyDir(dirs []string) (string, error) {
 
 	return "", ErrAllDirectoriesEmpty
 }
+
+// RecordCollides checks if the time of a record collides
+// with other records of the same day and returns a bool
+func (t *Timetrace) RecordCollides(toCheck Record) (bool, error) {
+	allRecords, err := t.loadAllRecords(toCheck.Start)
+	if err != nil {
+		return false, err
+	}
+
+	if toCheck.Start.Day() != toCheck.End.Day() {
+		moreRecords, err := t.loadAllRecords(*toCheck.End)
+		if err != nil {
+			return false, err
+		}
+		for _, rec := range moreRecords {
+			allRecords = append(allRecords, rec)
+		}
+	}
+
+	for _, rec := range allRecords {
+		if rec.Start.Before(toCheck.Start) && rec.End.After(toCheck.Start) {
+			return true, nil
+		} else if rec.Start.Before(*toCheck.End) && rec.End.After(*toCheck.End) {
+			return true, nil
+		} else if toCheck.Start.Before(rec.Start) && toCheck.End.After(rec.Start) {
+			return true, nil
+		} else if toCheck.Start.Before(*rec.End) && toCheck.End.After(*rec.End) {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}