golib/infra/svc/svc.go

package svc

import (
	"errors"

	"golib/features/mo"
	"golib/infra/ii"
	"golib/log/logs"
)

var (
	ErrItemNotfound     = errors.New("svc: item not found")
	ErrInternalError    = errors.New("svc: internal error") // ErrInternalError 上游函数错误时返回
	ErrDataError        = errors.New("svc: data error")     // ErrDataError 数据校验失败
	ErrPermissionDenied = errors.New("svc: permission denied")
)

type Service struct {
	Items  ii.Items
	Perms  ii.Permission
	User   ii.User
	Client *mo.Client
	Logs   *logs.Logs

	disableArg bool
}

// SetDisableArg 禁用 XML 配置内的聚合操作
func (s *Service) SetDisableArg(f bool) {
	s.disableArg = f
}

func (s *Service) Find(name string, filter mo.D) ([]mo.M, error) {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.Find: item not found: %s", name)
		return nil, ErrItemNotfound
	}
	if err := itemInfo.PrepareFilter(filter); err != nil {
		s.Logs.Println("svc.Find: PrepareFilter: %s data error: %s", name, err)
		return nil, ErrDataError
	}

	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.Find: AC: %s", err)
		return nil, ErrPermissionDenied
	}

	var (
		arg []mo.D
		err error
	)

	if !s.disableArg {
		arg, err = itemInfo.Aggregation(s.Items)
		if err != nil {
			return nil, err
		}
	}

	var (
		cursor *mo.Cursor
	)

	if len(arg) == 0 {
		cursor, err = itemInfo.Open(s.Client).Find(filter)
	} else {
		pipe := mo.NewPipeline(&mo.Matcher{Filter: filter})

		pipe = append(pipe, arg...)
		cursor, err = itemInfo.Open(s.Client).Aggregate(pipe)
	}

	if err != nil {
		s.Logs.Println("svc.Find: %s internal error: %s", name, err)
		return nil, ErrInternalError
	}

	var data []mo.M
	if err = mo.CursorDecodeAll(cursor, &data); err != nil {
		s.Logs.Println("svc.Find: CursorDecodeAll: %s internal error: %s", name, err)
		return nil, ErrInternalError
	}

	return data, nil
}

// FindOne 查询一个文档
func (s *Service) FindOne(name string, filter mo.D) (mo.M, error) {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.FindOne: item not found: %s", name)
		return nil, ErrItemNotfound
	}
	if err := itemInfo.PrepareFilter(filter); err != nil {
		s.Logs.Println("svc.FindOne: PrepareFilter: %s data error: %s", name, err)
		return nil, ErrDataError
	}

	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.FindOne: AC: %s", err)
		return nil, ErrPermissionDenied
	}

	var (
		arg []mo.D
		err error
	)

	if !s.disableArg {
		arg, err = itemInfo.Aggregation(s.Items)
		if err != nil {
			return nil, err
		}
	}

	var (
		cursor *mo.Cursor
	)

	if len(arg) == 0 {
		// MongoDB 内的 FindOne 也是由 Find 实现, 只需在 FindOptions 内设置 Limit 为负数即可, 详情参见 MongoDB FindOne 函数
		opt := mo.Options.Find().SetLimit(-1)
		// 此处不使用 FindOne 而是使用 Find 是为了保持和下面的聚合操作返回同样的数据类型, 使代码更整洁
		cursor, err = itemInfo.Open(s.Client).Find(filter, opt)
	} else {
		pipe := mo.NewPipeline(&mo.Matcher{Filter: filter}, &mo.Limiter{Limit: 1})

		pipe = append(pipe, arg...)
		cursor, err = itemInfo.Open(s.Client).Aggregate(pipe)
	}

	if err != nil {
		s.Logs.Println("svc.FindOne: %s internal error: %s", name, err)
		return nil, ErrInternalError
	}

	var data mo.M
	if err = mo.CursorDecode(cursor, &data); err != nil {
		s.Logs.Println("svc.FindOne: CursorDecode: %s internal error: %s", name, err)
		return nil, ErrInternalError
	}

	return data, nil
}

