projectx/internal/erpserver/repository/system/department/department.go

package department

import (
	"bytes"
	"context"
	"fmt"
	"time"

	"management/internal/erpserver/model/dto"
	"management/internal/erpserver/model/system"
	"management/internal/erpserver/repository"
	"management/internal/pkg/sqldb"

	"github.com/drhin/logger"
)

type store struct {
	db  *repository.Store
	log *logger.Logger
}

func NewStore(db *repository.Store, log *logger.Logger) system.DepartmentRepository {
	return &store{
		db:  db,
		log: log,
	}
}

func (s *store) Initialize(ctx context.Context) (*system.Department, error) {
	count, err := s.Count(ctx, dto.SearchDto{})
	if err != nil {
		return nil, err
	}

	if count == 0 {
		obj := &system.Department{
			Name:       "公司",
			ParentID:   0,
			ParentPath: ",0,",
			Status:     0,
			Sort:       6666,
			CreatedAt:  time.Now(),
			UpdatedAt:  time.Now(),
		}
		return s.Create(ctx, obj)
	}
	return s.Get(ctx, 1)
}

func (s *store) Create(ctx context.Context, obj *system.Department) (*system.Department, error) {
	//goland:noinspection ALL
	const q = `
	INSERT INTO sys_department (
		name, parent_id, parent_path, status, sort
	) VALUES (
		:name, :parent_id, :parent_path, :status, :sort      
	) RETURNING *;`

	data := map[string]any{
		"name":        obj.Name,
		"parent_id":   obj.ParentID,
		"parent_path": obj.ParentPath,
		"status":      obj.Status,
		"sort":        obj.Sort,
	}

	err := sqldb.NamedQueryStruct(ctx, s.log, s.db.DB(ctx), q, data, &obj)
	if err != nil {
		return nil, err
	}
	return obj, err
}

func (s *store) Update(ctx context.Context, obj *system.Department) error {
	const q = `
	UPDATE sys_department
	SET name = :name,
		parent_id = :parent_id,
		parent_path = :parent_path,
		status = :status,
		sort = :sort,
		updated_at = :updated_at
	WHERE id = :id;`

	return sqldb.NamedExecContext(ctx, s.log, s.db.DB(ctx), q, obj)
}

func (s *store) Get(ctx context.Context, id int32) (*system.Department, error) {
	//goland:noinspection ALL
	const q = `
	SELECT
		id, name, parent_id, parent_path, status, sort, created_at, updated_at
	FROM 
		sys_department
	WHERE 
		id = :id;`

	data := map[string]any{
		"id": id,
	}

	var depart system.Department
	err := sqldb.NamedQueryStruct(ctx, s.log, s.db.DB(ctx), q, data, &depart)
	if err != nil {
		return nil, fmt.Errorf("select id department: %w", err)
	}

	return &depart, nil
}

func (s *store) All(ctx context.Context) ([]*system.Department, error) {
	//goland:noinspection ALL
	const q = `
	SELECT
		id, name, parent_id, parent_path, status, sort, created_at, updated_at
	FROM 
		sys_department;`

	data := map[string]any{}

	var departs []system.Department
	err := sqldb.NamedQuerySlice(ctx, s.log, s.db.DB(ctx), q, data, &departs)
	if err != nil {
		return nil, fmt.Errorf("select all department: %w", err)
	}

	return toPointer(departs), nil
}

func (s *store) Count(ctx context.Context, filter dto.SearchDto) (int64, error) {
	//goland:noinspection ALL
	const q = `
	SELECT 
		COUNT(1)
	FROM 
		sys_department`

	data := map[string]any{}

	buf := bytes.NewBufferString(q)
	applyFilter(filter, data, buf)

	var count struct {
		Count int64 `db:"count"`
	}

	err := sqldb.NamedQueryStruct(ctx, s.log, s.db.DB(ctx), buf.String(), data, &count)
	if err != nil {
		return 0, fmt.Errorf("select count department: %w", err)
	}

	return count.Count, nil
}

func (s *store) List(ctx context.Context, filter dto.SearchDto) ([]*system.Department, error) {
	//goland:noinspection ALL
	const q = `
	SELECT
		id, name, parent_id, parent_path, status, sort, created_at, updated_at
	FROM 
		sys_department`

	data := map[string]any{
		"offset":        (filter.Page - 1) * filter.Rows,
		"rows_per_page": filter.Rows,
	}

	buf := bytes.NewBufferString(q)
	applyFilter(filter, data, buf)

	buf.WriteString(" ORDER BY id DESC")
	buf.WriteString(" LIMIT :rows_per_page OFFSET :offset")

	var departs []system.Department
	err := sqldb.NamedQuerySlice(ctx, s.log, s.db.DB(ctx), buf.String(), data, &departs)
	if err != nil {
		return nil, err
	}
	return toPointer(departs), nil
}

func (s *store) RebuildParentPath(ctx context.Context) error {
	query := `
	UPDATE sys_department AS tm
	SET parent_path = (SELECT ',' || string_agg(cast(t.parent_id AS VARCHAR), ',') || ','
					   FROM (WITH RECURSIVE temp (id, parent_id) AS (SELECT id, tm.parent_id
																	 FROM sys_department
																	 WHERE id = tm.id
																	 UNION ALL
																	 SELECT sys_department.id, sys_department.parent_id
																	 FROM sys_department,
																		  temp
																	 WHERE sys_department.id = temp.parent_id)
							 SELECT id, parent_id
							 FROM temp
							 ORDER BY id) AS t)
	WHERE tm.status = 0;`
	return sqldb.NamedExecContext(ctx, s.log, s.db.DB(ctx), query, nil)
}

func toPointer(data []system.Department) []*system.Department {
	var res []*system.Department
	for _, v := range data {
		res = append(res, &v)
	}
	return res
}