pkg/models/component.go - develop - pyo/updater

pkg/models/component.go
600 строк16 KB
ilovepitsa
restore from another repo
16 июн 2025, 18:36
16 июн 2025, 18:3691b9a34
package models

import (
	"errors"
	"fmt"

	version "github.com/hashicorp/go-version"
	"github.com/volatiletech/null"
	"gitverse.ru/pyo/updater/pkg/server"
	"gitverse.ru/pyo/updater/pkg/util"
)

const (
	ComponentTypeExecutable = iota + 1
	ComponentTypeGrammar
	ComponentTypeSetting
	ComponentTypeScenario
	ComponentTypeModule
	ComponentTypeSemantic
	ComponentTypeLangServer
	ComponentTypePlugin
	ComponentTypeShell
)

const (
	ComponentStatusAvailable   = "available"
	ComponentStatusProcessing  = "processing"
	ComponentStatusUnavailable = "unavailable"
)

type DBDependencies struct {
	Name    string `db:"name"`
	Version string `db:"version"`
}
type Platform struct {
	Platform string   `db:"platform" json:"platform"`
	EnvVars  []string `db:"env_vars" json:"env_vars"`
}

type BuildOptions struct {
	Tools             []string   `db:"tools" json:"tools"`
	CrossCompileTools []string   `db:"cross_compile_tools" json:"cross_compile_tools"`
	Platforms         []Platform `db:"platforms" json:"platforms"`
}

type DBComponent struct {
	ID            int64       `db:"id"`
	Name          string      `db:"name"`
	DisplayName   string      `db:"display_name"`
	State         string      `db:"state"`
	ComponentType int         `db:"type"`
	Author        string      `db:"author"`
	Icon          null.String `db:"icon"`
	Price         float32     `db:"price"`
	Homepage      null.String `db:"homepage"`
	Description   null.String `db:"description"`
	Publisher     string      `db:"publisher"`
}

type DBComponentWithVersion struct {
	DBComponent
	DBVersion
}

type ComponentWithVersion struct {
	Component
	Version
}

func MapComponentsWithVersionToDBComponentsWithVersion(components []ComponentWithVersion) []DBComponentWithVersion {
	dbComponents := make([]DBComponentWithVersion, len(components))
	for i, c := range components {
		dbComponents[i] = MapComponentWithVersionToDBComponentWithVersion(c)
	}
	return dbComponents
}

func MapDBComponentsWithVersionToComponentsWithVersion(components []DBComponentWithVersion) []ComponentWithVersion {
	componentsWithVersion := make([]ComponentWithVersion, len(components))
	for i, c := range components {
		componentsWithVersion[i] = MapDBComponentWithVersionToComponentWithVersion(c)
	}
	return componentsWithVersion
}

func MapComponentWithVersionToDBComponentWithVersion(c ComponentWithVersion) DBComponentWithVersion {
	return DBComponentWithVersion{
		DBComponent: MapComponentToDBComponent(c.Component),
		DBVersion:   MapVersionToDBVersion(c.Version),
	}
}

func MapDBComponentWithVersionToComponentWithVersion(c DBComponentWithVersion) ComponentWithVersion {
	return ComponentWithVersion{
		Component: MapDBComponentToComponent(c.DBComponent),
		Version:   MapDBVersionToVersion(c.DBVersion),
	}
}

type DBComponentWithVersions struct {
	DBComponent
	Versions []DBVersion
}

type ComponentWithVersions struct {
	Component
	Versions []Version
}

func MapComponentWithVersionsToDBComponentsWithVersions(components ComponentWithVersions) DBComponentWithVersions {
	return DBComponentWithVersions{
		DBComponent: MapComponentToDBComponent(components.Component),
		Versions:    MapVersionsToDBVersions(components.Versions),
	}
}

func MapDBComponentWithVersionsToComponentWithVersions(c DBComponentWithVersions) ComponentWithVersions {
	return ComponentWithVersions{
		Component: MapDBComponentToComponent(c.DBComponent),
		Versions:  MapDBVersionsToVersions(c.Versions),
	}
}

type Dependencies struct {
	Name    string
	Version version.Version
}

type Version struct {
	Version      version.Version `db:"version"`
	DevDepend    []Dependencies
	BuildOptions BuildOptions
}

type DBVersion struct {
	Version      string           `db:"version"`
	DevDepend    []DBDependencies `db:"depend"`
	BuildOptions BuildOptions     `db:"build_options"`
}