// FindOneAndDelete 查找并删除文档
// TODO 待定真删除还是假删除
func (s *Service) FindOneAndDelete() {}

func (s *Service) DeleteOne(name string, filter mo.D) error {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.DeleteOne: item not found: %s", name)
		return ErrItemNotfound
	}

	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.DeleteOne: AC: %s", err)
		return ErrPermissionDenied
	}

	result, err := itemInfo.Open(s.Client).DeleteOne(filter)
	if err != nil {
		s.Logs.Println("svc.DeleteOne: %s internal error: %s", name, err)
		return err
	}
	s.Logs.Println("svc.DeleteOne: %d documents has been deleted", result.DeletedCount)
	return nil
}

func (s *Service) DeleteMany(name string, filter mo.D) error {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.DeleteMany: item not found: %s", name)
		return ErrItemNotfound
	}

	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.DeleteMany: AC: %s", err)
		return ErrPermissionDenied
	}

	result, err := itemInfo.Open(s.Client).DeleteMany(filter)
	if err != nil {
		s.Logs.Println("svc.DeleteMany: %s internal error: %s", name, err)
		return err
	}
	s.Logs.Println("svc.DeleteMany: %d documents has been deleted", result.DeletedCount)
	return nil
}

// FindOneAndUpdate 查找并更新文档, 详情见 mo.SingleResult
func (s *Service) FindOneAndUpdate(name string, filter mo.D, update mo.M) error {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.FindOneAndUpdate: item not found: %s", name)
		return ErrItemNotfound
	}
	if err := itemInfo.PrepareFilter(filter); err != nil {
		s.Logs.Println("svc.FindOneAndUpdate: PrepareFilter: %s data error: %s", name, err)
		return ErrDataError
	}

	if err := itemInfo.PrepareUpdate(update, s.User); err != nil {
		s.Logs.Println("svc.FindOneAndUpdate: PrepareUpdate: %s data error: %s", name, err)
		return ErrDataError
	}

	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.FindOneAndUpdate: AC: %s", err)
		return ErrPermissionDenied
	}

	ou := OptionUpdate{}
	ou.SetSet(update)
	ou.SetCurrentDate()

	result := itemInfo.Open(s.Client).FindOneAndUpdate(filter, ou.Build())
	if err := result.Err(); err != nil {
		s.Logs.Println("svc.FindOneAndUpdate: %s internal error: %s", name, err)
		return err
	}

	return nil
}

// EstimatedDocumentCount 合计合集中的文档数量
func (s *Service) EstimatedDocumentCount(name string) (int64, error) {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.EstimatedDocumentCount: item not found: %s", name)
		return 0, ErrItemNotfound
	}

	length, err := itemInfo.Open(s.Client).EstimatedDocumentCount()
	if err != nil {
		s.Logs.Println("svc.EstimatedDocumentCount: %s internal error: %s", name, err)
		return 0, ErrInternalError
	}

	return length, nil
}

// CountDocuments 有条件的合集文档中的数量
func (s *Service) CountDocuments(name string, filter mo.D) (int64, error) {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.CountDocuments: item not found: %s", name)
		return 0, ErrItemNotfound
	}
	if err := itemInfo.PrepareFilter(filter); err != nil {
		s.Logs.Println("svc.CountDocuments: PrepareFilter: %s data error: %s", name, err)
		return 0, ErrDataError
	}
	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.CountDocuments: AC: %s", err)
		return 0, ErrPermissionDenied
	}
	length, err := itemInfo.Open(s.Client).CountDocuments(filter)
	if err != nil {
		s.Logs.Println("svc.CountDocuments: %s internal error: %s", name, err)
		return 0, ErrInternalError
	}
	return length, nil
}

