291 lines
9.0 KiB
Go
291 lines
9.0 KiB
Go
// --------------------------------------------------------------------------------------------
|
|
// The following code is automatically generated by the mongo-dao-generator tool.
|
|
// Please do not modify this code manually to avoid being overwritten in the next generation.
|
|
// For more tool details, please click the link to view https://github.com/dobyte/mongo-dao-generator
|
|
// --------------------------------------------------------------------------------------------
|
|
|
|
package internal
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
modelpkg "mongo.games.com/mongoctl/example/model"
|
|
"time"
|
|
)
|
|
|
|
type MailFilterFunc func(cols *MailColumns) interface{}
|
|
type MailUpdateFunc func(cols *MailColumns) interface{}
|
|
type MailPipelineFunc func(cols *MailColumns) interface{}
|
|
type MailCountOptionsFunc func(cols *MailColumns) *options.CountOptions
|
|
type MailAggregateOptionsFunc func(cols *MailColumns) *options.AggregateOptions
|
|
type MailFindOneOptionsFunc func(cols *MailColumns) *options.FindOneOptions
|
|
type MailFindManyOptionsFunc func(cols *MailColumns) *options.FindOptions
|
|
type MailUpdateOptionsFunc func(cols *MailColumns) *options.UpdateOptions
|
|
type MailDeleteOptionsFunc func(cols *MailColumns) *options.DeleteOptions
|
|
type MailInsertOneOptionsFunc func(cols *MailColumns) *options.InsertOneOptions
|
|
type MailInsertManyOptionsFunc func(cols *MailColumns) *options.InsertManyOptions
|
|
|
|
type Mail struct {
|
|
Columns *MailColumns
|
|
Database *mongo.Database
|
|
Collection *mongo.Collection
|
|
}
|
|
|
|
type MailColumns struct {
|
|
ID string // 邮件ID
|
|
Title string // 邮件标题
|
|
Content string // 邮件内容
|
|
Sender string // 邮件发送者
|
|
Receiver string // 邮件接受者
|
|
Status string // 邮件状态
|
|
SendTime string // 发送时间
|
|
}
|
|
|
|
var mailColumns = &MailColumns{
|
|
ID: "_id", // 邮件ID
|
|
Title: "title", // 邮件标题
|
|
Content: "content", // 邮件内容
|
|
Sender: "sender", // 邮件发送者
|
|
Receiver: "receiver", // 邮件接受者
|
|
Status: "status", // 邮件状态
|
|
SendTime: "send_time", // 发送时间
|
|
}
|
|
|
|
func NewMail(db *mongo.Database) *Mail {
|
|
return &Mail{
|
|
Columns: mailColumns,
|
|
Database: db,
|
|
Collection: db.Collection("mail"),
|
|
}
|
|
}
|
|
|
|
// Count returns the number of documents in the collection.
|
|
func (dao *Mail) Count(ctx context.Context, filterFunc MailFilterFunc, optionsFunc ...MailCountOptionsFunc) (int64, error) {
|
|
var (
|
|
opts *options.CountOptions
|
|
filter = filterFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.CountDocuments(ctx, filter, opts)
|
|
}
|
|
|
|
// Aggregate executes an aggregate command against the collection and returns a cursor over the resulting documents.
|
|
func (dao *Mail) Aggregate(ctx context.Context, pipelineFunc MailPipelineFunc, optionsFunc ...MailAggregateOptionsFunc) (*mongo.Cursor, error) {
|
|
var (
|
|
opts *options.AggregateOptions
|
|
pipeline = pipelineFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.Aggregate(ctx, pipeline, opts)
|
|
}
|
|
|
|
// InsertOne executes an insert command to insert a single document into the collection.
|
|
func (dao *Mail) InsertOne(ctx context.Context, model *modelpkg.Mail, optionsFunc ...MailInsertOneOptionsFunc) (*mongo.InsertOneResult, error) {
|
|
if model == nil {
|
|
return nil, errors.New("model is nil")
|
|
}
|
|
|
|
if err := dao.autofill(ctx, model); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var opts *options.InsertOneOptions
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.InsertOne(ctx, model, opts)
|
|
}
|
|
|
|
// InsertMany executes an insert command to insert multiple documents into the collection.
|
|
func (dao *Mail) InsertMany(ctx context.Context, models []*modelpkg.Mail, optionsFunc ...MailInsertManyOptionsFunc) (*mongo.InsertManyResult, error) {
|
|
if len(models) == 0 {
|
|
return nil, errors.New("models is empty")
|
|
}
|
|
|
|
documents := make([]interface{}, 0, len(models))
|
|
for i := range models {
|
|
model := models[i]
|
|
if err := dao.autofill(ctx, model); err != nil {
|
|
return nil, err
|
|
}
|
|
documents = append(documents, model)
|
|
}
|
|
|
|
var opts *options.InsertManyOptions
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.InsertMany(ctx, documents, opts)
|
|
}
|
|
|
|
// UpdateOne executes an update command to update at most one document in the collection.
|
|
func (dao *Mail) UpdateOne(ctx context.Context, filterFunc MailFilterFunc, updateFunc MailUpdateFunc, optionsFunc ...MailUpdateOptionsFunc) (*mongo.UpdateResult, error) {
|
|
var (
|
|
opts *options.UpdateOptions
|
|
filter = filterFunc(dao.Columns)
|
|
update = updateFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.UpdateOne(ctx, filter, update, opts)
|
|
}
|
|
|
|
// UpdateOneByID executes an update command to update at most one document in the collection.
|
|
func (dao *Mail) UpdateOneByID(ctx context.Context, id string, updateFunc MailUpdateFunc, optionsFunc ...MailUpdateOptionsFunc) (*mongo.UpdateResult, error) {
|
|
objectID, err := primitive.ObjectIDFromHex(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return dao.UpdateOne(ctx, func(cols *MailColumns) interface{} {
|
|
return bson.M{"_id": objectID}
|
|
}, updateFunc, optionsFunc...)
|
|
}
|
|
|
|
// UpdateMany executes an update command to update documents in the collection.
|
|
func (dao *Mail) UpdateMany(ctx context.Context, filterFunc MailFilterFunc, updateFunc MailUpdateFunc, optionsFunc ...MailUpdateOptionsFunc) (*mongo.UpdateResult, error) {
|
|
var (
|
|
opts *options.UpdateOptions
|
|
filter = filterFunc(dao.Columns)
|
|
update = updateFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.UpdateMany(ctx, filter, update, opts)
|
|
}
|
|
|
|
// FindOne executes a find command and returns a model for one document in the collection.
|
|
func (dao *Mail) FindOne(ctx context.Context, filterFunc MailFilterFunc, optionsFunc ...MailFindOneOptionsFunc) (*modelpkg.Mail, error) {
|
|
var (
|
|
opts *options.FindOneOptions
|
|
model = &modelpkg.Mail{}
|
|
filter = filterFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
err := dao.Collection.FindOne(ctx, filter, opts).Decode(model)
|
|
if err != nil {
|
|
if err == mongo.ErrNoDocuments {
|
|
return nil, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return model, nil
|
|
}
|
|
|
|
// FindOneByID executes a find command and returns a model for one document in the collection.
|
|
func (dao *Mail) FindOneByID(ctx context.Context, id string, optionsFunc ...MailFindOneOptionsFunc) (*modelpkg.Mail, error) {
|
|
objectID, err := primitive.ObjectIDFromHex(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return dao.FindOne(ctx, func(cols *MailColumns) interface{} {
|
|
return bson.M{"_id": objectID}
|
|
}, optionsFunc...)
|
|
}
|
|
|
|
// FindMany executes a find command and returns many models the matching documents in the collection.
|
|
func (dao *Mail) FindMany(ctx context.Context, filterFunc MailFilterFunc, optionsFunc ...MailFindManyOptionsFunc) ([]*modelpkg.Mail, error) {
|
|
var (
|
|
opts *options.FindOptions
|
|
filter = filterFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
cur, err := dao.Collection.Find(ctx, filter, opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
models := make([]*modelpkg.Mail, 0)
|
|
|
|
if err = cur.All(ctx, &models); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return models, nil
|
|
}
|
|
|
|
// DeleteOne executes a delete command to delete at most one document from the collection.
|
|
func (dao *Mail) DeleteOne(ctx context.Context, filterFunc MailFilterFunc, optionsFunc ...MailDeleteOptionsFunc) (*mongo.DeleteResult, error) {
|
|
var (
|
|
opts *options.DeleteOptions
|
|
filter = filterFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.DeleteOne(ctx, filter, opts)
|
|
}
|
|
|
|
// DeleteOneByID executes a delete command to delete at most one document from the collection.
|
|
func (dao *Mail) DeleteOneByID(ctx context.Context, id string, optionsFunc ...MailDeleteOptionsFunc) (*mongo.DeleteResult, error) {
|
|
objectID, err := primitive.ObjectIDFromHex(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return dao.DeleteOne(ctx, func(cols *MailColumns) interface{} {
|
|
return bson.M{"_id": objectID}
|
|
}, optionsFunc...)
|
|
}
|
|
|
|
// DeleteMany executes a delete command to delete documents from the collection.
|
|
func (dao *Mail) DeleteMany(ctx context.Context, filterFunc MailFilterFunc, optionsFunc ...MailDeleteOptionsFunc) (*mongo.DeleteResult, error) {
|
|
var (
|
|
opts *options.DeleteOptions
|
|
filter = filterFunc(dao.Columns)
|
|
)
|
|
|
|
if len(optionsFunc) > 0 {
|
|
opts = optionsFunc[0](dao.Columns)
|
|
}
|
|
|
|
return dao.Collection.DeleteMany(ctx, filter, opts)
|
|
}
|
|
|
|
// autofill when inserting data
|
|
func (dao *Mail) autofill(ctx context.Context, model *modelpkg.Mail) error {
|
|
if model.ID.IsZero() {
|
|
model.ID = primitive.NewObjectID()
|
|
}
|
|
|
|
if model.SendTime == 0 {
|
|
model.SendTime = primitive.NewDateTimeFromTime(time.Now())
|
|
}
|
|
|
|
return nil
|
|
}
|