grpc/handler_schedule.go

package grpc

import (
	"context"
	"encoding/json"
	"log/slog"

	pb "schedule_converter/proto/runner"

	apperr "schedule_converter/pkg/errors"
)

func (h *TaskHandler) getSchedule(ctx context.Context, payload []byte) ([]byte, error) {
	var req pb.GetSchedulePayload
	if err := unmarshalPayload(payload, &req); err != nil {
		return nil, err
	}

	log := slog.With("username", req.Username, "semester", req.Semester)
	log.Info("获取课表任务")

	result, err := h.service.GetSchedule(ctx, &req)
	if err != nil {
		return nil, apperr.New("get_schedule", err, "获取课表失败")
	}

	log.Info("课表获取成功", "course_count", len(result.Courses))
	return json.Marshal(result)
}
refactor(grpc): restructure task handling and migrate to slog Refactor the gRPC client and task handling logic to improve modularity, error handling, and observability. - Split `grpc/handler.go` into specialized handler files (login, classroom, exams, grades, schedule) to reduce complexity. - Replace standard `log` with `log/slog` throughout the project for structured logging. - Refactor `grpc/client.go` to use a thread-safe connection management pattern with `sync.RWMutex`. - Remove the legacy `service` package and HTTP server implementation, transitioning the application to a pure gRPC runner mode. - Clean up `config` and `pkg/errors` to remove unused utilities and simplify the API. - Improve error reporting in parsers and HTTP clients by checking response status codes. 2026-06-09 23:08:03 +08:00			`package grpc`

			`import (`
			`"context"`
			`"encoding/json"`
			`"log/slog"`

			`pb "schedule_converter/proto/runner"`

refactor: introduce service layer and migrate gRPC handlers to use it Extract business logic from gRPC handlers into a dedicated service package. Add context support throughout for cancellation and timeouts. Move models to their own package, remove hardcoded credentials from config, and simplify parsers to only handle HTML parsing. 2026-06-16 18:33:13 +08:00			`apperr "schedule_converter/pkg/errors"`
refactor(grpc): restructure task handling and migrate to slog Refactor the gRPC client and task handling logic to improve modularity, error handling, and observability. - Split `grpc/handler.go` into specialized handler files (login, classroom, exams, grades, schedule) to reduce complexity. - Replace standard `log` with `log/slog` throughout the project for structured logging. - Refactor `grpc/client.go` to use a thread-safe connection management pattern with `sync.RWMutex`. - Remove the legacy `service` package and HTTP server implementation, transitioning the application to a pure gRPC runner mode. - Clean up `config` and `pkg/errors` to remove unused utilities and simplify the API. - Improve error reporting in parsers and HTTP clients by checking response status codes. 2026-06-09 23:08:03 +08:00			`)`

			`func (h *TaskHandler) getSchedule(ctx context.Context, payload []byte) ([]byte, error) {`
			`var req pb.GetSchedulePayload`
			`if err := unmarshalPayload(payload, &req); err != nil {`
			`return nil, err`
			`}`

			`log := slog.With("username", req.Username, "semester", req.Semester)`
			`log.Info("获取课表任务")`

refactor: introduce service layer and migrate gRPC handlers to use it Extract business logic from gRPC handlers into a dedicated service package. Add context support throughout for cancellation and timeouts. Move models to their own package, remove hardcoded credentials from config, and simplify parsers to only handle HTML parsing. 2026-06-16 18:33:13 +08:00			`result, err := h.service.GetSchedule(ctx, &req)`
refactor(grpc): restructure task handling and migrate to slog Refactor the gRPC client and task handling logic to improve modularity, error handling, and observability. - Split `grpc/handler.go` into specialized handler files (login, classroom, exams, grades, schedule) to reduce complexity. - Replace standard `log` with `log/slog` throughout the project for structured logging. - Refactor `grpc/client.go` to use a thread-safe connection management pattern with `sync.RWMutex`. - Remove the legacy `service` package and HTTP server implementation, transitioning the application to a pure gRPC runner mode. - Clean up `config` and `pkg/errors` to remove unused utilities and simplify the API. - Improve error reporting in parsers and HTTP clients by checking response status codes. 2026-06-09 23:08:03 +08:00			`if err != nil {`
refactor: introduce service layer and migrate gRPC handlers to use it Extract business logic from gRPC handlers into a dedicated service package. Add context support throughout for cancellation and timeouts. Move models to their own package, remove hardcoded credentials from config, and simplify parsers to only handle HTML parsing. 2026-06-16 18:33:13 +08:00			`return nil, apperr.New("get_schedule", err, "获取课表失败")`
refactor(grpc): restructure task handling and migrate to slog Refactor the gRPC client and task handling logic to improve modularity, error handling, and observability. - Split `grpc/handler.go` into specialized handler files (login, classroom, exams, grades, schedule) to reduce complexity. - Replace standard `log` with `log/slog` throughout the project for structured logging. - Refactor `grpc/client.go` to use a thread-safe connection management pattern with `sync.RWMutex`. - Remove the legacy `service` package and HTTP server implementation, transitioning the application to a pure gRPC runner mode. - Clean up `config` and `pkg/errors` to remove unused utilities and simplify the API. - Improve error reporting in parsers and HTTP clients by checking response status codes. 2026-06-09 23:08:03 +08:00			`}`

refactor: introduce service layer and migrate gRPC handlers to use it Extract business logic from gRPC handlers into a dedicated service package. Add context support throughout for cancellation and timeouts. Move models to their own package, remove hardcoded credentials from config, and simplify parsers to only handle HTML parsing. 2026-06-16 18:33:13 +08:00			`log.Info("课表获取成功", "course_count", len(result.Courses))`
refactor(grpc): restructure task handling and migrate to slog Refactor the gRPC client and task handling logic to improve modularity, error handling, and observability. - Split `grpc/handler.go` into specialized handler files (login, classroom, exams, grades, schedule) to reduce complexity. - Replace standard `log` with `log/slog` throughout the project for structured logging. - Refactor `grpc/client.go` to use a thread-safe connection management pattern with `sync.RWMutex`. - Remove the legacy `service` package and HTTP server implementation, transitioning the application to a pure gRPC runner mode. - Clean up `config` and `pkg/errors` to remove unused utilities and simplify the API. - Improve error reporting in parsers and HTTP clients by checking response status codes. 2026-06-09 23:08:03 +08:00			`return json.Marshal(result)`
			`}`