// InsertOne 插入一条文档
// MongoDB 在插入文档时对于 _id 的做法: 即 doc 中不存在 _id 字段时会在数据编码时补充 _id 字段并且值使用 mo.ObjectID 而不修改源文档.
// 当 _id 字段存在时不会修改其数据类型. 但为了保持数据类型的统一性, 此处当 _id 存在时其必须为 mo.ObjectID 类型
func (s *Service) InsertOne(name string, doc mo.M) (mo.ObjectID, error) {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.InsertOne: item not found: %s", name)
		return mo.NilObjectID, ErrItemNotfound
	}

	if err := itemInfo.PrepareInsert(doc, s.User); err != nil {
		s.Logs.Println("svc.InsertOne: %s data error: %s", name, err)
		return mo.NilObjectID, ErrDataError
	}

	result, err := itemInfo.Open(s.Client).InsertOne(doc)
	if err != nil {
		s.Logs.Println("svc.InsertOne: %s internal error: %s", name, err)
		return mo.NilObjectID, ErrInternalError
	}

	return result.InsertedID.(mo.ObjectID), nil
}

// InsertMany 插入多条文档
// 对于 _id 的处理参见 InsertOne
// MongoDB 插入多条文档时并不要求列表内所有元素的数据类型一致, 但为了保持数据类型的统一性, docs 内的所有元素数据类型必须为 map/object
func (s *Service) InsertMany(name string, docs mo.A) ([]mo.ObjectID, error) {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.InsertMany: item not found: %s", name)
		return nil, ErrItemNotfound
	}

	err := s.toMaps(docs, func(row mo.M) error {
		if err := itemInfo.PrepareInsert(row, s.User); err != nil {
			s.Logs.Println("svc.InsertMany: %s data error: %s", name, err)
			return ErrDataError
		}
		return nil
	})

	if err != nil {
		s.Logs.Println("svc.InsertMany: %s data error: %s", name, err)
		return nil, ErrDataError
	}

	result, err := itemInfo.Open(s.Client).InsertMany(docs)
	if err != nil {
		s.Logs.Println("svc.InsertMany: %s internal error: %s", name, err)
		return nil, ErrInternalError
	}

	ids := make([]mo.ObjectID, len(result.InsertedIDs))
	// MongoDB 保证此处返回的类型为 mo.ObjectID
	for i, id := range result.InsertedIDs {
		ids[i] = id.(mo.ObjectID)
	}
	return ids, nil
}

func (s *Service) UpdateOne(name string, filter mo.D, update mo.M) error {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.UpdateOne: item not found: %s", name)
		return ErrItemNotfound
	}
	if err := itemInfo.PrepareFilter(filter); err != nil {
		s.Logs.Println("svc.UpdateOne: PrepareFilter: %s data error: %s", name, err)
		return ErrDataError
	}
	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.UpdateOne: AC: %s", err)
		return ErrPermissionDenied
	}
	if err := itemInfo.PrepareUpdate(update, s.User); err != nil {
		s.Logs.Println("svc.UpdateOne: PrepareUpdate: %s data error: %s", name, err)
		return ErrDataError
	}

	ou := OptionUpdate{}
	ou.SetSet(update)
	ou.SetCurrentDate()

	_, err := itemInfo.Open(s.Client).UpdateOne(filter, ou.Build())
	if err != nil {
		s.Logs.Println("svc.UpdateOne: %s internal error: %s", name, err)
		return ErrInternalError
	}
	return nil
}

