Coverage Report

Generated on Sun, 03 Aug 2025 05:06:31 UTC with gocov-html

Report Overview

`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/converter`	`100.0%`	`34/34`
`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/v1`	`0.0%`	`0/26`
`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/model`	`100.0%`	`10/10`
`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/converter`	`60.0%`	`9/15`
`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory`	`0.0%`	`0/69`
`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo`	`0.0%`	`0/73`
`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/service/part`	`100.0%`	`9/9`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/middleware`	`0.0%`	`0/6`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1`	`0.0%`	`0/57`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/converter`	`100.0%`	`24/24`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/inventory/v1`	`0.0%`	`0/8`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/payment/v1`	`0.0%`	`0/10`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/model`	`0.0%`	`0/10`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/converter`	`84.6%`	`22/26`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/inmemory`	`0.0%`	`0/21`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres`	`0.0%`	`0/45`
`github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order`	`100.0%`	`44/44`
`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/converter`	`100.0%`	`7/7`
`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/middleware`	`0.0%`	`0/8`
`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/payment/v1`	`0.0%`	`0/9`
`github.com/kont1n/MSA_Rocket_Factory/payment/internal/model`	`0.0%`	`0/7`
`github.com/kont1n/MSA_Rocket_Factory/payment/internal/service/payment`	`100.0%`	`4/4`

This coverage report has been generated with the following command:

gocov test github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/converter github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/v1 github.com/kont1n/MSA_Rocket_Factory/inventory/internal/model github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/converter github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo github.com/kont1n/MSA_Rocket_Factory/inventory/internal/service/part github.com/kont1n/MSA_Rocket_Factory/order/internal/api/middleware github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1 github.com/kont1n/MSA_Rocket_Factory/order/internal/client/converter github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/inventory/v1 github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/payment/v1 github.com/kont1n/MSA_Rocket_Factory/order/internal/model github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/converter github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/inmemory github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/converter github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/middleware github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/payment/v1 github.com/kont1n/MSA_Rocket_Factory/payment/internal/model github.com/kont1n/MSA_Rocket_Factory/payment/internal/service/payment | gocov-html

Package Overview: github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/converter 100.0%

Please select a function to see what's left for testing.

`ToProtoPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/converter/part.go`	`100.0%`	`19/19`
`ToModelPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/converter/filter.go`	`100.0%`	`15/15`

func ToProtoPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/api/converter/part.go:

func ToProtoPart(part *model.Part) *inventoryV1.Part {
        // Конвертируем Category из model.Category в inventoryV1.Category
        var protoCategory inventoryV1.Category
        switch part.Category {
        case model.ENGINE:
                protoCategory = inventoryV1.Category_CATEGORY_ENGINE
        case model.FUEL:
                protoCategory = inventoryV1.Category_CATEGORY_FUEL
        case model.PORTHOLE:
                protoCategory = inventoryV1.Category_CATEGORY_PORTHOLE
        case model.WING:
                protoCategory = inventoryV1.Category_CATEGORY_WING
        default:
                protoCategory = inventoryV1.Category_CATEGORY_UNSPECIFIED
        }

        // Конвертируем Dimensions
        dimensions := &inventoryV1.Dimensions{
                Length: part.Dimensions.Length,
                Width:  part.Dimensions.Width,
                Height: part.Dimensions.Height,
                Weight: part.Dimensions.Weight,
        }

        // Конвертируем Manufacturer
        manufacturer := &inventoryV1.Manufacturer{
                Name:    part.Manufacturer.Name,
                Country: part.Manufacturer.Country,
                Url:     part.Manufacturer.Website,
        }

        // Конвертируем Metadata
        metadata := make(map[string]*inventoryV1.Value)
        for key, value := range part.Metadata {
                protoValue := &inventoryV1.Value{}
                switch {
                case value.StringValue != "":
                        protoValue.Kind = &inventoryV1.Value_StringValue{StringValue: value.StringValue}
                case value.Int64Value != 0:
                        protoValue.Kind = &inventoryV1.Value_Int64Value{Int64Value: value.Int64Value}
                case value.Float64Value != 0:
                        protoValue.Kind = &inventoryV1.Value_DoubleValue{DoubleValue: value.Float64Value}
                case value.BoolValue:
                        protoValue.Kind = &inventoryV1.Value_BoolValue{BoolValue: value.BoolValue}
                }
                metadata[key] = protoValue
        }

        return &inventoryV1.Part{
                PartUuid:      part.OrderUuid.String(),
                Name:          part.Name,
                Description:   part.Description,
                Price:         part.Price,
                StockQuantity: part.StockQuantity,
                Category:      protoCategory,
                Dimensions:    dimensions,
                Manufacturer:  manufacturer,
                Tags:          part.Tags,
                Metadata:      metadata,
                CreatedAt:     timestamppb.New(part.CreatedAt),
                UpdatedAt:     timestamppb.New(part.UpdatedAt),
        }
}

func ToModelPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/api/converter/filter.go:

func ToModelPart(req *inventoryV1.ListPartsRequest) *model.Filter {
        if req.Filter != nil {
                uuids := make([]uuid.UUID, 0, len(req.Filter.PartUuid))
                for _, uuidStr := range req.Filter.PartUuid {
                        if uuid, err := uuid.Parse(uuidStr); err == nil {
                                uuids = append(uuids, uuid)
                        }
                }

                categories := make([]model.Category, 0, len(req.Filter.Category))
                for _, protoCategory := range req.Filter.Category {
                        switch protoCategory {
                        case inventoryV1.Category_CATEGORY_ENGINE:
                                categories = append(categories, model.ENGINE)
                        case inventoryV1.Category_CATEGORY_FUEL:
                                categories = append(categories, model.FUEL)
                        case inventoryV1.Category_CATEGORY_PORTHOLE:
                                categories = append(categories, model.PORTHOLE)
                        case inventoryV1.Category_CATEGORY_WING:
                                categories = append(categories, model.WING)
                        }
                }

                filter := &model.Filter{
                        Uuids:                 uuids,
                        Names:                 req.Filter.PartName,
                        Categories:            categories,
                        ManufacturerCountries: req.Filter.ManufacturerCountry,
                        Tags:                  req.Filter.Tags,
                }
                return filter
        }

        return nil
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/v1 0.0%

Please select a function to see what's left for testing.

`api.GetPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/v1/get.go`	`0.0%`	`0/13`
`api.ListParts(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/v1/list.go`	`0.0%`	`0/12`
`NewAPI(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/api/v1/api.go`	`0.0%`	`0/1`

func api.GetPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/api/v1/get.go:

func (a *api) GetPart(ctx context.Context, req *inventoryV1.GetPartRequest) (*inventoryV1.GetPartResponse, error) {
        id, err := uuid.Parse(req.PartUuid)
        if err != nil {
                return nil, status.Errorf(codes.InvalidArgument, "invalid part uuid")
        }

        part, err := a.inventoryService.GetPart(ctx, id)
        if err != nil {
                slog.Error("Failed to get part", "id:", id, "error:", err)

                if errors.Is(err, model.ErrPartNotFound) {
                        return nil, status.Errorf(codes.NotFound, "part not found")
                }

                if errors.Is(err, model.ErrConvertFromRepo) {
                        return nil, status.Errorf(codes.Internal, "failed to get part")
                }

                return nil, status.Error(codes.Internal, err.Error())
        }

        protoPart := converter.ToProtoPart(part)
        return &inventoryV1.GetPartResponse{Part: protoPart}, nil
}

func api.ListParts

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/api/v1/list.go:

func (a *api) ListParts(ctx context.Context, req *inventoryV1.ListPartsRequest) (*inventoryV1.ListPartsResponse, error) {
        filter := converter.ToModelPart(req)

        parts, err := a.inventoryService.ListParts(ctx, filter)
        if err != nil {
                slog.Error("Failed to get list part", "filter:", filter, "error:", err)

                if errors.Is(err, model.ErrConvertFromRepo) {
                        return nil, status.Errorf(codes.Internal, "failed to get list parts")
                }

                return nil, status.Error(codes.Internal, err.Error())
        }

        protoParts := make([]*inventoryV1.Part, 0, len(*parts))
        for _, part := range *parts {
                protoPart := converter.ToProtoPart(&part)
                protoParts = append(protoParts, protoPart)
        }

        return &inventoryV1.ListPartsResponse{Parts: protoParts}, nil
}

func NewAPI

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/api/v1/api.go:

14	`func NewAPI(inventoryService service.InventoryService) *api {`
15	`return &api{inventoryService: inventoryService}`
16	`}`

Package Overview: github.com/kont1n/MSA_Rocket_Factory/inventory/internal/model 100.0%

Please select a function to see what's left for testing.

`Category.String(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/model/category.go`	`100.0%`	`6/6`
`ToCategory(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/model/category.go`	`100.0%`	`3/3`
`CategoryName(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/model/category.go`	`100.0%`	`1/1`

func Category.String

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/model/category.go:

func (c Category) String() string {
        switch c {
        case ENGINE:
                return "ENGINE"
        case FUEL:
                return "FUEL"
        case PORTHOLE:
                return "PORTHOLE"
        case WING:
                return "WING"
        default:
                return "UNKNOWN"
        }
}

func ToCategory

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/model/category.go:

func ToCategory(value int) Category {
        switch value {
        case int(ENGINE), int(FUEL), int(PORTHOLE), int(WING):
                return Category(value)
        default:
                return UNKNOWN
        }
}

func CategoryName

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/model/category.go:

28	`func CategoryName(value int) string {`
29	`return Category(value).String()`
30	`}`

Package Overview: github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/converter 60.0%

Please select a function to see what's left for testing.

`ToModelPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/converter/part.go`	`100.0%`	`9/9`
`ToRepositoryPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/converter/part.go`	`0.0%`	`0/6`

func ToModelPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/converter/part.go:

func ToModelPart(repoPart *repoModel.RepositoryPart) (part *model.Part, err error) {
        id, err := uuid.Parse(repoPart.OrderUuid)
        if err != nil {
                return nil, model.ErrConvertFromRepo
        }

        manufacturer := model.Manufacturer{
                Name:    repoPart.Manufacturer.Name,
                Country: repoPart.Manufacturer.Country,
                Website: repoPart.Manufacturer.Website,
        }

        dimension := model.Dimensions{
                Length: repoPart.Dimensions.Length,
                Width:  repoPart.Dimensions.Width,
                Height: repoPart.Dimensions.Height,
                Weight: repoPart.Dimensions.Weight,
        }

        metadata := make(map[string]model.Value)
        for key, value := range repoPart.Metadata {
                metadata[key] = model.Value{
                        StringValue:  value.StringValue,
                        Int64Value:   value.Int64Value,
                        Float64Value: value.Float64Value,
                        BoolValue:    value.BoolValue,
                }
        }

        return &model.Part{
                OrderUuid:     id,
                Name:          repoPart.Name,
                Description:   repoPart.Description,
                Price:         repoPart.Price,
                StockQuantity: repoPart.StockQuantity,
                Category:      model.ToCategory(repoPart.Category),
                Dimensions:    dimension,
                Manufacturer:  manufacturer,
                Tags:          repoPart.Tags,
                Metadata:      metadata,
                CreatedAt:     repoPart.CreatedAt,
                UpdatedAt:     repoPart.UpdatedAt,
        }, nil
}

func ToRepositoryPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/converter/part.go:

func ToRepositoryPart(part *model.Part) *repoModel.RepositoryPart {
        manufacturer := repoModel.Manufacturer{
                Name:    part.Manufacturer.Name,
                Country: part.Manufacturer.Country,
                Website: part.Manufacturer.Website,
        }

        dimension := repoModel.Dimensions{
                Length: part.Dimensions.Length,
                Width:  part.Dimensions.Width,
                Height: part.Dimensions.Height,
                Weight: part.Dimensions.Weight,
        }

        metadata := make(map[string]repoModel.Value)
        for key, value := range part.Metadata {
                metadata[key] = repoModel.Value{
                        StringValue:  value.StringValue,
                        Int64Value:   value.Int64Value,
                        Float64Value: value.Float64Value,
                        BoolValue:    value.BoolValue,
                }
        }

        return &repoModel.RepositoryPart{
                OrderUuid:     part.OrderUuid.String(),
                Name:          part.Name,
                Description:   part.Description,
                Price:         part.Price,
                StockQuantity: part.StockQuantity,
                Category:      int(part.Category),
                Dimensions:    dimension,
                Manufacturer:  manufacturer,
                Tags:          part.Tags,
                Metadata:      metadata,
                CreatedAt:     part.CreatedAt,
                UpdatedAt:     part.UpdatedAt,
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory 0.0%

Please select a function to see what's left for testing.

`filtration(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory/list.go`	`0.0%`	`0/38`
`repository.ListParts(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory/list.go`	`0.0%`	`0/14`
`repository.GetPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory/get.go`	`0.0%`	`0/10`
`repository.addTestData(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory/testdata.go`	`0.0%`	`0/4`
`NewRepository(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/inmemory/repository.go`	`0.0%`	`0/3`

func filtration

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/inmemory/list.go:

func filtration(filter *model.Filter, parts []*repoModel.RepositoryPart) (result []*repoModel.RepositoryPart) {
        // Создаем мап для фильтрации
        uuidSet := make(map[string]bool)
        for _, uuid := range filter.Uuids {
                uuidSet[uuid.String()] = true
        }

        nameSet := make(map[string]bool)
        for _, name := range filter.Names {
                nameSet[name] = true
        }

        categorySet := make(map[int]bool)
        for _, category := range filter.Categories {
                categorySet[int(category)] = true
        }

        manufacturerCountrySet := make(map[string]bool)
        for _, manufacturerCountry := range filter.ManufacturerCountries {
                manufacturerCountrySet[manufacturerCountry] = true
        }

        tagSet := make(map[string]bool)
        for _, tag := range filter.Tags {
                tagSet[tag] = true
        }

        // Фильтруем детали
        for _, part := range parts {
                if len(uuidSet) > 0 {
                        if _, ok := uuidSet[part.OrderUuid]; !ok {
                                continue
                        }
                }

                if len(nameSet) > 0 {
                        if _, ok := nameSet[part.Name]; !ok {
                                continue
                        }
                }

                if len(categorySet) > 0 {
                        if _, ok := categorySet[part.Category]; !ok {
                                continue
                        }
                }

                if len(manufacturerCountrySet) > 0 {
                        if _, ok := manufacturerCountrySet[part.Manufacturer.Country]; !ok {
                                continue
                        }
                }

                if len(tagSet) > 0 {
                        // Проверяем, есть ли хотя бы один тег из фильтра в тегах детали
                        tagFound := false
                        for _, partTag := range part.Tags {
                                if _, ok := tagSet[partTag]; ok {
                                        tagFound = true
                                        break
                                }
                        }
                        if !tagFound {
                                continue
                        }
                }

                result = append(result, part)
        }

        return result
}

func repository.ListParts

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/inmemory/list.go:

func (r *repository) ListParts(ctx context.Context, filter *model.Filter) (*[]model.Part, error) {
        partsFiltered := make([]*repoModel.RepositoryPart, 0)
        r.mu.RLock()
        for _, part := range r.data {
                partsFiltered = append(partsFiltered, part)
        }
        r.mu.RUnlock()

        if filter != nil {
                partsFiltered = filtration(filter, partsFiltered)
        }

        parts := make([]model.Part, 0, len(partsFiltered))
        for _, repoPart := range partsFiltered {
                part, err := repoConverter.ToModelPart(repoPart)
                if err != nil {
                        return nil, err
                }
                parts = append(parts, lo.FromPtr(part))
        }

        return &parts, nil
}

func repository.GetPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/inmemory/get.go:

func (r *repository) GetPart(ctx context.Context, uuid uuid.UUID) (*model.Part, error) {
        partUuid := uuid.String()

        r.mu.RLock()
        repoPart, ok := r.data[partUuid]
        r.mu.RUnlock()

        if !ok {
                return nil, model.ErrPartNotFound
        }

        part, err := repoConverter.ToModelPart(repoPart)
        if err != nil {
                return nil, err
        }

        return part, nil
}

func repository.addTestData

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/inmemory/testdata.go:

func (r *repository) addTestData() {
        log.Printf("Add Test Data for inventory service")

        r.mu.Lock()
        defer r.mu.Unlock()

        r.data = map[string]*repoModel.RepositoryPart{
                "d973e963-b7e6-4323-8f4e-4bfd5ab8e834": {
                        OrderUuid:     "d973e963-b7e6-4323-8f4e-4bfd5ab8e834",
                        Name:          "Detail 1",
                        Description:   "Detail 1 description",
                        Price:         100,
                        StockQuantity: 10,
                        Category:      1, // ENGINE
                        Dimensions: repoModel.Dimensions{
                                Length: 100,
                                Width:  100,
                                Height: 100,
                                Weight: 100,
                        },
                        Manufacturer: repoModel.Manufacturer{
                                Country: "China",
                                Name:    "Details Fabric",
                        },
                        Tags:      []string{"tag1", "tag2"},
                        CreatedAt: time.Now(),
                        UpdatedAt: time.Now(),
                },
                "d973e963-b7e6-4323-8f4e-4bfd5ab8e835": {
                        OrderUuid:     "d973e963-b7e6-4323-8f4e-4bfd5ab8e835",
                        Name:          "Detail 2",
                        Description:   "Detail 2 description",
                        Price:         200,
                        StockQuantity: 20,
                        Category:      1, // ENGINE
                        Dimensions: repoModel.Dimensions{
                                Length: 100,
                                Width:  100,
                                Height: 100,
                                Weight: 100,
                        },
                        Manufacturer: repoModel.Manufacturer{
                                Country: "USA",
                                Name:    "Details Fabric",
                        },
                        Tags:      []string{"tag1", "tag2"},
                        CreatedAt: time.Now(),
                        UpdatedAt: time.Now(),
                },
        }
}

func NewRepository

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/inmemory/repository.go:

func NewRepository() *repository {
        repo := &repository{
                data: make(map[string]*repoModel.RepositoryPart),
        }

        repo.addTestData()

        return repo
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo 0.0%

Please select a function to see what's left for testing.

`buildMongoFilter(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo/list.go`	`0.0%`	`0/20`
`repository.AddTestData(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo/testdata.go`	`0.0%`	`0/18`
`repository.ListParts(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo/list.go`	`0.0%`	`0/16`
`repository.GetPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo/get.go`	`0.0%`	`0/12`
`NewRepository(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo/repository.go`	`0.0%`	`0/4`
`@26:8(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/repository/mongo/list.go`	`0.0%`	`0/3`

func buildMongoFilter

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/mongo/list.go:

func buildMongoFilter(filter *model.Filter) bson.M {
        if filter == nil {
                return bson.M{}
        }

        mongoFilter := bson.M{}

        // Фильтр по UUID
        if len(filter.Uuids) > 0 {
                uuidStrings := make([]string, len(filter.Uuids))
                for i, uuid := range filter.Uuids {
                        uuidStrings[i] = uuid.String()
                }
                mongoFilter["order_uuid"] = bson.M{"$in": uuidStrings}
        }

        // Фильтр по именам
        if len(filter.Names) > 0 {
                mongoFilter["name"] = bson.M{"$in": filter.Names}
        }

        // Фильтр по категориям
        if len(filter.Categories) > 0 {
                categoryInts := make([]int, len(filter.Categories))
                for i, category := range filter.Categories {
                        categoryInts[i] = int(category)
                }
                mongoFilter["category"] = bson.M{"$in": categoryInts}
        }

        // Фильтр по странам производителей
        if len(filter.ManufacturerCountries) > 0 {
                mongoFilter["manufacturer.country"] = bson.M{"$in": filter.ManufacturerCountries}
        }

        // Фильтр по тегам (должен содержать хотя бы один из указанных тегов)
        if len(filter.Tags) > 0 {
                mongoFilter["tags"] = bson.M{"$in": filter.Tags}
        }

        return mongoFilter
}

func repository.AddTestData

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/mongo/testdata.go:

func (r *repository) AddTestData(ctx context.Context) error {
        log.Printf("Добавление тестовых данных для инвентаря в MongoDB")

        collection := r.db.Collection(partsCollection)

        // Проверяем, есть ли уже данные в коллекции
        count, err := collection.CountDocuments(ctx, map[string]interface{}{})
        if err != nil {
                return err
        }

        if count > 0 {
                log.Printf("Тестовые данные уже существуют в коллекции, пропускаем добавление")
                return nil
        }

        // Создаем тестовые данные
        testParts := []repoModel.RepositoryPart{
                {
                        OrderUuid:     "d973e963-b7e6-4323-8f4e-4bfd5ab8e834",
                        Name:          "Ракетный двигатель RD-180",
                        Description:   "Мощный ракетный двигатель для тяжелых носителей",
                        Price:         15000000.50,
                        StockQuantity: 5,
                        Category:      1, // ENGINE
                        Dimensions: repoModel.Dimensions{
                                Length: 355.6,
                                Width:  297.2,
                                Height: 297.2,
                                Weight: 5480.0,
                        },
                        Manufacturer: repoModel.Manufacturer{
                                Name:    "Energomash",
                                Country: "Russia",
                                Website: "https://www.energomash.ru",
                        },
                        Tags: []string{"rocket", "engine", "rd-180", "heavy-lift"},
                        Metadata: map[string]repoModel.Value{
                                "thrust": {
                                        Float64Value: 3830000.0,
                                },
                                "fuel_type": {
                                        StringValue: "RP-1/LOX",
                                },
                                "reusable": {
                                        BoolValue: false,
                                },
                                "test_fires": {
                                        Int64Value: 150,
                                },
                        },
                        CreatedAt: time.Now(),
                        UpdatedAt: time.Now(),
                },
                {
                        OrderUuid:     "d973e963-b7e6-4323-8f4e-4bfd5ab8e835",
                        Name:          "Система управления Navigation-1",
                        Description:   "Навигационная система для космических аппаратов",
                        Price:         750000.00,
                        StockQuantity: 12,
                        Category:      2, // ELECTRONICS
                        Dimensions: repoModel.Dimensions{
                                Length: 50.0,
                                Width:  40.0,
                                Height: 15.0,
                                Weight: 8.5,
                        },
                        Manufacturer: repoModel.Manufacturer{
                                Name:    "SpaceX",
                                Country: "USA",
                                Website: "https://www.spacex.com",
                        },
                        Tags: []string{"navigation", "electronics", "gps", "space"},
                        Metadata: map[string]repoModel.Value{
                                "accuracy": {
                                        StringValue: "sub-meter",
                                },
                                "frequency": {
                                        Float64Value: 1575.42,
                                },
                                "channels": {
                                        Int64Value: 32,
                                },
                                "space_qualified": {
                                        BoolValue: true,
                                },
                        },
                        CreatedAt: time.Now(),
                        UpdatedAt: time.Now(),
                },
                {
                        OrderUuid:     "d973e963-b7e6-4323-8f4e-4bfd5ab8e836",
                        Name:          "Топливный бак Falcon-Tank-9",
                        Description:   "Алюминиевый топливный бак для среднего класса ракет",
                        Price:         2500000.75,
                        StockQuantity: 8,
                        Category:      3, // STRUCTURE
                        Dimensions: repoModel.Dimensions{
                                Length: 1200.0,
                                Width:  366.0,
                                Height: 366.0,
                                Weight: 25000.0,
                        },
                        Manufacturer: repoModel.Manufacturer{
                                Name:    "Boeing",
                                Country: "USA",
                                Website: "https://www.boeing.com/space",
                        },
                        Tags: []string{"fuel", "tank", "structure", "aluminum"},
                        Metadata: map[string]repoModel.Value{
                                "capacity": {
                                        Float64Value: 400000.0,
                                },
                                "material": {
                                        StringValue: "Al-Li 2195",
                                },
                                "pressure_rating": {
                                        Float64Value: 3.5,
                                },
                                "insulated": {
                                        BoolValue: true,
                                },
                        },
                        CreatedAt: time.Now(),
                        UpdatedAt: time.Now(),
                },
        }

        // Конвертируем в interface{} для вставки
        docs := make([]interface{}, len(testParts))
        for i, part := range testParts {
                docs[i] = part
        }

        // Вставляем тестовые данные
        result, err := collection.InsertMany(ctx, docs)
        if err != nil {
                log.Printf("Ошибка при добавлении тестовых данных: %v", err)
                return err
        }

        log.Printf("Успешно добавлено %d тестовых записей в коллекцию %s", len(result.InsertedIDs), partsCollection)
        return nil
}

func repository.ListParts

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/mongo/list.go:

func (r *repository) ListParts(ctx context.Context, filter *model.Filter) (*[]model.Part, error) {
        collection := r.db.Collection(partsCollection)

        // Создаем фильтр для MongoDB
        mongoFilter := buildMongoFilter(filter)

        // Выполняем запрос
        cursor, err := collection.Find(ctx, mongoFilter)
        if err != nil {
                return nil, err
        }
        defer func(cursor *mongo.Cursor, ctx context.Context) {
                err := cursor.Close(ctx)
                if err != nil {
                        log.Printf("failed to close cursor: %v", err)
                }
        }(cursor, ctx)

        // Читаем результаты
        var repoParts []repoModel.RepositoryPart
        if err = cursor.All(ctx, &repoParts); err != nil {
                return nil, err
        }

        // Преобразуем в основные модели
        parts := make([]model.Part, 0, len(repoParts))
        for _, repoPart := range repoParts {
                part, err := repoConverter.ToModelPart(&repoPart)
                if err != nil {
                        return nil, err
                }
                parts = append(parts, *part)
        }

        return &parts, nil
}

func repository.GetPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/mongo/get.go:

func (r *repository) GetPart(ctx context.Context, uuid uuid.UUID) (*model.Part, error) {
        collection := r.db.Collection(partsCollection)

        filter := bson.M{"order_uuid": uuid.String()}

        var repoPart repoModel.RepositoryPart
        err := collection.FindOne(ctx, filter).Decode(&repoPart)
        if err != nil {
                if errors.Is(err, mongo.ErrNoDocuments) {
                        return nil, model.ErrPartNotFound
                }
                return nil, err
        }

        // Преобразуем модель репозитория в основную модель
        part, err := repoConverter.ToModelPart(&repoPart)
        if err != nil {
                return nil, err
        }

        return part, nil
}

func NewRepository

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/mongo/repository.go:

func NewRepository(database *mongo.Database) *repository {
        repo := &repository{
                db: database,
        }

        // Добавляем тестовые данные при инициализации
        if err := repo.AddTestData(context.Background()); err != nil {
                log.Printf("Предупреждение: не удалось добавить тестовые данные в MongoDB: %v", err)
        }

        return repo
}

func @26:8

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/repository/mongo/list.go:

func(cursor *mongo.Cursor, ctx context.Context) {
                err := cursor.Close(ctx)
                if err != nil {
                        log.Printf("failed to close cursor: %v", err)
                }
        }

Package Overview: github.com/kont1n/MSA_Rocket_Factory/inventory/internal/service/part 100.0%

Please select a function to see what's left for testing.

`service.GetPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/service/part/get.go`	`100.0%`	`4/4`
`service.ListParts(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/service/part/list.go`	`100.0%`	`4/4`
`NewService(...)`	`github.com/kont1n/MSA_Rocket_Factory/inventory/internal/service/part/service.go`	`100.0%`	`1/1`

func service.GetPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/service/part/get.go:

func (s *service) GetPart(ctx context.Context, uuid uuid.UUID) (*model.Part, error) {
        part, err := s.repo.GetPart(ctx, uuid)
        if err != nil {
                return nil, fmt.Errorf("service: failed to get part from repository: %w", err)
        }

        return part, nil
}

func service.ListParts

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/service/part/list.go:

func (s *service) ListParts(ctx context.Context, filter *model.Filter) (*[]model.Part, error) {
        parts, err := s.repo.ListParts(ctx, filter)
        if err != nil {
                return nil, fmt.Errorf("service: failed to get list of parts from repository: %w", err)
        }

        return parts, nil
}

func NewService

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/inventory/internal/service/part/service.go:

func NewService(repo repository.InventoryRepository) *service {
        return &service{
                repo: repo,
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/api/middleware 0.0%

Please select a function to see what's left for testing.

`@11:26(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/middleware/request_logger.go`	`0.0%`	`0/5`
`RequestLogger(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/middleware/request_logger.go`	`0.0%`	`0/1`

func @11:26

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/middleware/request_logger.go:

11	`func(w http.ResponseWriter, r *http.Request) {`
12	`// Засекаем время начала обработки запроса`
13	`startTime := time.Now()`
14
15	`// Логируем начало запроса`
16	`log.Printf("⏱️ Начало запроса: %s %s", r.Method, r.URL.Path)`
17
18	`// Передаем управление следующему обработчику`
19	`next.ServeHTTP(w, r)`
20
21	`// Вычисляем время выполнения запроса`
22	`duration := time.Since(startTime)`
23
24	`// Логируем окончание запроса с временем выполнения`
25	`log.Printf("✅ Запрос завершен: %s %s, время выполнения: %v", r.Method, r.URL.Path, duration)`
26	`}`

func RequestLogger

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/middleware/request_logger.go:

10	`func RequestLogger(next http.Handler) http.Handler {`
11	`return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {`
12	`// Засекаем время начала обработки запроса`
13	`startTime := time.Now()`
14
15	`// Логируем начало запроса`
16	`log.Printf("⏱️ Начало запроса: %s %s", r.Method, r.URL.Path)`
17
18	`// Передаем управление следующему обработчику`
19	`next.ServeHTTP(w, r)`
20
21	`// Вычисляем время выполнения запроса`
22	`duration := time.Since(startTime)`
23
24	`// Логируем окончание запроса с временем выполнения`
25	`log.Printf("✅ Запрос завершен: %s %s, время выполнения: %v", r.Method, r.URL.Path, duration)`
26	`})`
27	`}`

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1 0.0%

Please select a function to see what's left for testing.

`api.CancelOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1/cancel.go`	`0.0%`	`0/14`
`api.CreateOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1/create.go`	`0.0%`	`0/14`
`api.PayOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1/pay.go`	`0.0%`	`0/14`
`api.GetOrderByUUID(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1/get.go`	`0.0%`	`0/9`
`api.NewError(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1/error.go`	`0.0%`	`0/5`
`NewAPI(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/api/order/v1/api.go`	`0.0%`	`0/1`

func api.CancelOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/order/v1/cancel.go:

func (a *api) CancelOrder(ctx context.Context, params orderV1.CancelOrderParams) (orderV1.CancelOrderRes, error) {
        orderDraft := model.Order{
                OrderUUID: params.OrderUUID,
        }

        _, err := a.orderService.CancelOrder(ctx, lo.ToPtr(orderDraft))
        if err != nil {
                slog.Error("Cancel order error", "order:", params.OrderUUID, "error:", err)

                if errors.Is(err, model.ErrOrderNotFound) {
                        return &orderV1.NotFoundError{
                                Code:    http.StatusNotFound,
                                Message: "order not found",
                        }, nil
                }

                if errors.Is(err, model.ErrConvertFromRepo) {
                        return &orderV1.InternalServerError{
                                Code:    http.StatusInternalServerError,
                                Message: "cannot convert order from repository",
                        }, nil
                }

                if errors.Is(err, model.ErrPaid) {
                        return &orderV1.BadRequestError{
                                Code:    http.StatusBadRequest,
                                Message: "order already paid",
                        }, nil
                }

                if errors.Is(err, model.ErrCancelled) {
                        return &orderV1.BadRequestError{
                                Code:    http.StatusBadRequest,
                                Message: "order already cancelled",
                        }, nil
                }

                return nil, err
        }

        return &orderV1.CancelOrderNoContent{}, nil
}

func api.CreateOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/order/v1/create.go:

func (a *api) CreateOrder(ctx context.Context, req *orderV1.CreateOrderRequest) (orderV1.CreateOrderRes, error) {
        orderDraft := model.Order{
                UserUUID:  uuid.UUID(req.UserUUID),
                PartUUIDs: req.PartUuids,
        }

        createOrder, err := a.orderService.CreateOrder(ctx, &orderDraft)
        if err != nil {
                slog.Error("Create order error", "order:", req, "error:", err)

                if errors.Is(err, model.ErrPartsSpecified) {
                        return &orderV1.BadRequestError{
                                Code:    http.StatusBadRequest,
                                Message: "parts not specified",
                        }, nil
                }

                if errors.Is(err, model.ErrPartsListNotFound) {
                        return &orderV1.NotFoundError{
                                Code:    http.StatusNotFound,
                                Message: "parts not found",
                        }, nil
                }

                if errors.Is(err, model.ErrConvertFromClient) {
                        return &orderV1.InternalServerError{
                                Code:    http.StatusInternalServerError,
                                Message: "can't parse part",
                        }, nil
                }

                if errors.Is(err, model.ErrInventoryClient) {
                        return &orderV1.InternalServerError{
                                Code:    http.StatusFailedDependency,
                                Message: "inventory client error",
                        }, nil
                }

                return nil, err
        }

        return &orderV1.CreateOrderResponse{
                OrderUUID: orderV1.OrderUUID(createOrder.OrderUUID),
                TotalPrice: orderV1.OptTotalPrice{
                        Value: orderV1.TotalPrice(createOrder.TotalPrice),
                        Set:   true,
                },
        }, nil
}

func api.PayOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/order/v1/pay.go:

func (a *api) PayOrder(ctx context.Context, req *orderV1.PayOrderRequest, params orderV1.PayOrderParams) (orderV1.PayOrderRes, error) {
        orderDraft := model.Order{
                OrderUUID:     params.OrderUUID,
                PaymentMethod: string(req.PaymentMethod),
        }

        order, err := a.orderService.PayOrder(ctx, &orderDraft)
        if err != nil {
                slog.Error("Pay order error", "order", params.OrderUUID, "error", err)

                if errors.Is(err, model.ErrOrderNotFound) {
                        return &orderV1.NotFoundError{
                                Code:    http.StatusNotFound,
                                Message: "order not found",
                        }, nil
                }

                if errors.Is(err, model.ErrConvertFromRepo) {
                        return &orderV1.InternalServerError{
                                Code:    http.StatusInternalServerError,
                                Message: "cannot convert order from repository",
                        }, nil
                }

                if errors.Is(err, model.ErrConvertFromClient) {
                        return &orderV1.InternalServerError{
                                Code:    http.StatusInternalServerError,
                                Message: "can't parse transaction",
                        }, nil
                }

                if errors.Is(err, model.ErrPaymentClient) {
                        return &orderV1.InternalServerError{
                                Code:    http.StatusFailedDependency,
                                Message: "payment client error",
                        }, nil
                }

                return nil, err
        }

        return &orderV1.PayOrderResponse{
                TransactionUUID: orderV1.TransactionUUID(order.TransactionUUID),
        }, nil
}

func api.GetOrderByUUID

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/order/v1/get.go:

func (a *api) GetOrderByUUID(ctx context.Context, params orderV1.GetOrderByUUIDParams) (orderV1.GetOrderByUUIDRes, error) {
        order, err := a.orderService.GetOrder(ctx, params.OrderUUID)
        if err != nil {
                slog.Error("Get order error", "order", params.OrderUUID, "error", err)

                if errors.Is(err, model.ErrOrderNotFound) {
                        return &orderV1.NotFoundError{
                                Code:    http.StatusNotFound,
                                Message: "order not found",
                        }, nil
                }

                if errors.Is(err, model.ErrConvertFromRepo) {
                        return &orderV1.InternalServerError{
                                Code:    http.StatusInternalServerError,
                                Message: "cannot convert order from repository",
                        }, nil
                }

                return nil, err
        }

        return &orderV1.OrderDto{
                OrderUUID: order.OrderUUID,
                UserUUID:  order.UserUUID,
                PartUuids: order.PartUUIDs,
                TotalPrice: orderV1.OptFloat32{
                        Value: float32(order.TotalPrice),
                        Set:   true,
                },
                TransactionUUID: orderV1.OptUUID{
                        Value: order.TransactionUUID,
                        Set:   true,
                },
                PaymentMethod: orderV1.OptPaymentMethod{
                        Value: orderV1.PaymentMethod(order.PaymentMethod),
                        Set:   true,
                },
                Status: orderV1.OrderStatus(order.Status),
        }, nil
}

func api.NewError

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/order/v1/error.go:

func (a *api) NewError(ctx context.Context, err error) *orderV1.GenericErrorStatusCode {
        code := orderV1.OptInt{}
        code.SetTo(http.StatusInternalServerError)

        message := orderV1.OptString{}
        message.SetTo(err.Error())

        return &orderV1.GenericErrorStatusCode{
                StatusCode: http.StatusInternalServerError,
                Response: orderV1.GenericError{
                        Code:    code,
                        Message: message,
                },
        }
}

func NewAPI

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/api/order/v1/api.go:

func NewAPI(service service.OrderService) *api {
        return &api{
                orderService: service,
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/client/converter 100.0%

Please select a function to see what's left for testing.

`ToProtoFilter(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/converter/filter.go`	`100.0%`	`9/9`
`ToModelPartsList(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/converter/part.go`	`100.0%`	`7/7`
`ToModelPart(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/converter/part.go`	`100.0%`	`4/4`
`ToProtoPaymentMethod(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/converter/payment.go`	`100.0%`	`4/4`

func ToProtoFilter

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/converter/filter.go:

func ToProtoFilter(filter *model.Filter) *inventoryV1.PartsFilter {
        uuids := make([]string, 0, len(filter.PartUUIDs))
        for _, id := range filter.PartUUIDs {
                uuids = append(uuids, id.String())
        }

        categories := make([]inventoryV1.Category, 0, len(filter.Categories))
        for _, category := range filter.Categories {
                // Безопасная конвертация int в int32 через строку
                categoryStr := strconv.Itoa(int(category))
                if categoryInt32, err := strconv.ParseInt(categoryStr, 10, 32); err == nil {
                        categories = append(categories, inventoryV1.Category(int32(categoryInt32)))
                }
        }

        return &inventoryV1.PartsFilter{
                PartUuid:            uuids,
                PartName:            filter.PartNames,
                Category:            categories,
                ManufacturerCountry: filter.ManufacturerCountries,
                Tags:                filter.Tags,
        }
}

func ToModelPartsList

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/converter/part.go:

func ToModelPartsList(parts []*inventoryV1.Part) (*[]model.Part, error) {
        result := make([]model.Part, 0, len(parts))
        for _, part := range parts {
                modelPart, err := ToModelPart(part)
                if err != nil {
                        return nil, err
                }
                result = append(result, *modelPart)
        }
        return &result, nil
}

func ToModelPart

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/converter/part.go:

func ToModelPart(part *inventoryV1.Part) (*model.Part, error) {
        id, err := uuid.Parse(part.PartUuid)
        if err != nil {
                return nil, model.ErrConvertFromClient
        }
        return &model.Part{
                PartUUID:    id,
                Name:        part.Name,
                Description: part.Description,
                Price:       part.Price,
        }, nil
}

func ToProtoPaymentMethod

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/converter/payment.go:

func ToProtoPaymentMethod(paymentMethod string) generaredPaymentV1.PaymentMethod {
        intPaymentMethod, ok := generaredPaymentV1.PaymentMethod_value["PAYMENT_METHOD_"+paymentMethod]
        if !ok {
                intPaymentMethod = int32(generaredPaymentV1.PaymentMethod_PAYMENT_METHOD_UNSPECIFIED)
        }
        return generaredPaymentV1.PaymentMethod(intPaymentMethod)
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/inventory/v1 0.0%

Please select a function to see what's left for testing.

`inventoryClient.ListParts(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/inventory/v1/list.go`	`0.0%`	`0/7`
`NewClient(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/inventory/v1/client.go`	`0.0%`	`0/1`

func inventoryClient.ListParts

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/grpc/inventory/v1/list.go:

func (c inventoryClient) ListParts(ctx context.Context, filter *model.Filter) (*[]model.Part, error) {
        parts, err := c.generatedClient.ListParts(ctx, &generaredInventoryV1.ListPartsRequest{
                Filter: converter.ToProtoFilter(filter),
        })
        if err != nil {
                return nil, model.ErrInventoryClient
        }

        modelParts, err := converter.ToModelPartsList(parts.Parts)
        if err != nil {
                return nil, err
        }

        return modelParts, nil
}

func NewClient

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/grpc/inventory/v1/client.go:

func NewClient(generatedClient generaredInventoryV1.InventoryServiceClient) *inventoryClient {
        return &inventoryClient{
                generatedClient: generatedClient,
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/payment/v1 0.0%

Please select a function to see what's left for testing.

`paymentClient.CreatePayment(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/payment/v1/pay.go`	`0.0%`	`0/9`
`NewClient(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/client/grpc/payment/v1/client.go`	`0.0%`	`0/1`

func paymentClient.CreatePayment

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/grpc/payment/v1/pay.go:

func (p paymentClient) CreatePayment(ctx context.Context, order *model.Order) (*model.Order, error) {
        // Оплачиваем заказ с помощью gRPC клиента
        response, err := p.generatedClient.PayOrder(ctx, &generaredPaymentV1.PayOrderRequest{
                OrderUuid:     order.OrderUUID.String(),
                UserUuid:      order.UserUUID.String(),
                PaymentMethod: converter.ToProtoPaymentMethod(order.PaymentMethod),
        })
        if err != nil {
                return nil, model.ErrPaymentClient
        }

        transaction, err := uuid.Parse(response.GetTransactionUuid())
        if err != nil {
                return nil, model.ErrConvertFromClient
        }

        // Обновляем заказ
        order.TransactionUUID = transaction
        order.Status = model.StatusPaid

        return order, nil
}

func NewClient

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/client/grpc/payment/v1/client.go:

func NewClient(generatedClient generaredPaymentV1.PaymentServiceClient) *paymentClient {
        return &paymentClient{
                generatedClient: generatedClient,
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/model 0.0%

Please select a function to see what's left for testing.

`Category.String(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/model/category.go`	`0.0%`	`0/6`
`ToCategory(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/model/category.go`	`0.0%`	`0/3`
`CategoryName(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/model/category.go`	`0.0%`	`0/1`

func Category.String

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/model/category.go:

func (c Category) String() string {
        switch c {
        case ENGINE:
                return "ENGINE"
        case FUEL:
                return "FUEL"
        case PORTHOLE:
                return "PORTHOLE"
        case WING:
                return "WING"
        default:
                return "UNKNOWN"
        }
}

func ToCategory

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/model/category.go:

func ToCategory(value int) Category {
        switch value {
        case int(ENGINE), int(FUEL), int(PORTHOLE), int(WING):
                return Category(value)
        default:
                return UNKNOWN
        }
}

func CategoryName

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/model/category.go:

28	`func CategoryName(value int) string {`
29	`return Category(value).String()`
30	`}`

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/converter 84.6%

Please select a function to see what's left for testing.

`ToModelOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/converter/order.go`	`100.0%`	`17/17`
`ToRepoOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/converter/order.go`	`100.0%`	`5/5`
`ToRepoOrderPostgres(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/converter/order.go`	`0.0%`	`0/2`
`ToModelOrderFromPostgres(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/converter/order.go`	`0.0%`	`0/2`

func ToModelOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/converter/order.go:

func ToModelOrder(repoOrder *repoModel.Order) (*model.Order, error) {
        orderId, err := uuid.Parse(repoOrder.OrderUUID)
        if err != nil {
                return nil, model.ErrConvertFromRepo
        }

        userId, err := uuid.Parse(repoOrder.UserUUID)
        if err != nil {
                return nil, model.ErrConvertFromRepo
        }

        transactionId, err := uuid.Parse(repoOrder.TransactionUUID)
        if err != nil {
                return nil, model.ErrConvertFromRepo
        }

        parts := make([]uuid.UUID, 0, len(repoOrder.PartUUIDs))
        for _, partUUID := range repoOrder.PartUUIDs {
                partId, err := uuid.Parse(partUUID)
                if err != nil {
                        return nil, model.ErrConvertFromRepo
                }
                parts = append(parts, partId)
        }

        order := &model.Order{
                OrderUUID:       orderId,
                UserUUID:        userId,
                PartUUIDs:       parts,
                TotalPrice:      repoOrder.TotalPrice,
                TransactionUUID: transactionId,
                PaymentMethod:   repoOrder.PaymentMethod,
                Status:          model.OrderStatus(repoOrder.Status),
        }

        return order, nil
}

func ToRepoOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/converter/order.go:

func ToRepoOrder(order *model.Order) *repoModel.Order {
        parts := make([]string, 0, len(order.PartUUIDs))
        for _, partUUID := range order.PartUUIDs {
                parts = append(parts, partUUID.String())
        }

        repoOrder := &repoModel.Order{
                OrderUUID:       order.OrderUUID.String(),
                UserUUID:        order.UserUUID.String(),
                PartUUIDs:       parts,
                TotalPrice:      float32(order.TotalPrice),
                TransactionUUID: order.TransactionUUID.String(),
                PaymentMethod:   order.PaymentMethod,
                Status:          string(order.Status),
        }
        return repoOrder
}

func ToRepoOrderPostgres

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/converter/order.go:

func ToRepoOrderPostgres(order *model.Order) *repoModel.OrderPostgres {
        repoOrder := &repoModel.OrderPostgres{
                UserUUID:        order.UserUUID,
                PartUUIDs:       order.PartUUIDs,
                TotalPrice:      order.TotalPrice,
                TransactionUUID: order.TransactionUUID,
                PaymentMethod:   order.PaymentMethod,
                Status:          string(order.Status),
        }

        return repoOrder
}

func ToModelOrderFromPostgres

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/converter/order.go:

func ToModelOrderFromPostgres(repoOrder *repoModel.OrderPostgres) (*model.Order, error) {
        order := &model.Order{
                OrderUUID:       repoOrder.OrderUUID,
                UserUUID:        repoOrder.UserUUID,
                PartUUIDs:       repoOrder.PartUUIDs,
                TotalPrice:      repoOrder.TotalPrice,
                TransactionUUID: repoOrder.TransactionUUID,
                PaymentMethod:   repoOrder.PaymentMethod,
                Status:          model.OrderStatus(repoOrder.Status),
        }

        return order, nil
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/inmemory 0.0%

Please select a function to see what's left for testing.

`repository.GetOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/inmemory/get.go`	`0.0%`	`0/9`
`repository.CreateOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/inmemory/create.go`	`0.0%`	`0/6`
`repository.UpdateOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/inmemory/update.go`	`0.0%`	`0/5`
`NewRepository(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/inmemory/repository.go`	`0.0%`	`0/1`

func repository.GetOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/inmemory/get.go:

func (r *repository) GetOrder(ctx context.Context, id uuid.UUID) (*model.Order, error) {
        r.mu.RLock()
        repoOrder := r.data[id.String()]
        r.mu.RUnlock()

        if lo.ToPtr(repoOrder) == nil {
                return nil, model.ErrOrderNotFound
        }

        order, err := converter.ToModelOrder(lo.ToPtr(repoOrder))
        if err != nil {
                return nil, err
        }

        return order, nil
}

func repository.CreateOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/inmemory/create.go:

func (r *repository) CreateOrder(ctx context.Context, order *model.Order) (*model.Order, error) {
        repoOrder := converter.ToRepoOrder(order)

        order.OrderUUID = uuid.New()

        r.mu.Lock()
        r.data[order.OrderUUID.String()] = *repoOrder
        r.mu.Unlock()

        return order, nil
}

func repository.UpdateOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/inmemory/update.go:

func (r *repository) UpdateOrder(ctx context.Context, order *model.Order) (*model.Order, error) {
        repoOrder := converter.ToRepoOrder(order)

        r.mu.Lock()
        r.data[order.OrderUUID.String()] = *repoOrder
        r.mu.Unlock()

        return order, nil
}

func NewRepository

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/inmemory/repository.go:

func NewRepository() *repository {
        return &repository{
                data: make(map[string]repoModel.Order),
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres 0.0%

Please select a function to see what's left for testing.

`repository.GetOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres/get.go`	`0.0%`	`0/14`
`repository.CreateOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres/create.go`	`0.0%`	`0/10`
`repository.UpdateOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres/update.go`	`0.0%`	`0/9`
`repository.Migrate(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres/repository.go`	`0.0%`	`0/7`
`NewRepository(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/repository/postgres/repository.go`	`0.0%`	`0/5`

func repository.GetOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/postgres/get.go:

func (r *repository) GetOrder(ctx context.Context, id uuid.UUID) (*model.Order, error) {
        builderSelect := sq.Select(
                "order_uuid", "user_uuid", "part_uuid", "total_price",
                "transaction_uuid", "payment_method", "status", "created_at", "updated_at").
                From("orders").
                PlaceholderFormat(sq.Dollar).
                Where(sq.Eq{"order_uuid": id})

        query, args, err := builderSelect.ToSql()
        if err != nil {
                return nil, model.ErrFailedToBuildQuery
        }

        var repoOrder repoModel.OrderPostgres
        err = r.db.QueryRow(ctx, query, args...).Scan(
                &repoOrder.OrderUUID,
                &repoOrder.UserUUID,
                &repoOrder.PartUUIDs,
                &repoOrder.TotalPrice,
                &repoOrder.TransactionUUID,
                &repoOrder.PaymentMethod,
                &repoOrder.Status,
                &repoOrder.CreatedAt,
                &repoOrder.UpdatedAt,
        )
        if err != nil {
                if errors.Is(err, sql.ErrNoRows) {
                        return nil, model.ErrOrderNotFound
                }
                return nil, model.ErrFailedToGetOrder
        }

        order, err := converter.ToModelOrderFromPostgres(&repoOrder)
        if err != nil {
                return nil, err
        }

        return order, nil
}

func repository.CreateOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/postgres/create.go:

func (r *repository) CreateOrder(ctx context.Context, order *model.Order) (*model.Order, error) {
        repoOrder := converter.ToRepoOrderPostgres(order)

        builderInsert := sq.Insert("orders").
                PlaceholderFormat(sq.Dollar).
                Columns("user_uuid", "part_uuid", "total_price", "transaction_uuid", "payment_method", "status").
                Values(repoOrder.UserUUID, repoOrder.PartUUIDs, repoOrder.TotalPrice, repoOrder.TransactionUUID, repoOrder.PaymentMethod, repoOrder.Status).
                Suffix("RETURNING order_uuid")

        query, args, err := builderInsert.ToSql()
        if err != nil {
                return nil, model.ErrFailedToBuildQuery
        }

        err = r.db.QueryRow(ctx, query, args...).Scan(&repoOrder.OrderUUID)
        if err != nil {
                return nil, model.ErrFailedToInsertOrder
        }

        order.OrderUUID = repoOrder.OrderUUID

        return order, nil
}

func repository.UpdateOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/postgres/update.go:

func (r *repository) UpdateOrder(ctx context.Context, order *model.Order) (*model.Order, error) {
        repoOrder := converter.ToRepoOrderPostgres(order)

        builderUpdate := sq.Update("orders").
                PlaceholderFormat(sq.Dollar).
                Set("transaction_uuid", repoOrder.TransactionUUID).
                Set("payment_method", repoOrder.PaymentMethod).
                Set("status", repoOrder.Status).
                Set("updated_at", "NOW()").
                Where(sq.Eq{"order_uuid": order.OrderUUID})

        query, args, err := builderUpdate.ToSql()
        if err != nil {
                return nil, model.ErrFailedToBuildQuery
        }

        _, err = r.db.Exec(ctx, query, args...)
        if err != nil {
                return nil, model.ErrFailedToUpdateOrder
        }

        return order, nil
}

func repository.Migrate

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/postgres/repository.go:

func (r *repository) Migrate(migrationsDir string) error {
        sqlDB := stdlib.OpenDBFromPool(r.db)

        if err := goose.SetDialect("postgres"); err != nil {
                return err
        }
        if err := goose.Up(sqlDB, migrationsDir); err != nil {
                return err
        }

        log.Println("✅ Миграции успешно применены.")
        return nil
}

func NewRepository

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/repository/postgres/repository.go:

func NewRepository(pool *pgxpool.Pool, migrationsDir string) *repository {
        repo := repository{
                db: pool,
        }
        err := repo.Migrate(migrationsDir)
        if err != nil {
                log.Fatalf("Failed to migrate: %v", err)
        }

        return &repo
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order 100.0%

Please select a function to see what's left for testing.

`service.CreateOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order/create.go`	`100.0%`	`17/17`
`service.CancelOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order/cancel.go`	`100.0%`	`12/12`
`service.PayOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order/pay.go`	`100.0%`	`10/10`
`service.GetOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order/get.go`	`100.0%`	`4/4`
`NewService(...)`	`github.com/kont1n/MSA_Rocket_Factory/order/internal/service/order/service.go`	`100.0%`	`1/1`

func service.CreateOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/service/order/create.go:

func (s service) CreateOrder(ctx context.Context, order *model.Order) (*model.Order, error) {
        // Проверяем что детали указаны и заполняем фильтр
        if len(order.PartUUIDs) == 0 {
                return nil, model.ErrPartsSpecified
        }
        uuidFilter := model.Filter{
                PartUUIDs: order.PartUUIDs,
        }

        // Выполняем запрос к API инвентаря для получения деталей заказа
        parts, err := s.inventoryClient.ListParts(ctx, &uuidFilter)
        if err != nil {
                return nil, fmt.Errorf("service: failed to get list parts from inventory client: %w", err)
        }
        if len(*parts) != len(order.PartUUIDs) {
                return nil, model.ErrPartsListNotFound
        }

        // Считаем общую стоимость заказа
        totalPrice := 0.0
        for _, part := range *parts {
                totalPrice += part.Price
        }
        order.TotalPrice = float32(totalPrice)

        order.Status = model.StatusPendingPayment

        // Сохраняем заказ в хранилище
        order, err = s.orderRepository.CreateOrder(ctx, order)
        if err != nil {
                return nil, fmt.Errorf("service: failed to create order in repository: %w", err)
        }
        return order, nil
}

func service.CancelOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/service/order/cancel.go:

func (s service) CancelOrder(ctx context.Context, order *model.Order) (*model.Order, error) {
        // Получаем заказ по UUID
        order, err := s.orderRepository.GetOrder(ctx, order.OrderUUID)
        if err != nil {
                return nil, fmt.Errorf("service: failed to get order from repository: %w", err)
        }

        // Проверяем статус заказа
        if order.Status == model.StatusPaid {
                return nil, model.ErrPaid
        }
        if order.Status == model.StatusCancelled {
                return nil, model.ErrCancelled
        }

        order.Status = model.StatusCancelled
        // Сохраняем отмену заказа в хранилище
        order, err = s.orderRepository.UpdateOrder(ctx, order)
        if err != nil {
                return nil, fmt.Errorf("service: failed to update order in repository: %w", err)
        }

        return order, nil
}

func service.PayOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/service/order/pay.go:

func (s service) PayOrder(ctx context.Context, order *model.Order) (*model.Order, error) {
        // Получаем заказ по UUID
        order, err := s.orderRepository.GetOrder(ctx, order.OrderUUID)
        if err != nil {
                return nil, fmt.Errorf("service: failed to get order from repository: %w", err)
        }

        // Выполняем запрос к API для оплаты заказа
        order, err = s.paymentClient.CreatePayment(ctx, order)
        if err != nil {
                return nil, fmt.Errorf("service: failed to create payment in payment client: %w", err)
        }

        // Обновляем заказ в хранилище
        order, err = s.orderRepository.UpdateOrder(ctx, order)
        if err != nil {
                return nil, fmt.Errorf("service: failed to update order in repository: %w", err)
        }

        return order, nil
}

func service.GetOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/service/order/get.go:

func (s service) GetOrder(ctx context.Context, id uuid.UUID) (*model.Order, error) {
        // Получаем заказ по UUID
        order, err := s.orderRepository.GetOrder(ctx, id)
        if err != nil {
                return nil, fmt.Errorf("service: failed to get order from repository: %w", err)
        }

        return order, nil
}

func NewService

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/order/internal/service/order/service.go:

func NewService(
        orderRepository repository.OrderRepository,
        inventoryClient grpc.InventoryClient,
        paymentClient grpc.PaymentClient,
) *service {
        return &service{
                orderRepository: orderRepository,
                inventoryClient: inventoryClient,
                paymentClient:   paymentClient,
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/converter 100.0%

Please select a function to see what's left for testing.

ToModelOrder(...) github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/converter/order.go 100.0% 7/7

func ToModelOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/api/converter/order.go:

func ToModelOrder(req *paymentV1.PayOrderRequest) (model.Order, error) {
        orderUuid, err := uuid.Parse(req.GetOrderUuid())
        if err != nil {
                return model.Order{}, err
        }

        userUuid, err := uuid.Parse(req.GetUserUuid())
        if err != nil {
                return model.Order{}, err
        }

        return model.Order{
                OrderUuid:     orderUuid,
                UserUuid:      userUuid,
                PaymentMethod: "CARD", // Используем строковое значение по умолчанию
        }, nil
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/middleware 0.0%

Please select a function to see what's left for testing.

`@11:26(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/middleware/request_logger.go`	`0.0%`	`0/5`
`responseWriter.WriteHeader(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/middleware/request_logger.go`	`0.0%`	`0/2`
`RequestLogger(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/middleware/request_logger.go`	`0.0%`	`0/1`

func @11:26

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/api/middleware/request_logger.go:

func(w http.ResponseWriter, r *http.Request) {
                start := time.Now()

                // Создаем response writer для перехвата статуса
                ww := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}

                // Выполняем следующий обработчик
                next.ServeHTTP(ww, r)

                // Логируем информацию о запросе
                duration := time.Since(start)
                log.Printf("📝 %s %s %d %v", r.Method, r.URL.Path, ww.statusCode, duration)
        }

func responseWriter.WriteHeader

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/api/middleware/request_logger.go:

32	`func (rw *responseWriter) WriteHeader(code int) {`
33	`rw.statusCode = code`
34	`rw.ResponseWriter.WriteHeader(code)`
35	`}`

func RequestLogger

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/api/middleware/request_logger.go:

func RequestLogger(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                start := time.Now()

                // Создаем response writer для перехвата статуса
                ww := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}

                // Выполняем следующий обработчик
                next.ServeHTTP(ww, r)

                // Логируем информацию о запросе
                duration := time.Since(start)
                log.Printf("📝 %s %s %d %v", r.Method, r.URL.Path, ww.statusCode, duration)
        })
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/payment/v1 0.0%

Please select a function to see what's left for testing.

`api.PayOrder(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/payment/v1/pay.go`	`0.0%`	`0/8`
`NewAPI(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/api/payment/v1/api.go`	`0.0%`	`0/1`

func api.PayOrder

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/api/payment/v1/pay.go:

func (a *api) PayOrder(ctx context.Context, req *paymentV1.PayOrderRequest) (*paymentV1.PayOrderResponse, error) {
        order, err := converter.ToModelOrder(req)
        if err != nil {
                return nil, status.Error(codes.InvalidArgument, err.Error())
        }

        transaction, err := a.paymentService.Pay(ctx, order)
        if err != nil {
                slog.Info("Payment fail", "transaction:", transaction, "err:", err)
                return nil, status.Error(codes.Internal, err.Error())
        }

        return &paymentV1.PayOrderResponse{
                TransactionUuid: transaction.String(),
        }, nil
}

func NewAPI

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/api/payment/v1/api.go:

func NewAPI(paymentService service.PaymentService) *api {
        return &api{
                paymentService: paymentService,
        }
}

Package Overview: github.com/kont1n/MSA_Rocket_Factory/payment/internal/model 0.0%

Please select a function to see what's left for testing.

`PaymentMethodFromString(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/model/order.go`	`0.0%`	`0/6`
`PaymentMethod.String(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/model/order.go`	`0.0%`	`0/1`

func PaymentMethodFromString

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/model/order.go:

func PaymentMethodFromString(value string) PaymentMethod {
        switch value {
        case "CARD":
                return CARD
        case "SBP":
                return SBP
        case "CREDIT_CARD":
                return CREDIT_CARD
        case "INVESTOR_MONEY":
                return INVESTOR_MONEY
        default:
                return UNKNOWN
        }
}

func PaymentMethod.String

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/model/order.go:

25	`func (pm PaymentMethod) String() string {`
26	`return string(pm)`
27	`}`

Package Overview: github.com/kont1n/MSA_Rocket_Factory/payment/internal/service/payment 100.0%

Please select a function to see what's left for testing.

`service.Pay(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/service/payment/pay.go`	`100.0%`	`3/3`
`NewService(...)`	`github.com/kont1n/MSA_Rocket_Factory/payment/internal/service/payment/service.go`	`100.0%`	`1/1`

func service.Pay

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/service/payment/pay.go:

func (s *service) Pay(ctx context.Context, order model.Order) (uuid.UUID, error) {
        transactionUuid := uuid.New()
        slog.Info("Payment success", "transaction_uuid:", transactionUuid)

        return transactionUuid, nil
}

func NewService

Back

In /home/runner/work/MSA_Rocket_Factory/MSA_Rocket_Factory/payment/internal/service/payment/service.go:

11	`func NewService() *service {`
12	`return &service{}`
13	`}`

Report Total

31.2%

Took 67.261474ms

10	`func ToProtoPart(part model.Part) inventoryV1.Part {`
11	`// Конвертируем Category из model.Category в inventoryV1.Category`
12	`var protoCategory inventoryV1.Category`
13	`switch part.Category {`
14	`case model.ENGINE:`
15	`protoCategory = inventoryV1.Category_CATEGORY_ENGINE`
16	`case model.FUEL:`
17	`protoCategory = inventoryV1.Category_CATEGORY_FUEL`
18	`case model.PORTHOLE:`
19	`protoCategory = inventoryV1.Category_CATEGORY_PORTHOLE`
20	`case model.WING:`
21	`protoCategory = inventoryV1.Category_CATEGORY_WING`
22	`default:`
23	`protoCategory = inventoryV1.Category_CATEGORY_UNSPECIFIED`
24	`}`
25
26	`// Конвертируем Dimensions`
27	`dimensions := &inventoryV1.Dimensions{`
28	`Length: part.Dimensions.Length,`
29	`Width: part.Dimensions.Width,`
30	`Height: part.Dimensions.Height,`
31	`Weight: part.Dimensions.Weight,`
32	`}`
33
34	`// Конвертируем Manufacturer`
35	`manufacturer := &inventoryV1.Manufacturer{`
36	`Name: part.Manufacturer.Name,`
37	`Country: part.Manufacturer.Country,`
38	`Url: part.Manufacturer.Website,`
39	`}`
40
41	`// Конвертируем Metadata`
42	`metadata := make(map[string]*inventoryV1.Value)`
43	`for key, value := range part.Metadata {`
44	`protoValue := &inventoryV1.Value{}`
45	`switch {`
46	`case value.StringValue != "":`
47	`protoValue.Kind = &inventoryV1.Value_StringValue{StringValue: value.StringValue}`
48	`case value.Int64Value != 0:`
49	`protoValue.Kind = &inventoryV1.Value_Int64Value{Int64Value: value.Int64Value}`
50	`case value.Float64Value != 0:`
51	`protoValue.Kind = &inventoryV1.Value_DoubleValue{DoubleValue: value.Float64Value}`
52	`case value.BoolValue:`
53	`protoValue.Kind = &inventoryV1.Value_BoolValue{BoolValue: value.BoolValue}`
54	`}`
55	`metadata[key] = protoValue`
56	`}`
57
58	`return &inventoryV1.Part{`
59	`PartUuid: part.OrderUuid.String(),`
60	`Name: part.Name,`
61	`Description: part.Description,`
62	`Price: part.Price,`
63	`StockQuantity: part.StockQuantity,`
64	`Category: protoCategory,`
65	`Dimensions: dimensions,`
66	`Manufacturer: manufacturer,`
67	`Tags: part.Tags,`
68	`Metadata: metadata,`
69	`CreatedAt: timestamppb.New(part.CreatedAt),`
70	`UpdatedAt: timestamppb.New(part.UpdatedAt),`
71	`}`
72	`}`

55	`func ToRepositoryPart(part model.Part) repoModel.RepositoryPart {`
56	`manufacturer := repoModel.Manufacturer{`
57	`Name: part.Manufacturer.Name,`
58	`Country: part.Manufacturer.Country,`
59	`Website: part.Manufacturer.Website,`
60	`}`
61
62	`dimension := repoModel.Dimensions{`
63	`Length: part.Dimensions.Length,`
64	`Width: part.Dimensions.Width,`
65	`Height: part.Dimensions.Height,`
66	`Weight: part.Dimensions.Weight,`
67	`}`
68
69	`metadata := make(map[string]repoModel.Value)`
70	`for key, value := range part.Metadata {`
71	`metadata[key] = repoModel.Value{`
72	`StringValue: value.StringValue,`
73	`Int64Value: value.Int64Value,`
74	`Float64Value: value.Float64Value,`
75	`BoolValue: value.BoolValue,`
76	`}`
77	`}`
78
79	`return &repoModel.RepositoryPart{`
80	`OrderUuid: part.OrderUuid.String(),`
81	`Name: part.Name,`
82	`Description: part.Description,`
83	`Price: part.Price,`
84	`StockQuantity: part.StockQuantity,`
85	`Category: int(part.Category),`
86	`Dimensions: dimension,`
87	`Manufacturer: manufacturer,`
88	`Tags: part.Tags,`
89	`Metadata: metadata,`
90	`CreatedAt: part.CreatedAt,`
91	`UpdatedAt: part.UpdatedAt,`
92	`}`
93	`}`

37	`func filtration(filter model.Filter, parts []repoModel.RepositoryPart) (result []*repoModel.RepositoryPart) {`
38	`// Создаем мап для фильтрации`
39	`uuidSet := make(map[string]bool)`
40	`for _, uuid := range filter.Uuids {`
41	`uuidSet[uuid.String()] = true`
42	`}`
43
44	`nameSet := make(map[string]bool)`
45	`for _, name := range filter.Names {`
46	`nameSet[name] = true`
47	`}`
48
49	`categorySet := make(map[int]bool)`
50	`for _, category := range filter.Categories {`
51	`categorySet[int(category)] = true`
52	`}`
53
54	`manufacturerCountrySet := make(map[string]bool)`
55	`for _, manufacturerCountry := range filter.ManufacturerCountries {`
56	`manufacturerCountrySet[manufacturerCountry] = true`
57	`}`
58
59	`tagSet := make(map[string]bool)`
60	`for _, tag := range filter.Tags {`
61	`tagSet[tag] = true`
62	`}`
63
64	`// Фильтруем детали`
65	`for _, part := range parts {`
66	`if len(uuidSet) > 0 {`
67	`if _, ok := uuidSet[part.OrderUuid]; !ok {`
68	`continue`
69	`}`
70	`}`
71
72	`if len(nameSet) > 0 {`
73	`if _, ok := nameSet[part.Name]; !ok {`
74	`continue`
75	`}`
76	`}`
77
78	`if len(categorySet) > 0 {`
79	`if _, ok := categorySet[part.Category]; !ok {`
80	`continue`
81	`}`
82	`}`
83
84	`if len(manufacturerCountrySet) > 0 {`
85	`if _, ok := manufacturerCountrySet[part.Manufacturer.Country]; !ok {`
86	`continue`
87	`}`
88	`}`
89
90	`if len(tagSet) > 0 {`
91	`// Проверяем, есть ли хотя бы один тег из фильтра в тегах детали`
92	`tagFound := false`
93	`for _, partTag := range part.Tags {`
94	`if _, ok := tagSet[partTag]; ok {`
95	`tagFound = true`
96	`break`
97	`}`
98	`}`
99	`if !tagFound {`
100	`continue`
101	`}`
102	`}`
103
104	`result = append(result, part)`
105	`}`
106
107	`return result`
108	`}`

11	`func (r *repository) addTestData() {`
12	`log.Printf("Add Test Data for inventory service")`
13
14	`r.mu.Lock()`
15	`defer r.mu.Unlock()`
16
17	`r.data = map[string]*repoModel.RepositoryPart{`
18	`"d973e963-b7e6-4323-8f4e-4bfd5ab8e834": {`
19	`OrderUuid: "d973e963-b7e6-4323-8f4e-4bfd5ab8e834",`
20	`Name: "Detail 1",`
21	`Description: "Detail 1 description",`
22	`Price: 100,`
23	`StockQuantity: 10,`
24	`Category: 1, // ENGINE`
25	`Dimensions: repoModel.Dimensions{`
26	`Length: 100,`
27	`Width: 100,`
28	`Height: 100,`
29	`Weight: 100,`
30	`},`
31	`Manufacturer: repoModel.Manufacturer{`
32	`Country: "China",`
33	`Name: "Details Fabric",`
34	`},`
35	`Tags: []string{"tag1", "tag2"},`
36	`CreatedAt: time.Now(),`
37	`UpdatedAt: time.Now(),`
38	`},`
39	`"d973e963-b7e6-4323-8f4e-4bfd5ab8e835": {`
40	`OrderUuid: "d973e963-b7e6-4323-8f4e-4bfd5ab8e835",`
41	`Name: "Detail 2",`
42	`Description: "Detail 2 description",`
43	`Price: 200,`
44	`StockQuantity: 20,`
45	`Category: 1, // ENGINE`
46	`Dimensions: repoModel.Dimensions{`
47	`Length: 100,`
48	`Width: 100,`
49	`Height: 100,`
50	`Weight: 100,`
51	`},`
52	`Manufacturer: repoModel.Manufacturer{`
53	`Country: "USA",`
54	`Name: "Details Fabric",`
55	`},`
56	`Tags: []string{"tag1", "tag2"},`
57	`CreatedAt: time.Now(),`
58	`UpdatedAt: time.Now(),`
59	`},`
60	`}`
61	`}`

53	`func buildMongoFilter(filter *model.Filter) bson.M {`
54	`if filter == nil {`
55	`return bson.M{}`
56	`}`
57
58	`mongoFilter := bson.M{}`
59
60	`// Фильтр по UUID`
61	`if len(filter.Uuids) > 0 {`
62	`uuidStrings := make([]string, len(filter.Uuids))`
63	`for i, uuid := range filter.Uuids {`
64	`uuidStrings[i] = uuid.String()`
65	`}`
66	`mongoFilter["order_uuid"] = bson.M{"$in": uuidStrings}`
67	`}`
68
69	`// Фильтр по именам`
70	`if len(filter.Names) > 0 {`
71	`mongoFilter["name"] = bson.M{"$in": filter.Names}`
72	`}`
73
74	`// Фильтр по категориям`
75	`if len(filter.Categories) > 0 {`
76	`categoryInts := make([]int, len(filter.Categories))`
77	`for i, category := range filter.Categories {`
78	`categoryInts[i] = int(category)`
79	`}`
80	`mongoFilter["category"] = bson.M{"$in": categoryInts}`
81	`}`
82
83	`// Фильтр по странам производителей`
84	`if len(filter.ManufacturerCountries) > 0 {`
85	`mongoFilter["manufacturer.country"] = bson.M{"$in": filter.ManufacturerCountries}`
86	`}`
87
88	`// Фильтр по тегам (должен содержать хотя бы один из указанных тегов)`
89	`if len(filter.Tags) > 0 {`
90	`mongoFilter["tags"] = bson.M{"$in": filter.Tags}`
91	`}`
92
93	`return mongoFilter`
94	`}`

10	`func ToModelPart(req inventoryV1.ListPartsRequest) model.Filter {`
11	`if req.Filter != nil {`
12	`uuids := make([]uuid.UUID, 0, len(req.Filter.PartUuid))`
13	`for _, uuidStr := range req.Filter.PartUuid {`
14	`if uuid, err := uuid.Parse(uuidStr); err == nil {`
15	`uuids = append(uuids, uuid)`
16	`}`
17	`}`
18
19	`categories := make([]model.Category, 0, len(req.Filter.Category))`
20	`for _, protoCategory := range req.Filter.Category {`
21	`switch protoCategory {`
22	`case inventoryV1.Category_CATEGORY_ENGINE:`
23	`categories = append(categories, model.ENGINE)`
24	`case inventoryV1.Category_CATEGORY_FUEL:`
25	`categories = append(categories, model.FUEL)`
26	`case inventoryV1.Category_CATEGORY_PORTHOLE:`
27	`categories = append(categories, model.PORTHOLE)`
28	`case inventoryV1.Category_CATEGORY_WING:`
29	`categories = append(categories, model.WING)`
30	`}`
31	`}`
32
33	`filter := &model.Filter{`
34	`Uuids: uuids,`
35	`Names: req.Filter.PartName,`
36	`Categories: categories,`
37	`ManufacturerCountries: req.Filter.ManufacturerCountry,`
38	`Tags: req.Filter.Tags,`
39	`}`
40	`return filter`
41	`}`
42
43	`return nil`
44	`}`

17	`func (a api) GetPart(ctx context.Context, req inventoryV1.GetPartRequest) (*inventoryV1.GetPartResponse, error) {`
18	`id, err := uuid.Parse(req.PartUuid)`
19	`if err != nil {`
20	`return nil, status.Errorf(codes.InvalidArgument, "invalid part uuid")`
21	`}`
22
23	`part, err := a.inventoryService.GetPart(ctx, id)`
24	`if err != nil {`
25	`slog.Error("Failed to get part", "id:", id, "error:", err)`
26
27	`if errors.Is(err, model.ErrPartNotFound) {`
28	`return nil, status.Errorf(codes.NotFound, "part not found")`
29	`}`
30
31	`if errors.Is(err, model.ErrConvertFromRepo) {`
32	`return nil, status.Errorf(codes.Internal, "failed to get part")`
33	`}`
34
35	`return nil, status.Error(codes.Internal, err.Error())`
36	`}`
37
38	`protoPart := converter.ToProtoPart(part)`
39	`return &inventoryV1.GetPartResponse{Part: protoPart}, nil`
40	`}`

16	`func (a api) ListParts(ctx context.Context, req inventoryV1.ListPartsRequest) (*inventoryV1.ListPartsResponse, error) {`
17	`filter := converter.ToModelPart(req)`
18
19	`parts, err := a.inventoryService.ListParts(ctx, filter)`
20	`if err != nil {`
21	`slog.Error("Failed to get list part", "filter:", filter, "error:", err)`
22
23	`if errors.Is(err, model.ErrConvertFromRepo) {`
24	`return nil, status.Errorf(codes.Internal, "failed to get list parts")`
25	`}`
26
27	`return nil, status.Error(codes.Internal, err.Error())`
28	`}`
29
30	`protoParts := make([]inventoryV1.Part, 0, len(parts))`
31	`for _, part := range *parts {`
32	`protoPart := converter.ToProtoPart(&part)`
33	`protoParts = append(protoParts, protoPart)`
34	`}`
35
36	`return &inventoryV1.ListPartsResponse{Parts: protoParts}, nil`
37	`}`

13	`func (c Category) String() string {`
14	`switch c {`
15	`case ENGINE:`
16	`return "ENGINE"`
17	`case FUEL:`
18	`return "FUEL"`
19	`case PORTHOLE:`
20	`return "PORTHOLE"`
21	`case WING:`
22	`return "WING"`
23	`default:`
24	`return "UNKNOWN"`
25	`}`
26	`}`

32	`func ToCategory(value int) Category {`
33	`switch value {`
34	`case int(ENGINE), int(FUEL), int(PORTHOLE), int(WING):`
35	`return Category(value)`
36	`default:`
37	`return UNKNOWN`
38	`}`
39	`}`

10	`func ToModelPart(repoPart repoModel.RepositoryPart) (part model.Part, err error) {`
11	`id, err := uuid.Parse(repoPart.OrderUuid)`
12	`if err != nil {`
13	`return nil, model.ErrConvertFromRepo`
14	`}`
15
16	`manufacturer := model.Manufacturer{`
17	`Name: repoPart.Manufacturer.Name,`
18	`Country: repoPart.Manufacturer.Country,`
19	`Website: repoPart.Manufacturer.Website,`
20	`}`
21
22	`dimension := model.Dimensions{`
23	`Length: repoPart.Dimensions.Length,`
24	`Width: repoPart.Dimensions.Width,`
25	`Height: repoPart.Dimensions.Height,`
26	`Weight: repoPart.Dimensions.Weight,`
27	`}`
28
29	`metadata := make(map[string]model.Value)`
30	`for key, value := range repoPart.Metadata {`
31	`metadata[key] = model.Value{`
32	`StringValue: value.StringValue,`
33	`Int64Value: value.Int64Value,`
34	`Float64Value: value.Float64Value,`
35	`BoolValue: value.BoolValue,`
36	`}`
37	`}`
38
39	`return &model.Part{`
40	`OrderUuid: id,`
41	`Name: repoPart.Name,`
42	`Description: repoPart.Description,`
43	`Price: repoPart.Price,`
44	`StockQuantity: repoPart.StockQuantity,`
45	`Category: model.ToCategory(repoPart.Category),`
46	`Dimensions: dimension,`
47	`Manufacturer: manufacturer,`
48	`Tags: repoPart.Tags,`
49	`Metadata: metadata,`
50	`CreatedAt: repoPart.CreatedAt,`
51	`UpdatedAt: repoPart.UpdatedAt,`
52	`}, nil`
53	`}`

13	`func (r repository) ListParts(ctx context.Context, filter model.Filter) (*[]model.Part, error) {`
14	`partsFiltered := make([]*repoModel.RepositoryPart, 0)`
15	`r.mu.RLock()`
16	`for _, part := range r.data {`
17	`partsFiltered = append(partsFiltered, part)`
18	`}`
19	`r.mu.RUnlock()`
20
21	`if filter != nil {`
22	`partsFiltered = filtration(filter, partsFiltered)`
23	`}`
24
25	`parts := make([]model.Part, 0, len(partsFiltered))`
26	`for _, repoPart := range partsFiltered {`
27	`part, err := repoConverter.ToModelPart(repoPart)`
28	`if err != nil {`
29	`return nil, err`
30	`}`
31	`parts = append(parts, lo.FromPtr(part))`
32	`}`
33
34	`return &parts, nil`
35	`}`

12	`func (r repository) GetPart(ctx context.Context, uuid uuid.UUID) (model.Part, error) {`
13	`partUuid := uuid.String()`
14
15	`r.mu.RLock()`
16	`repoPart, ok := r.data[partUuid]`
17	`r.mu.RUnlock()`
18
19	`if !ok {`
20	`return nil, model.ErrPartNotFound`
21	`}`
22
23	`part, err := repoConverter.ToModelPart(repoPart)`
24	`if err != nil {`
25	`return nil, err`
26	`}`
27
28	`return part, nil`
29	`}`

17	`func NewRepository() *repository {`
18	`repo := &repository{`
19	`data: make(map[string]*repoModel.RepositoryPart),`
20	`}`
21
22	`repo.addTestData()`
23
24	`return repo`
25	`}`

12	`func (r *repository) AddTestData(ctx context.Context) error {`
13	`log.Printf("Добавление тестовых данных для инвентаря в MongoDB")`
14
15	`collection := r.db.Collection(partsCollection)`
16
17	`// Проверяем, есть ли уже данные в коллекции`
18	`count, err := collection.CountDocuments(ctx, map[string]interface{}{})`
19	`if err != nil {`
20	`return err`
21	`}`
22
23	`if count > 0 {`
24	`log.Printf("Тестовые данные уже существуют в коллекции, пропускаем добавление")`
25	`return nil`
26	`}`
27
28	`// Создаем тестовые данные`
29	`testParts := []repoModel.RepositoryPart{`
30	`{`
31	`OrderUuid: "d973e963-b7e6-4323-8f4e-4bfd5ab8e834",`
32	`Name: "Ракетный двигатель RD-180",`
33	`Description: "Мощный ракетный двигатель для тяжелых носителей",`
34	`Price: 15000000.50,`
35	`StockQuantity: 5,`
36	`Category: 1, // ENGINE`
37	`Dimensions: repoModel.Dimensions{`
38	`Length: 355.6,`
39	`Width: 297.2,`
40	`Height: 297.2,`
41	`Weight: 5480.0,`
42	`},`
43	`Manufacturer: repoModel.Manufacturer{`
44	`Name: "Energomash",`
45	`Country: "Russia",`
46	`Website: "https://www.energomash.ru",`
47	`},`
48	`Tags: []string{"rocket", "engine", "rd-180", "heavy-lift"},`
49	`Metadata: map[string]repoModel.Value{`
50	`"thrust": {`
51	`Float64Value: 3830000.0,`
52	`},`
53	`"fuel_type": {`
54	`StringValue: "RP-1/LOX",`
55	`},`
56	`"reusable": {`
57	`BoolValue: false,`
58	`},`
59	`"test_fires": {`
60	`Int64Value: 150,`
61	`},`
62	`},`
63	`CreatedAt: time.Now(),`
64	`UpdatedAt: time.Now(),`
65	`},`
66	`{`
67	`OrderUuid: "d973e963-b7e6-4323-8f4e-4bfd5ab8e835",`
68	`Name: "Система управления Navigation-1",`
69	`Description: "Навигационная система для космических аппаратов",`
70	`Price: 750000.00,`
71	`StockQuantity: 12,`
72	`Category: 2, // ELECTRONICS`
73	`Dimensions: repoModel.Dimensions{`
74	`Length: 50.0,`
75	`Width: 40.0,`
76	`Height: 15.0,`
77	`Weight: 8.5,`
78	`},`
79	`Manufacturer: repoModel.Manufacturer{`
80	`Name: "SpaceX",`
81	`Country: "USA",`
82	`Website: "https://www.spacex.com",`
83	`},`
84	`Tags: []string{"navigation", "electronics", "gps", "space"},`
85	`Metadata: map[string]repoModel.Value{`
86	`"accuracy": {`
87	`StringValue: "sub-meter",`
88	`},`
89	`"frequency": {`
90	`Float64Value: 1575.42,`
91	`},`
92	`"channels": {`
93	`Int64Value: 32,`
94	`},`
95	`"space_qualified": {`
96	`BoolValue: true,`
97	`},`
98	`},`
99	`CreatedAt: time.Now(),`
100	`UpdatedAt: time.Now(),`
101	`},`
102	`{`
103	`OrderUuid: "d973e963-b7e6-4323-8f4e-4bfd5ab8e836",`
104	`Name: "Топливный бак Falcon-Tank-9",`
105	`Description: "Алюминиевый топливный бак для среднего класса ракет",`
106	`Price: 2500000.75,`
107	`StockQuantity: 8,`
108	`Category: 3, // STRUCTURE`
109	`Dimensions: repoModel.Dimensions{`
110	`Length: 1200.0,`
111	`Width: 366.0,`
112	`Height: 366.0,`
113	`Weight: 25000.0,`
114	`},`
115	`Manufacturer: repoModel.Manufacturer{`
116	`Name: "Boeing",`
117	`Country: "USA",`
118	`Website: "https://www.boeing.com/space",`
119	`},`
120	`Tags: []string{"fuel", "tank", "structure", "aluminum"},`
121	`Metadata: map[string]repoModel.Value{`
122	`"capacity": {`
123	`Float64Value: 400000.0,`
124	`},`
125	`"material": {`
126	`StringValue: "Al-Li 2195",`
127	`},`
128	`"pressure_rating": {`
129	`Float64Value: 3.5,`
130	`},`
131	`"insulated": {`
132	`BoolValue: true,`
133	`},`
134	`},`
135	`CreatedAt: time.Now(),`
136	`UpdatedAt: time.Now(),`
137	`},`
138	`}`
139
140	`// Конвертируем в interface{} для вставки`
141	`docs := make([]interface{}, len(testParts))`
142	`for i, part := range testParts {`
143	`docs[i] = part`
144	`}`
145
146	`// Вставляем тестовые данные`
147	`result, err := collection.InsertMany(ctx, docs)`
148	`if err != nil {`
149	`log.Printf("Ошибка при добавлении тестовых данных: %v", err)`
150	`return err`
151	`}`
152
153	`log.Printf("Успешно добавлено %d тестовых записей в коллекцию %s", len(result.InsertedIDs), partsCollection)`
154	`return nil`
155	`}`

15	`func (r repository) ListParts(ctx context.Context, filter model.Filter) (*[]model.Part, error) {`
16	`collection := r.db.Collection(partsCollection)`
17
18	`// Создаем фильтр для MongoDB`
19	`mongoFilter := buildMongoFilter(filter)`
20
21	`// Выполняем запрос`
22	`cursor, err := collection.Find(ctx, mongoFilter)`
23	`if err != nil {`
24	`return nil, err`
25	`}`
26	`defer func(cursor *mongo.Cursor, ctx context.Context) {`
27	`err := cursor.Close(ctx)`
28	`if err != nil {`
29	`log.Printf("failed to close cursor: %v", err)`
30	`}`
31	`}(cursor, ctx)`
32
33	`// Читаем результаты`
34	`var repoParts []repoModel.RepositoryPart`
35	`if err = cursor.All(ctx, &repoParts); err != nil {`
36	`return nil, err`
37	`}`
38
39	`// Преобразуем в основные модели`
40	`parts := make([]model.Part, 0, len(repoParts))`
41	`for _, repoPart := range repoParts {`
42	`part, err := repoConverter.ToModelPart(&repoPart)`
43	`if err != nil {`
44	`return nil, err`
45	`}`
46	`parts = append(parts, *part)`
47	`}`
48
49	`return &parts, nil`
50	`}`

16	`func (r repository) GetPart(ctx context.Context, uuid uuid.UUID) (model.Part, error) {`
17	`collection := r.db.Collection(partsCollection)`
18
19	`filter := bson.M{"order_uuid": uuid.String()}`
20
21	`var repoPart repoModel.RepositoryPart`
22	`err := collection.FindOne(ctx, filter).Decode(&repoPart)`
23	`if err != nil {`
24	`if errors.Is(err, mongo.ErrNoDocuments) {`
25	`return nil, model.ErrPartNotFound`
26	`}`
27	`return nil, err`
28	`}`
29
30	`// Преобразуем модель репозитория в основную модель`
31	`part, err := repoConverter.ToModelPart(&repoPart)`
32	`if err != nil {`
33	`return nil, err`
34	`}`
35
36	`return part, nil`
37	`}`

20	`func NewRepository(database mongo.Database) repository {`
21	`repo := &repository{`
22	`db: database,`
23	`}`
24
25	`// Добавляем тестовые данные при инициализации`
26	`if err := repo.AddTestData(context.Background()); err != nil {`
27	`log.Printf("Предупреждение: не удалось добавить тестовые данные в MongoDB: %v", err)`
28	`}`
29
30	`return repo`
31	`}`

26	`func(cursor *mongo.Cursor, ctx context.Context) {`
27	`err := cursor.Close(ctx)`
28	`if err != nil {`
29	`log.Printf("failed to close cursor: %v", err)`
30	`}`
31	`}`

12	`func (s service) GetPart(ctx context.Context, uuid uuid.UUID) (model.Part, error) {`
13	`part, err := s.repo.GetPart(ctx, uuid)`
14	`if err != nil {`
15	`return nil, fmt.Errorf("service: failed to get part from repository: %w", err)`
16	`}`
17
18	`return part, nil`
19	`}`

10	`func (s service) ListParts(ctx context.Context, filter model.Filter) (*[]model.Part, error) {`
11	`parts, err := s.repo.ListParts(ctx, filter)`
12	`if err != nil {`
13	`return nil, fmt.Errorf("service: failed to get list of parts from repository: %w", err)`
14	`}`
15
16	`return parts, nil`
17	`}`

14	`func NewService(repo repository.InventoryRepository) *service {`
15	`return &service{`
16	`repo: repo,`
17	`}`
18	`}`

15	`func (a *api) CancelOrder(ctx context.Context, params orderV1.CancelOrderParams) (orderV1.CancelOrderRes, error) {`
16	`orderDraft := model.Order{`
17	`OrderUUID: params.OrderUUID,`
18	`}`
19
20	`_, err := a.orderService.CancelOrder(ctx, lo.ToPtr(orderDraft))`
21	`if err != nil {`
22	`slog.Error("Cancel order error", "order:", params.OrderUUID, "error:", err)`
23
24	`if errors.Is(err, model.ErrOrderNotFound) {`
25	`return &orderV1.NotFoundError{`
26	`Code: http.StatusNotFound,`
27	`Message: "order not found",`
28	`}, nil`
29	`}`
30
31	`if errors.Is(err, model.ErrConvertFromRepo) {`
32	`return &orderV1.InternalServerError{`
33	`Code: http.StatusInternalServerError,`
34	`Message: "cannot convert order from repository",`
35	`}, nil`
36	`}`
37
38	`if errors.Is(err, model.ErrPaid) {`
39	`return &orderV1.BadRequestError{`
40	`Code: http.StatusBadRequest,`
41	`Message: "order already paid",`
42	`}, nil`
43	`}`
44
45	`if errors.Is(err, model.ErrCancelled) {`
46	`return &orderV1.BadRequestError{`
47	`Code: http.StatusBadRequest,`
48	`Message: "order already cancelled",`
49	`}, nil`
50	`}`
51
52	`return nil, err`
53	`}`
54
55	`return &orderV1.CancelOrderNoContent{}, nil`
56	`}`

15	`func (a api) CreateOrder(ctx context.Context, req orderV1.CreateOrderRequest) (orderV1.CreateOrderRes, error) {`
16	`orderDraft := model.Order{`
17	`UserUUID: uuid.UUID(req.UserUUID),`
18	`PartUUIDs: req.PartUuids,`
19	`}`
20
21	`createOrder, err := a.orderService.CreateOrder(ctx, &orderDraft)`
22	`if err != nil {`
23	`slog.Error("Create order error", "order:", req, "error:", err)`
24
25	`if errors.Is(err, model.ErrPartsSpecified) {`
26	`return &orderV1.BadRequestError{`
27	`Code: http.StatusBadRequest,`
28	`Message: "parts not specified",`
29	`}, nil`
30	`}`
31
32	`if errors.Is(err, model.ErrPartsListNotFound) {`
33	`return &orderV1.NotFoundError{`
34	`Code: http.StatusNotFound,`
35	`Message: "parts not found",`
36	`}, nil`
37	`}`
38
39	`if errors.Is(err, model.ErrConvertFromClient) {`
40	`return &orderV1.InternalServerError{`
41	`Code: http.StatusInternalServerError,`
42	`Message: "can't parse part",`
43	`}, nil`
44	`}`
45
46	`if errors.Is(err, model.ErrInventoryClient) {`
47	`return &orderV1.InternalServerError{`
48	`Code: http.StatusFailedDependency,`
49	`Message: "inventory client error",`
50	`}, nil`
51	`}`
52
53	`return nil, err`
54	`}`
55
56	`return &orderV1.CreateOrderResponse{`
57	`OrderUUID: orderV1.OrderUUID(createOrder.OrderUUID),`
58	`TotalPrice: orderV1.OptTotalPrice{`
59	`Value: orderV1.TotalPrice(createOrder.TotalPrice),`
60	`Set: true,`
61	`},`
62	`}, nil`
63	`}`

13	`func (a api) PayOrder(ctx context.Context, req orderV1.PayOrderRequest, params orderV1.PayOrderParams) (orderV1.PayOrderRes, error) {`
14	`orderDraft := model.Order{`
15	`OrderUUID: params.OrderUUID,`
16	`PaymentMethod: string(req.PaymentMethod),`
17	`}`
18
19	`order, err := a.orderService.PayOrder(ctx, &orderDraft)`
20	`if err != nil {`
21	`slog.Error("Pay order error", "order", params.OrderUUID, "error", err)`
22
23	`if errors.Is(err, model.ErrOrderNotFound) {`
24	`return &orderV1.NotFoundError{`
25	`Code: http.StatusNotFound,`
26	`Message: "order not found",`
27	`}, nil`
28	`}`
29
30	`if errors.Is(err, model.ErrConvertFromRepo) {`
31	`return &orderV1.InternalServerError{`
32	`Code: http.StatusInternalServerError,`
33	`Message: "cannot convert order from repository",`
34	`}, nil`
35	`}`
36
37	`if errors.Is(err, model.ErrConvertFromClient) {`
38	`return &orderV1.InternalServerError{`
39	`Code: http.StatusInternalServerError,`
40	`Message: "can't parse transaction",`
41	`}, nil`
42	`}`
43
44	`if errors.Is(err, model.ErrPaymentClient) {`
45	`return &orderV1.InternalServerError{`
46	`Code: http.StatusFailedDependency,`
47	`Message: "payment client error",`
48	`}, nil`
49	`}`
50
51	`return nil, err`
52	`}`
53
54	`return &orderV1.PayOrderResponse{`
55	`TransactionUUID: orderV1.TransactionUUID(order.TransactionUUID),`
56	`}, nil`
57	`}`

13	`func (a *api) GetOrderByUUID(ctx context.Context, params orderV1.GetOrderByUUIDParams) (orderV1.GetOrderByUUIDRes, error) {`
14	`order, err := a.orderService.GetOrder(ctx, params.OrderUUID)`
15	`if err != nil {`
16	`slog.Error("Get order error", "order", params.OrderUUID, "error", err)`
17
18	`if errors.Is(err, model.ErrOrderNotFound) {`
19	`return &orderV1.NotFoundError{`
20	`Code: http.StatusNotFound,`
21	`Message: "order not found",`
22	`}, nil`
23	`}`
24
25	`if errors.Is(err, model.ErrConvertFromRepo) {`
26	`return &orderV1.InternalServerError{`
27	`Code: http.StatusInternalServerError,`
28	`Message: "cannot convert order from repository",`
29	`}, nil`
30	`}`
31
32	`return nil, err`
33	`}`
34
35	`return &orderV1.OrderDto{`
36	`OrderUUID: order.OrderUUID,`
37	`UserUUID: order.UserUUID,`
38	`PartUuids: order.PartUUIDs,`
39	`TotalPrice: orderV1.OptFloat32{`
40	`Value: float32(order.TotalPrice),`
41	`Set: true,`
42	`},`
43	`TransactionUUID: orderV1.OptUUID{`
44	`Value: order.TransactionUUID,`
45	`Set: true,`
46	`},`
47	`PaymentMethod: orderV1.OptPaymentMethod{`
48	`Value: orderV1.PaymentMethod(order.PaymentMethod),`
49	`Set: true,`
50	`},`
51	`Status: orderV1.OrderStatus(order.Status),`
52	`}, nil`
53	`}`

10	`func (a api) NewError(ctx context.Context, err error) orderV1.GenericErrorStatusCode {`
11	`code := orderV1.OptInt{}`
12	`code.SetTo(http.StatusInternalServerError)`
13
14	`message := orderV1.OptString{}`
15	`message.SetTo(err.Error())`
16
17	`return &orderV1.GenericErrorStatusCode{`
18	`StatusCode: http.StatusInternalServerError,`
19	`Response: orderV1.GenericError{`
20	`Code: code,`
21	`Message: message,`
22	`},`
23	`}`
24	`}`

9	`func NewAPI(service service.OrderService) *api {`
10	`return &api{`
11	`orderService: service,`
12	`}`
13	`}`

10	`func ToProtoFilter(filter model.Filter) inventoryV1.PartsFilter {`
11	`uuids := make([]string, 0, len(filter.PartUUIDs))`
12	`for _, id := range filter.PartUUIDs {`
13	`uuids = append(uuids, id.String())`
14	`}`
15
16	`categories := make([]inventoryV1.Category, 0, len(filter.Categories))`
17	`for _, category := range filter.Categories {`
18	`// Безопасная конвертация int в int32 через строку`
19	`categoryStr := strconv.Itoa(int(category))`
20	`if categoryInt32, err := strconv.ParseInt(categoryStr, 10, 32); err == nil {`
21	`categories = append(categories, inventoryV1.Category(int32(categoryInt32)))`
22	`}`
23	`}`
24
25	`return &inventoryV1.PartsFilter{`
26	`PartUuid: uuids,`
27	`PartName: filter.PartNames,`
28	`Category: categories,`
29	`ManufacturerCountry: filter.ManufacturerCountries,`
30	`Tags: filter.Tags,`
31	`}`
32	`}`

10	`func ToModelPartsList(parts []inventoryV1.Part) ([]model.Part, error) {`
11	`result := make([]model.Part, 0, len(parts))`
12	`for _, part := range parts {`
13	`modelPart, err := ToModelPart(part)`
14	`if err != nil {`
15	`return nil, err`
16	`}`
17	`result = append(result, *modelPart)`
18	`}`
19	`return &result, nil`
20	`}`

22	`func ToModelPart(part inventoryV1.Part) (model.Part, error) {`
23	`id, err := uuid.Parse(part.PartUuid)`
24	`if err != nil {`
25	`return nil, model.ErrConvertFromClient`
26	`}`
27	`return &model.Part{`
28	`PartUUID: id,`
29	`Name: part.Name,`
30	`Description: part.Description,`
31	`Price: part.Price,`
32	`}, nil`
33	`}`

7	`func ToProtoPaymentMethod(paymentMethod string) generaredPaymentV1.PaymentMethod {`
8	`intPaymentMethod, ok := generaredPaymentV1.PaymentMethod_value["PAYMENT_METHOD_"+paymentMethod]`
9	`if !ok {`
10	`intPaymentMethod = int32(generaredPaymentV1.PaymentMethod_PAYMENT_METHOD_UNSPECIFIED)`
11	`}`
12	`return generaredPaymentV1.PaymentMethod(intPaymentMethod)`
13	`}`

11	`func (c inventoryClient) ListParts(ctx context.Context, filter model.Filter) ([]model.Part, error) {`
12	`parts, err := c.generatedClient.ListParts(ctx, &generaredInventoryV1.ListPartsRequest{`
13	`Filter: converter.ToProtoFilter(filter),`
14	`})`
15	`if err != nil {`
16	`return nil, model.ErrInventoryClient`
17	`}`
18
19	`modelParts, err := converter.ToModelPartsList(parts.Parts)`
20	`if err != nil {`
21	`return nil, err`
22	`}`
23
24	`return modelParts, nil`
25	`}`

11	`func NewClient(generatedClient generaredInventoryV1.InventoryServiceClient) *inventoryClient {`
12	`return &inventoryClient{`
13	`generatedClient: generatedClient,`
14	`}`
15	`}`

13	`func (p paymentClient) CreatePayment(ctx context.Context, order model.Order) (model.Order, error) {`
14	`// Оплачиваем заказ с помощью gRPC клиента`
15	`response, err := p.generatedClient.PayOrder(ctx, &generaredPaymentV1.PayOrderRequest{`
16	`OrderUuid: order.OrderUUID.String(),`
17	`UserUuid: order.UserUUID.String(),`
18	`PaymentMethod: converter.ToProtoPaymentMethod(order.PaymentMethod),`
19	`})`
20	`if err != nil {`
21	`return nil, model.ErrPaymentClient`
22	`}`
23
24	`transaction, err := uuid.Parse(response.GetTransactionUuid())`
25	`if err != nil {`
26	`return nil, model.ErrConvertFromClient`
27	`}`
28
29	`// Обновляем заказ`
30	`order.TransactionUUID = transaction`
31	`order.Status = model.StatusPaid`
32
33	`return order, nil`
34	`}`