master_keuangan/pkg/database/mongo/menu.go

package mongo

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"log"
	MenuHandler "template_blueprint/pkg/models/menu"
	"time"
)

func (s *DatabaseService) GetMenu() ([]*MenuHandler.Menu, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	datalogin, err := s.DBMongo.Collection("menu").Find(ctx, bson.D{})
	if err != nil {
		log.Println(err)
	}
	var menu []*MenuHandler.Menu
	err = datalogin.All(ctx, &menu)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	return menu, nil
}

func (s *DatabaseService) Getrole() ([]*MenuHandler.Rolemenu, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	datarole, err := s.DBMongo.Collection("role_menu").Find(ctx, bson.D{})
	if err != nil {
		log.Println(err)
	}
	var role []*MenuHandler.Rolemenu
	err = datarole.All(ctx, &role)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	return role, nil
}

func (s *DatabaseService) Gettype() ([]*MenuHandler.TypeUser, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	datatype, err := s.DBMongo.Collection("type_user").Find(ctx, bson.D{})
	if err != nil {
		log.Println(err)
	}
	var typeuser []*MenuHandler.TypeUser
	err = datatype.All(ctx, &typeuser)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	return typeuser, nil
}

func (s *DatabaseService) GetBytypeID(id string) ([]*MenuHandler.Rolemenu, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	filter := bson.M{
		"type_user_id": id,
	}

	cursor, err := s.DBMongo.Collection("role_menu").Find(ctx, filter)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	defer cursor.Close(ctx)
	var results []*MenuHandler.Rolemenu
	if err = cursor.All(ctx, &results); err != nil {
		log.Println(err)
		return nil, err
	}
	return results, nil
}

func (s *DatabaseService) GetmenuByID(id string) ([]*MenuHandler.Menu, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	objectID, err := primitive.ObjectIDFromHex(id)
	filter := bson.M{
		"_id": objectID,
	}

	cursor, err := s.DBMongo.Collection("menu").Find(ctx, filter)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	defer cursor.Close(ctx)
	var results []*MenuHandler.Menu
	if err = cursor.All(ctx, &results); err != nil {
		log.Println(err)
		return nil, err
	}
	return results, nil
}

func (s *DatabaseService) GettypeByID(id string) ([]*MenuHandler.TypeUser, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	objectID, err := primitive.ObjectIDFromHex(id)
	filter := bson.M{
		"_id": objectID,
	}

	cursor, err := s.DBMongo.Collection("type_user").Find(ctx, filter)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	defer cursor.Close(ctx)
	var results []*MenuHandler.TypeUser
	if err = cursor.All(ctx, &results); err != nil {
		log.Println(err)
		return nil, err
	}
	return results, nil
}

func (s *DatabaseService) GetGroupedBytypeIDFlatWithMenu(id string) (*MenuHandler.GroupedRoleMenuFlatWithMenu, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	objectID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return nil, fmt.Errorf("invalid ObjectID format: %v", err)
	}

	pipeline := []bson.M{
		{
			"$match": bson.M{
				"type_user_id": id,
			},
		},
		{
			"$group": bson.M{
				"_id": "$type_user_id",
				"menu_id": bson.M{
					"$push": "$menu_id",
				},
			},
		},
		{
			"$lookup": bson.M{
				"from": "type_user",
				"let":  bson.M{"user_id": objectID},
				"pipeline": []bson.M{
					{
						"$match": bson.M{
							"$expr": bson.M{
								"$eq": []interface{}{"$_id", "$$user_id"},
							},
						},
					},
					{
						"$project": bson.M{
							"_id":     0,
							"display": 1,
						},
					},
				},
				"as": "user_info",
			},
		},
		{
			"$unwind": "$menu_id",
		},
		{
			"$lookup": bson.M{
				"from": "menu",
				"let":  bson.M{"menu_id_str": "$menu_id"},
				"pipeline": []bson.M{
					{
						"$addFields": bson.M{
							"menu_id_as_string": bson.M{"$toString": "$_id"},
						},
					},
					{
						"$match": bson.M{
							"$expr": bson.M{
								"$eq": []interface{}{"$menu_id_as_string", "$$menu_id_str"},
							},
						},
					},
					{
						"$project": bson.M{
							"_id":     0,
							"display": 1,
							"icon":    1,
							"link":    1,
						},
					},
				},
				"as": "menu_details",
			},
		},
		{
			"$unwind": bson.M{
				"path":                       "$menu_details",
				"preserveNullAndEmptyArrays": true,
			},
		},
		{
			"$group": bson.M{
				"_id":       "$_id",
				"user_info": bson.M{"$first": "$user_info"},
				"menus": bson.M{
					"$push": bson.M{
						"menu_id":      "$menu_id",
						"menu_display": "$menu_details.display",
						"menu_icon":    "$menu_details.icon",
						"menu_link":    "$menu_details.link",
					},
				},
			},
		},
		{
			"$project": bson.M{
				"_id":          0,
				"type_user_id": "$_id",
				"display": bson.M{
					"$ifNull": []interface{}{
						bson.M{"$arrayElemAt": []interface{}{"$user_info.display", 0}},
						"",
					},
				},
				"menus": 1,
			},
		},
	}

	cursor, err := s.DBMongo.Collection("role_menu").Aggregate(ctx, pipeline)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	defer cursor.Close(ctx)

	var results []MenuHandler.GroupedRoleMenuFlatWithMenu
	if err = cursor.All(ctx, &results); err != nil {
		log.Println(err)
		return nil, err
	}

	if len(results) == 0 {
		return &MenuHandler.GroupedRoleMenuFlatWithMenu{
			TypeUserID: id,
			Display:    "",
			Menus:      []MenuHandler.FlatMenu{},
		}, nil
	}

	return &results[0], nil
}

func (s *DatabaseService) GetBytypeIDdelete(id string) error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	filter := bson.M{
		"type_user_id": id,
	}

	_, err := s.DBMongo.Collection("role_menu").DeleteMany(ctx, filter)
	if err != nil {
		log.Println(err)
		return err
	}

	return nil
}

func (s *DatabaseService) InsertRole(req []MenuHandler.Rolemenu) error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	var interfaceArray []interface{}

	for _, role := range req {
		if role.ID.IsZero() {
			role.ID = primitive.NewObjectID()
		}
		interfaceArray = append(interfaceArray, role)
	}
	_, err := s.DBMongo.Collection("role_menu").InsertMany(ctx, interfaceArray)
	if err != nil {
		log.Println(err)
		return err
	}

	return nil
}