func (s *Service) UpdateByID(name string, id mo.ObjectID, update mo.M) error {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.UpdateByID: item not found: %s", name)
		return ErrItemNotfound
	}
	if id.IsZero() {
		s.Logs.Println("svc.UpdateByID: id are zero: %s", name)
		return ErrDataError
	}
	if err := itemInfo.PrepareUpdate(update, s.User); err != nil {
		s.Logs.Println("svc.UpdateByID: %s data error: %s", name, err)
		return ErrDataError
	}

	ou := OptionUpdate{}
	ou.SetSet(update)
	ou.SetCurrentDate()

	_, err := itemInfo.Open(s.Client).UpdateByID(id, ou.Build())
	if err != nil {
		s.Logs.Println("svc.UpdateByID: %s internal error: %s", name, err)
		return ErrInternalError
	}
	return nil
}

func (s *Service) UpdateMany(name string, filter mo.D, update mo.M) error {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.UpdateMany: item not found: %s", name)
		return ErrItemNotfound
	}
	if err := itemInfo.PrepareFilter(filter); err != nil {
		s.Logs.Println("svc.UpdateMany: PrepareFilter: %s data error: %s", name, err)
		return ErrDataError
	}
	if err := s.AC(itemInfo.Name, &filter); err != nil {
		s.Logs.Println("svc.UpdateMany: AC: %s", err)
		return ErrPermissionDenied
	}
	if err := itemInfo.PrepareUpdate(update, s.User); err != nil {
		s.Logs.Println("svc.UpdateMany: PrepareUpdate: %s data error: %s", name, err)
		return ErrDataError
	}

	ou := OptionUpdate{}
	ou.SetSet(update)
	ou.SetCurrentDate()

	_, err := itemInfo.Open(s.Client).UpdateMany(filter, ou.Build())
	if err != nil {
		s.Logs.Println("svc.UpdateMany: %s internal error: %s", name, err)
		return ErrInternalError
	}
	return nil
}

// Aggregate 聚合查询
// v 必须传入指针类型
// Aggregate 默认不传入 XML 配置中的 Lookup/Set 等聚合操作, 当需要时可通过 itemInfo.Aggregation 函数创建后传入
func (s *Service) Aggregate(name string, pipe mo.Pipeline, v interface{}) error {
	itemInfo, ok := s.Items.Has(name)
	if !ok {
		s.Logs.Println("svc.Aggregate: item not found: %s", name)
		return ErrItemNotfound
	}

	// 如果存在 mo.PsMatch 操作符时则追加
	if i, d, o := mo.HasOperator(pipe, mo.PsMatch); o {
		filter, ok := d.(mo.D)
		if !ok {
			return ErrDataError
		}
		if err := s.AC(itemInfo.Name, &filter); err != nil {
			s.Logs.Println("svc.Aggregate: AC: %s", err)
			return ErrPermissionDenied
		}
		pipe[i] = mo.D{{Key: mo.PsMatch, Value: filter}}
	} else {
		// 不存在时则新建一个 mo.PsMatch
		var filter mo.D
		if err := s.AC(itemInfo.Name, &filter); err != nil {
			s.Logs.Println("svc.Aggregate: AC: %s", err)
			return ErrPermissionDenied
		}
		if filter != nil {
			pipe = append(mo.Pipeline{mo.D{{Key: mo.PsMatch, Value: filter}}}, pipe...)
		}
	}

	cursor, err := itemInfo.Open(s.Client).Aggregate(pipe)
	if err != nil {
		s.Logs.Println("svc.Aggregate: %s internal error: %s", name, err)
		return ErrInternalError
	}
	if err = mo.CursorDecodeAll(cursor, v); err != nil {
		s.Logs.Println("svc.Aggregate: CursorDecodeAll: %s internal error: %s", name, err)
		return ErrInternalError
	}
	return nil
}

func (s *Service) AC(name ii.Name, filter *mo.D) error {
	perms, ok := s.Perms.Has(name, s.User)
	if !ok {
		return ErrPermissionDenied
	}
	// perms 应当在 filter 后面, 假设 filter 与 perms 同时存在 name=1 的条件, 按照权限限制应当以 perms 为准
	// MongoDB 对于同一个字段出现多次时, 以最后出现的字段生效
	*filter = append(*filter, perms...)
	return nil
}