frx/kurious
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

create product at ydb

Browse Source
This commit is contained in:
Gitea
2023-12-04 01:24:24 +03:00
parent 414dc87091
commit 20107503e0
5 changed files with 300 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
cmd/dev/sravnicli/core.go
View File

@ -15,14 +15,13 @@ import (
"github.com/teris-io/cli"
)
const (
debugOptName = "verbose"
jsonOptName = "json"
var (
limitOption = cli.NewOption("limit", "Limits amount of items to return").WithType(cli.TypeInt)
offsetOption = cli.NewOption("offset", "Offsets items to return").WithType(cli.TypeInt)
debugOption = cli.NewOption("verbose", "Enables debug logging").WithChar('v').WithType(cli.TypeBool)
jsonOption = cli.NewOption("json", "Sets output as json").WithType(cli.TypeBool)
)
var limitOption = cli.NewOption("limit", "Limits amount of items to return").WithType(cli.TypeInt)
var offsetOption = cli.NewOption("offset", "Offsets items to return").WithType(cli.TypeInt)
type actionWrapper func(next cli.Action) cli.Action
func buildCLICommand(f func() cli.Command) cliCommand {
@ -92,9 +91,29 @@ func actionWrapperParseConfig(next cli.Action) cli.Action {
}
}
func isJSONFormatEnabled(options map[string]string) bool {
_, ok := options[jsonOption.Key()]
return ok
}
type outputEncoderF func(any) error
func makeOutputEncoder(options map[string]string) outputEncoderF {
if isJSONFormatEnabled(options) {
out := json.NewEncoder(defaultOutput)
out.SetIndent("", " ")
return out.Encode
}
return outputEncoderF(func(a any) error {
_, err := fmt.Fprintf(defaultOutput, "%#v", a)
return err
})
}
func makeLogger(options map[string]string) *slog.Logger {
level := slog.LevelInfo
if _, ok := options[debugOptName]; ok {
if _, ok := options[debugOption.Key()]; ok {
level = slog.LevelDebug
}
@ -103,7 +122,7 @@ func makeLogger(options map[string]string) *slog.Logger {
}
var h slog.Handler
if _, ok := options[jsonOptName]; ok {
if isJSONFormatEnabled(options) {
h = slog.NewJSONHandler(os.Stdout, &opts)
} else {
h = slog.NewTextHandler(os.Stdout, &opts)
@ -113,7 +132,7 @@ func makeLogger(options map[string]string) *slog.Logger {
}
func makeSravniClient(ctx context.Context, log *slog.Logger, options map[string]string) (sravni.Client, error) {
_, isDebug := options[debugOptName]
_, isDebug := options[debugOption.Key()]
client, err := sravni.NewClient(ctx, log, isDebug)
if err != nil {
return nil, fmt.Errorf("making new client: %w", err)
@ -125,6 +144,8 @@ func makeSravniClient(ctx context.Context, log *slog.Logger, options map[string]
type baseAction struct {
ctx context.Context
log *slog.Logger
out outputEncoderF
}
func (ba *baseAction) getYDBConnection() (*adapters.YDBConnection, error) {
@ -142,6 +163,7 @@ func (ba *baseAction) getYDBConnection() (*adapters.YDBConnection, error) {
func (ba *baseAction) parse(_ []string, options map[string]string) (err error) {
ba.log = makeLogger(options).With(slog.String("component", "action"))
ba.out = makeOutputEncoder(options)
return nil
}

156
cmd/dev/sravnicli/ydb.go
View File

@ -5,9 +5,12 @@ import (
stderrors "errors"
"fmt"
"log/slog"
"strconv"
"time"
"git.loyso.art/frx/kurious/internal/common/errors"
"git.loyso.art/frx/kurious/internal/common/xcontext"
"git.loyso.art/frx/kurious/internal/kurious/domain"
"github.com/teris-io/cli"
)
@ -22,12 +25,29 @@ func setupYDBCommand(ctx context.Context) cli.Command {
coursesGet := buildCLICommand(func() cli.Command {
return cli.NewCommand("get", "Fetches one or more courses").
WithArg(cli.NewArg("ids", "List of course ids").AsOptional()).
WithArg(cli.NewArg("ids", "List of course ids").AsOptional().WithType(cli.TypeString)).
WithAction(newYDBCoursesGetAction(ctx))
})
coursesCreate := buildCLICommand(func() cli.Command {
return cli.NewCommand("create", "Creates course").
WithOption(cli.NewOption("generate-id", "Generates id").WithType(cli.TypeBool)).
WithOption(cli.NewOption("name", "Sets course name")).
WithOption(cli.NewOption("source-name", "Sets source name")).
WithOption(cli.NewOption("organization-id", "Sets organization id")).
WithOption(cli.NewOption("origin-link", "Sets origin link")).
WithOption(cli.NewOption("image-link", "Sets image link")).
WithOption(cli.NewOption("desc", "Sets description link")).
WithOption(cli.NewOption("full-price", "Sets full price").WithType(cli.TypeNumber)).
WithOption(cli.NewOption("discount", "Sets discount").WithType(cli.TypeNumber)).
WithOption(cli.NewOption("duration", "Sets duration")).
WithOption(cli.NewOption("starts-at", "Sets starts at")).
WithAction(NewYDBCoursesCreateAction(ctx))
})
courses := cli.NewCommand("courses", "Courses commands").
WithCommand(coursesGet)
WithCommand(coursesGet).
WithCommand(coursesCreate)
return cli.NewCommand("ydb", "YDB related actions").
WithCommand(migration).
@ -70,6 +90,127 @@ func (a *ydbMigrateApplyAction) handle() error {
return nil
}
func NewYDBCoursesCreateAction(ctx context.Context) cli.Action {
action := &ydbCoursesCreateAction{
baseAction: newBaseAction(ctx),
}
return asCLIAction(action)
}
type ydbCoursesCreateAction struct {
*baseAction
generateID bool
id string
name string
sourceName string
organizationID string
originLink string
imageLink string
description string
fullPrice float64
discount float64
duration time.Duration
startsAt time.Time
}
func (a *ydbCoursesCreateAction) getCreateParams() domain.CreateCourseParams {
if a.generateID {
a.id = strconv.FormatInt(time.Now().Unix(), 10)
}
out := domain.CreateCourseParams{
ID: a.id,
Name: a.name,
SourceType: domain.SourceTypeParsed,
OrganizationID: a.organizationID,
OriginLink: a.originLink,
ImageLink: a.imageLink,
Description: a.description,
FullPrice: a.fullPrice,
Discount: a.discount,
Duration: a.duration,
StartsAt: a.startsAt,
}
if a.sourceName != "" {
out.SourceName.Set(a.sourceName)
}
return out
}
func (a *ydbCoursesCreateAction) parse(params []string, options map[string]string) error {
err := a.baseAction.parse(params, options)
if err != nil {
return err
}
if err != nil {
return fmt.Errorf("parsing full-price: %w", err)
}
a.discount, err = strconv.ParseFloat(options["discount"], 64)
if err != nil {
return fmt.Errorf("parsing discount: %w", err)
}
a.fullPrice, err = strconv.ParseFloat(options["full-price"], 64)
if err != nil {
return fmt.Errorf("parsing full-price: %w", err)
}
if genid, ok := options["generate-id"]; ok {
a.generateID, err = strconv.ParseBool(genid)
if err != nil {
return fmt.Errorf("parsing generate-id: %w", err)
}
}
if duration, ok := options["duration"]; ok {
a.duration, err = time.ParseDuration(duration)
if err != nil {
return fmt.Errorf("parsing duration: %w", err)
}
}
if startsAt, ok := options["starts-at"]; ok {
a.startsAt, err = time.Parse(time.RFC3339, startsAt)
if err != nil {
return fmt.Errorf("parsing time: %w", err)
}
}
a.name = options["name"]
a.sourceName = options["source-name"]
a.organizationID = options["organization-id"]
a.originLink = options["origin-link"]
a.imageLink = options["image-link"]
a.description = options["desc"]
return nil
}
func (a *ydbCoursesCreateAction) handle() error {
ydbConn, err := a.getYDBConnection()
if err != nil {
return err
}
defer func() {
errClose := ydbConn.Close()
if errClose != nil {
xcontext.LogError(a.ctx, a.log, "unable to close repository", slog.Any("error", err))
if err == nil {
err = errClose
}
}
}()
params := a.getCreateParams()
repository := ydbConn.CourseRepository()
_, err = repository.Create(a.ctx, params)
if err != nil {
return fmt.Errorf("creating course: %w", err)
}
return nil
}
type ydbCoursesGetAction struct {
*baseAction
@ -116,6 +257,7 @@ func (a *ydbCoursesGetAction) handle() error {
}()
repository := ydbConn.CourseRepository()
courses := make([]domain.Course, 0, len(a.courseIDs))
for _, courseID := range a.courseIDs {
course, err := repository.Get(a.ctx, courseID)
if err != nil && !stderrors.Is(err, errors.ErrNotFound) {
@ -125,7 +267,15 @@ func (a *ydbCoursesGetAction) handle() error {
continue
}
xcontext.LogInfo(a.ctx, a.log, "fetched course", slog.Any("item", course))
xcontext.LogInfo(a.ctx, a.log, "fetched course", slog.String("id", courseID))
courses = append(courses, course)
}
for _, course := range courses {
err = a.out(course)
if err != nil {
xcontext.LogError(a.ctx, a.log, "unable to write course", slog.Any("error", err))
}
}
return nil