machinedowntimeep

type CreateMachineDowntimeEventEndpoint struct{}

type CreateMachineDowntimeEventRequest struct {
	// ID of the machine that stopped.
	MachineID string `json:"machine_id" validate:"required"`
	// Why the machine stopped.
	//
	// The reason decides which OEE term the stoppage charges, so it does more than label the event. Retrieve the available reasons and the term each one charges from the downtime reasons list.
	Reason constants.MachineDowntimeReasonCode `json:"reason" validate:"required"`
	// When the machine stopped.
	//
	// Cannot be in the future beyond a few minutes of clock skew, which is allowed so a shop-floor tablet running fast can still log "just now". The business day the stoppage counts against is taken from this timestamp.
	StartedAt time.Time `json:"started_at" validate:"required"`
	// When the machine started running again.
	//
	// Omit it while the machine is still down; that leaves the event open, and the duration is filled in once the event is closed. It must be later than `started_at`.
	EndedAt field.Optional[time.Time] `json:"ended_at,omitzero"`
	// How long the machine was down, counted in a unit of time.
	//
	// The end time is derived from `started_at` plus this. Send either send `ended_at` or `duration`. The unit must measure time.
	Duration field.Optional[apirequest.QuantityInput] `json:"duration,omitzero"`
	// ID of the item the machine was running when it stopped.
	ItemID field.Optional[string] `json:"item_id,omitzero"`
	// ID of the production run in progress when the machine stopped.
	ProductionRunID field.Optional[string] `json:"production_run_id,omitzero"`
	// ID of the batch in progress when the machine stopped.
	BatchID field.Optional[string] `json:"batch_id,omitzero"`
	// Free-form notes about the stoppage.
	//
	// Searchable from the downtime events list. Maximum 2000 characters.
	Note field.Optional[string] `json:"note,omitzero" validate:"omitempty,max=2000"`
	// How the event was recorded.
	//
	// Records the stoppage as manually logged unless you say otherwise, so an integration or shop-floor station should send its own source to keep hand-entered downtime distinguishable.
	Source field.Optional[constants.MachineDowntimeSource] `json:"source,omitzero"`
}

type DeleteMachineDowntimeEventEndpoint struct{}

type DeleteMachineDowntimeEventRequest struct {
	// ID of the downtime event to delete.
	MachineDowntimeEventID string `path:"id" validate:"required"`
}

type ListMachineDowntimeEventsEndpoint struct{}

type ListMachineDowntimeEventsRequest struct {
	apiresource.PaginationRequest
	// Only return events for these machines.
	MachineIDs []string `query:"machine_ids"`
	// Only return events for machines in these departments.
	DepartmentIDs []string `query:"department_ids"`
	// Only return events logged against these reasons.
	Reasons []constants.MachineDowntimeReasonCode `query:"reasons"`
	// Only return events that are still open, meaning the machine is down right now.
	//
	// Sending `false` is the same as leaving it out: both open and closed events come back.
	Open bool `query:"open"`
	// Only return events that started on or after this timestamp, formatted as RFC3339.
	StartDate *string `query:"starts_at"`
	// Only return events that started on or before this timestamp, formatted as RFC3339.
	EndDate *string `query:"ends_at"`
}

type ListMachineDowntimeReasonsEndpoint struct{}

type ListMachineDowntimeReasonsRequest struct{}

type MachineDowntimeSvc interface {
	ListDowntimeReasons(ctx context.Context, req *ListMachineDowntimeReasonsRequest) (*apiresource.List[apiresource.MachineDowntimeReason], *apierror.APIError)
	ListDowntimeEvents(ctx context.Context, req *ListMachineDowntimeEventsRequest) (*apiresource.List[apiresource.MachineDowntimeEvent], *apierror.APIError)
	GetDowntimeEvent(ctx context.Context, req *RetrieveMachineDowntimeEventRequest) (*apiresource.MachineDowntimeEvent, *apierror.APIError)
	CreateDowntimeEvent(ctx context.Context, req *CreateMachineDowntimeEventRequest) (*apiresource.MachineDowntimeEvent, *apierror.APIError)
	UpdateDowntimeEvent(ctx context.Context, req *UpdateMachineDowntimeEventRequest) (*apiresource.MachineDowntimeEvent, *apierror.APIError)
	DeleteDowntimeEvent(ctx context.Context, req *DeleteMachineDowntimeEventRequest) (*apiresource.EmptyResource, *apierror.APIError)
}

type MachineDowntimeSvcConfig struct {
	// CoreClient (required) is the core-service machine-downtime gRPC client.
	CoreClient pb.CoreMachineDowntimeServiceClient
}

type RetrieveMachineDowntimeEventEndpoint struct{}

type RetrieveMachineDowntimeEventRequest struct {
	// ID of the downtime event to retrieve.
	MachineDowntimeEventID string `path:"id" validate:"required"`
}

type UpdateMachineDowntimeEventEndpoint struct{}

type UpdateMachineDowntimeEventRequest struct {
	// ID of the downtime event to update.
	MachineDowntimeEventID string `path:"id" validate:"required"`
	// ID of the machine that stopped.
	//
	// Moving an event to another machine re-resolves the department it is charged to, so past availability changes for both rooms. Rejected when the destination machine already has an open stoppage and this one is open too.
	MachineID field.Optional[string] `json:"machine_id,omitzero"`
	// Why the machine stopped.
	//
	// Reclassifying a stoppage moves it to the OEE term the new reason charges, so past availability figures change with it.
	Reason field.Optional[constants.MachineDowntimeReasonCode] `json:"reason,omitzero"`
	// When the machine stopped.
	//
	// Correcting it recalculates the duration and can move the stoppage onto a different business day.
	StartedAt field.Optional[time.Time] `json:"started_at,omitzero"`
	// When the machine started running again.
	//
	// Setting it closes the event and records the duration. Send null to reopen an event that was closed by mistake, which is rejected if the machine has since had another stoppage logged that is still open.
	EndedAt field.Clearable[time.Time] `json:"ended_at,omitzero"`
	// How long the machine was down, counted in a unit of time.
	//
	// Restates the end as a length of time from the start, so it is applied against `started_at` as this request leaves it. Send this or `ended_at`, never both. Send null to reopen the event.
	Duration field.Clearable[apirequest.QuantityInput] `json:"duration,omitzero"`
	// ID of the item the machine was running when it stopped.
	//
	// Send null to detach the item.
	ItemID field.Clearable[string] `json:"item_id,omitzero"`
	// ID of the production run in progress when the machine stopped.
	//
	// Send null to detach the run.
	ProductionRunID field.Clearable[string] `json:"production_run_id,omitzero"`
	// ID of the batch in progress when the machine stopped.
	//
	// Send null to detach the batch.
	BatchID field.Clearable[string] `json:"batch_id,omitzero"`
	// Free-form notes about the stoppage.
	//
	// Send null to remove the note. Maximum 2000 characters.
	Note field.Clearable[string] `json:"note,omitzero" validate:"omitempty,max=2000"`
}