func MapDBVersionToVersion(v DBVersion) Version {
	ver := version.Must(version.NewVersion(v.Version))
	return Version{
		Version:      *ver,
		DevDepend:    MapDBDevDependsToDevDepends(v.DevDepend),
		BuildOptions: v.BuildOptions,
	}
}

func MapVersionToDBVersion(v Version) DBVersion {
	return DBVersion{
		Version:      v.Version.String(),
		DevDepend:    MapDevDependsToDBDevDepends(v.DevDepend),
		BuildOptions: v.BuildOptions,
	}
}

func MapDBVersionsToVersions(vs []DBVersion) []Version {
	res := []Version{}
	for _, v := range vs {
		res = append(res, MapDBVersionToVersion(v))
	}
	return res
}
func MapVersionsToDBVersions(vs []Version) []DBVersion {
	res := []DBVersion{}
	for _, v := range vs {
		res = append(res, MapVersionToDBVersion(v))
	}
	return res
}

func MapServerVersionToVersion(v server.Version) (Version, error) {
	if v.Version == nil {
		return Version{}, errors.New("version is empty")
	}
	res := Version{}
	ver, err := version.NewVersion(*v.Version)
	if err != nil {
		return Version{}, err
	}
	res.Version = *ver
	if v.DevDependencies != nil {
		dd, err := MapServerDevDepToDevDep(*v.DevDependencies)
		if err != nil {
			return Version{}, err
		}
		res.DevDepend = dd
	}
	if v.BuildOptions != nil {
		bo, err := MapServerBuildOptionsToBuildOptions(*v.BuildOptions)
		if err != nil {
			return Version{}, err
		}
		res.BuildOptions = bo
	}
	return res, nil
}

type Component struct {
	ID            int64
	Name          string
	DisplayName   string
	Status        string
	ComponentType int
	Author        string
	Icon          null.String
	Price         float32
	Homepage      null.String
	Description   null.String
	Publisher     string
}

func MapServerComponentDesciptionToComponent(c server.ComponentDescription) (Component, error) {
	res := Component{}
	res.Author = c.Author.Name
	cType, err := MapServerComponentTypeToComponentType(c.Type)
	if err != nil {
		return Component{}, err
	}
	res.ComponentType = cType
	res.Description = null.StringFromPtr(c.Description)
	res.DisplayName = c.DisplayName
	res.Homepage = null.StringFromPtr(c.Homepage)
	res.Icon = null.StringFrom("")
	res.Name = c.Name
	if c.Pricing != nil && c.Pricing.Amount != nil {
		res.Price = *c.Pricing.Amount
	}
	res.Publisher = c.Publisher

	return res, nil
}

type BuildOperationsStatus int

const (
	BuildStatusCreated BuildOperationsStatus = iota
	BuildStatusProcessing
	BuildStatusDone
	BuildStatusError
)

type BuildOperationType int

const (
	BuildTypeBuild BuildOperationType = iota
)

type BuildOperation struct {
	Id                    int                   `db:"id"`
	CreatedAt             null.Time             `db:"created_at"`
	UpdatedAt             null.Time             `db:"updated_at"`
	DeletedAt             null.Time             `db:"deleted_at"`
	Version               string                `db:"version"`
	ComponentID           int64                 `db:"component_id"`
	ComponentName         string                `db:"component_name"`
	ComponentDisplayName  string                `db:"component_display_name"`
	ComponentState        string                `db:"component_state"`
	ComponentType         int                   `db:"component_type"`
	ComponentDevDepend    []DBDependencies      `db:"component_depend"`
	ComponentBuildOptions BuildOptions          `db:"component_build_options"`
	ComponentAuthor       string                `db:"component_author"`
	ComponentIcon         null.String           `db:"component_icon"`
	ComponentPrice        float32               `db:"component_price"`
	ComponentHomepage     null.String           `db:"component_homepage"`
	ComponentDescription  null.String           `db:"component_description"`
	Publisher             string                `db:"component_publisher"`
	ComponentPath         string                `db:"path"`
	Status                BuildOperationsStatus `db:"status"`
	OperationType         BuildOperationType    `db:"operation_type"`
}

func MapDependenciesToDevDependencies(dep []Dependencies) server.DevDependencies {
	res := server.DevDependencies{}
	for _, d := range dep {
		res = append(res, server.DevDependence{
			Name:    d.Name,
			Version: util.Ptr(d.Version.String()),
		})
	}
	return res
}

func MapComponentTypeToServerComponentType(compType int) server.ComponentType {
	switch compType {
	case 1:
		return server.Executable
	case 2:
		return server.Grammar
	case 3:
		return server.Setting
	case 4:
		return server.Scenario
	case 5:
		return server.Module
	case 6:
		return server.LanguageServer
	case 7:
		return server.Plugin
	case 8:
		return server.Shell
	}
	return "unknown"
}

