bpiek/api/categories.go

package api

import (
	"errors"
	"gitea.24example.ru/spavelit/bpiek/model"
	"gitea.24example.ru/spavelit/bpiek/utils"
)

var categories []model.Category
var parentCategories []model.Category
var treeCategories []model.TreeCategories

func (a *Api) GetCategories() ([]model.Category, error) {
	if len(categories) > 0 {
		return categories, nil
	}

	parentCategories, err := a.GetParentCategories()

	if err != nil {
		return nil, err
	}

	for _, category := range parentCategories {
		categoriesAndProduct, err := a.GetCategoriesAndProductsBySlugParentCategory(category.Slug)
		if err != nil {
			return nil, err
		}

		if len(categoriesAndProduct.Categories) != 0 {
			categories = append(categories, categoriesAndProduct.Categories...)
		}
	}

	return categories, nil
}

func (a *Api) GetParentCategories() ([]model.Category, error) {

	if len(parentCategories) > 0 {
		return parentCategories, nil
	}

	apiResponse, err := a.Client.HTTPClient.R().SetResult(&model.CategoryResponse{}).Get("client/catalog")
	if err != nil {
		return nil, err
	}

	if apiResponse.StatusCode() != 200 {
		return nil, errors.New("failed to get categories")
	}

	result := apiResponse.Result().(*model.CategoryResponse).Categories

	if len(result) == 0 {
		return nil, errors.New("no categories found")
	}

	parentCategories = result

	return parentCategories, nil
}

func (a *Api) GetCategoriesAndProductsBySlugParentCategory(slug string) (*model.CategoriesAndProductsBySlugParentCategoryResponse, error) {
	apiResponse, err := a.Client.HTTPClient.
		R().
		SetResult(&model.CategoriesAndProductsBySlugParentCategoryResponse{}).
		Get("client/category/" + slug + "/json")
	if err != nil {
		return nil, err
	}

	if apiResponse.StatusCode() != 200 {
		return nil, errors.New("failed to get categories and products")
	}

	return apiResponse.Result().(*model.CategoriesAndProductsBySlugParentCategoryResponse), nil
}

func (a *Api) GetTreeCategories() ([]model.TreeCategories, error) {
	if len(treeCategories) > 0 {
		return treeCategories, nil
	}

	tree := map[string]interface{}{}

	parentCategories, err := a.GetParentCategories()
	if err != nil {
		return nil, err
	}

	for _, parent := range parentCategories {
		tree[parent.Slug] = map[string]interface{}{
			"name":     parent.Name,
			"slug":     parent.Slug,
			"url":      parent.Url,
			"children": map[string]interface{}{},
		}

		categoriesAndProduct, err := a.GetCategoriesAndProductsBySlugParentCategory(parent.Slug)
		if err != nil {
			return nil, err
		}

		utils.ConvertListToNestedDict(categoriesAndProduct.Categories, tree)
	}

	treeCategories = utils.ConvertToNestedList(tree)

	return treeCategories, nil
}