func GetStringSliceFromVersions(vers []version.Version) []string {
	res := []string{}
	for _, v := range vers {
		res = append(res, v.String())
	}
	return res
}

func MapPlatformsToServerPlatforms(p []Platform) []server.Platform {
	res := []server.Platform{}
	for _, pl := range p {
		res = append(res, server.Platform{
			Platforms:    &pl.Platform,
			EnvVariables: &pl.EnvVars,
		})
	}
	return res
}

func MapBuildOptionsToServerBuildOptions(b BuildOptions) server.BuildOptions {
	return server.BuildOptions{
		Platforms:         util.Ptr(MapPlatformsToServerPlatforms(b.Platforms)),
		CrossCompileTools: &b.CrossCompileTools,
		Tools:             &b.Tools,
	}
}

func MapVersionToServerVersion(v Version) server.Version {
	return server.Version{
		Version:         util.Ptr(v.Version.String()),
		DevDependencies: util.Ptr(MapDependenciesToDevDependencies(v.DevDepend)),
		BuildOptions:    util.Ptr(MapBuildOptionsToServerBuildOptions(v.BuildOptions)),
	}
}

func MapVersionsToServerVersions(vs []Version) []server.Version {
	res := []server.Version{}
	for _, v := range vs {
		res = append(res, MapVersionToServerVersion(v))
	}
	return res
}

func MapComponentToServerComponentDescription(c Component) server.ComponentDescription {
	return server.ComponentDescription{
		Author: server.Author{
			Name: c.Author,
		},
		Description: c.Description.Ptr(),
		DisplayName: c.DisplayName,
		Homepage:    &c.Homepage.String,
		Name:        c.Name,
		Icon:        c.Icon.Ptr(),
		Pricing: &server.Price{
			Amount: &c.Price,
		},
		Publisher: c.Publisher,
		Type:      MapComponentTypeToServerComponentType(c.ComponentType),
	}
}

func MapDevDependsToDBDevDepends(deps []Dependencies) []DBDependencies {
	res := []DBDependencies{}
	for _, d := range deps {
		res = append(res, MapDevDependToDBDevDepend(d))
	}
	return res
}

func MapDevDependToDBDevDepend(d Dependencies) DBDependencies {
	return DBDependencies{
		Name:    d.Name,
		Version: d.Version.String(),
	}
}

func MapComponentToDBComponent(c Component) DBComponent {
	return DBComponent{
		ID:            c.ID,
		Name:          c.Name,
		DisplayName:   c.DisplayName,
		ComponentType: c.ComponentType,
		Author:        c.Author,
		Icon:          c.Icon,
		Price:         c.Price,
		Homepage:      c.Homepage,
		Description:   c.Description,
		Publisher:     c.Publisher,
		State:         c.Status,
	}
}

func MapDBDevDependsToDevDepends(deps []DBDependencies) []Dependencies {
	res := []Dependencies{}
	for _, d := range deps {
		res = append(res, MapDBDevDependToDevDepend(d))
	}
	return res
}

func MapDBDevDependToDevDepend(d DBDependencies) Dependencies {
	if d.Version == "" {
		return Dependencies{
			Name: d.Name,
		}
	}
	return Dependencies{
		Name:    d.Name,
		Version: *version.Must(version.NewSemver(d.Version)),
	}
}

func MapComponentsToDBComponents(comp []Component) []DBComponent {
	res := []DBComponent{}
	for _, c := range comp {
		res = append(res, MapComponentToDBComponent(c))
	}
	return res
}

func MustStringToVersion(vers []string) []version.Version {
	res := []version.Version{}
	for _, v := range vers {
		res = append(res, *version.Must(version.NewSemver(v)))
	}
	return res
}

func MapDBComponentToComponent(c DBComponent) Component {
	return Component{
		ID:            c.ID,
		Name:          c.Name,
		DisplayName:   c.DisplayName,
		ComponentType: c.ComponentType,
		Author:        c.Author,
		Status:        c.State,
		Icon:          c.Icon,
		Price:         c.Price,
		Homepage:      c.Homepage,
		Description:   c.Description,
		Publisher:     c.Publisher,
	}
}

func MapDBComponentsToComponents(comp []DBComponent) []Component {
	res := []Component{}
	for _, c := range comp {
		res = append(res, MapDBComponentToComponent(c))
	}
	return res
}

func MapUpdateElementsToComponent(el server.UpdateElements) ([]ComponentWithVersion, error) {
	resp := []ComponentWithVersion{}
	for _, e := range el {
		c, err := MapUpdateElementToComponent(e)
		if err != nil {
			return nil, err
		}
		resp = append(resp, c)
	}
	return resp, nil
}

func MapUpdateElementToComponent(e server.UpdateElement) (ComponentWithVersion, error) {
	if e.Version == nil {
		return ComponentWithVersion{}, errors.New("version is nil")
	}
	if e.Name == nil {
		return ComponentWithVersion{}, errors.New("name is nil")
	}

	v, err := version.NewSemver(*e.Version)
	if err != nil {
		return ComponentWithVersion{}, err
	}
	return ComponentWithVersion{
		Component: Component{
			Name: *e.Name,
		},
		Version: Version{
			Version: *v,
		},
	}, nil
}

func MapComponentsToUpdateElements(comp []ComponentWithVersion) server.UpdateElements {
	resp := server.UpdateElements{}
	for _, c := range comp {
		resp = append(resp, server.UpdateElement{
			Name:    &c.Name,
			Version: util.Ptr(c.Version.Version.String()),
		})
	}
	return resp
}

func MapComponentWithVersionsToComponentDescriptionWithVersions(c ComponentWithVersions) server.ComponentDescriptionWithVersions {
	return server.ComponentDescriptionWithVersions{
		Description: util.Ptr(MapComponentToServerComponentDescription(c.Component)),
		Version:     util.Ptr(MapVersionsToServerVersions(c.Versions)),
	}
}

func MapComponentWithVersionToComponentDescriptionWithVersion(c ComponentWithVersion) server.ComponentDescriptionWithVersion {
	return server.ComponentDescriptionWithVersion{
		Description: MapComponentToServerComponentDescription(c.Component),
		Version:     MapVersionToServerVersion(c.Version),
	}
}

func MapServerComponentTypeToComponentType(sType server.ComponentType) (int, error) {
	switch sType {
	case server.Executable:
		return ComponentTypeExecutable, nil
	case server.Grammar:
		return ComponentTypeGrammar, nil
	case server.Setting:
		return ComponentTypeSetting, nil
	case server.Scenario:
		return ComponentTypeScenario, nil
	case server.Module:
		return ComponentTypeModule, nil
	case server.Semantics:
		return ComponentTypeSemantic, nil
	case server.LanguageServer:
		return ComponentTypeLangServer, nil
	case server.Plugin:
		return ComponentTypePlugin, nil
	case server.Shell:
		return ComponentTypeShell, nil
	}
	return 0, fmt.Errorf("unknown component type")
}

func MapServerDevDepToDevDep(dd server.DevDependencies) ([]Dependencies, error) {
	res := []Dependencies{}
	for _, d := range dd {
		dep := Dependencies{
			Name: d.Name,
		}
		if d.Version != nil {
			v, err := version.NewSemver(*d.Version)
			if err != nil {
				return nil, err
			}
			dep.Version = *v
		}
		res = append(res, dep)
	}
	return res, nil
}

func MapServerPlatformsToPlatforms(sp []server.Platform) ([]Platform, error) {
	res := []Platform{}
	for _, p := range sp {
		pl := Platform{}
		if p.Platforms == nil {
			return nil, fmt.Errorf("platform is nil")
		}
		pl.Platform = *p.Platforms
		if p.EnvVariables != nil {
			pl.EnvVars = *p.EnvVariables
		}
		res = append(res, pl)
	}
	return res, nil
}

func MapServerComponentToComponent(sc server.ComponentDescriptionWithVersion) (ComponentWithVersion, error) {
	res := ComponentWithVersion{}
	var err error
	res.Component, err = MapServerComponentDesciptionToComponent(sc.Description)
	if err != nil {
		return ComponentWithVersion{}, fmt.Errorf("cant parse component description. err: %v", err)
	}
	res.Version, err = MapServerVersionToVersion(sc.Version)
	return res, err
}

func MapServerBuildOptionsToBuildOptions(sbo server.BuildOptions) (BuildOptions, error) {
	res := BuildOptions{}
	if sbo.CrossCompileTools != nil {
		res.CrossCompileTools = *sbo.CrossCompileTools
	}
	if sbo.Platforms != nil {
		var err error
		res.Platforms, err = MapServerPlatformsToPlatforms(*sbo.Platforms)
		if err != nil {
			return BuildOptions{}, fmt.Errorf("cant parse platforms %v", err)
		}
	}
	return res, nil
}