commit doble databse

pkg/database/mongo/database.go

@@ -5,9 +5,9 @@ import (
 )
 
 type DatabaseService struct {
-	DB *mongo.Database
+	DBMongo *mongo.Database
 }
 
-func NewDatabaseService(db *mongo.Database) *DatabaseService {
-	return &DatabaseService{DB: db}
+func NewDatabaseServiceMongo(db *mongo.Database) *DatabaseService {
+	return &DatabaseService{DBMongo: db}
 }

pkg/database/mongo/login.go

@@ -0,0 +1,52 @@
+package mongo
+
+import (
+	"context"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"log"
+	loginHandler "template_blueprint/pkg/models/login"
+	"time"
+)
+
+func (s *DatabaseService) Getlogin() ([]*loginHandler.Menu, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	datalogin, err := s.DBMongo.Collection("role_menu_ex").Find(ctx, bson.D{})
+	if err != nil {
+		log.Println(err)
+	}
+	var login []*loginHandler.Menu
+	err = datalogin.All(ctx, &login)
+	if err != nil {
+		log.Println(err)
+		return nil, err
+	}
+	return login, nil
+}
+
+func (s *DatabaseService) GetByid(id string) (*loginHandler.Menu, 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 ID format: %v", err)
+	}
+	filter := bson.M{
+		"_id": objectID,
+	}
+
+	var result loginHandler.Menu
+	err = s.DBMongo.Collection("role_menu_ex").FindOne(ctx, filter).Decode(&result)
+	if err != nil {
+		if err == mongo.ErrNoDocuments {
+			return nil, fmt.Errorf("ID %s tidak ditemukan", id)
+		}
+		return nil, err
+	}
+
+	return &result, nil
+}

pkg/database/mongo/master_data.go

@@ -1,24 +0,0 @@
-package mongo
-
-import (
-	"context"
-	"log"
-	"template_blueprint/pkg/models/master_data"
-	"time"
-)
-
-func (s *DatabaseService) InsertDataMaster(req master_data.ReqInsertData) error {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	_, err := s.DB.Collection(req.Table).InsertOne(ctx, master_data.ReqInsertDataMaster{
-		ID:      req.ID,
-		System:  req.System,
-		Code:    req.Code,
-		Display: req.Display,
-	})
-	if err != nil {
-		log.Println(err)
-		return err
-	}
-	return nil
-}

pkg/database/mongo/mongo.go

@@ -1,29 +0,0 @@
-package mongo
-
-import (
-	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"log"
-	"template_blueprint/pkg/models/local"
-	"time"
-)
-
-func (s *DatabaseService) GetDataLog() ([]*local.StartUpLog, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	dataLog, err := s.DB.Collection("startup_log").Find(ctx, bson.M{})
-	if err != nil {
-		log.Println("MASUK SINI")
-		log.Println(err)
-		return nil, err
-	}
-	log.Println("Data", dataLog.Current)
-	var logs []*local.StartUpLog
-	errDecode := dataLog.All(ctx, &logs)
-	if errDecode != nil {
-		log.Println(errDecode)
-		return nil, errDecode
-	}
-	log.Println("LOGS :", logs)
-	return logs, nil
-}

pkg/database/mongo/patient.go

@@ -1,36 +0,0 @@
-package mongo
-
-import (
-	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"log"
-	"template_blueprint/pkg/models/patient"
-	"time"
-)
-
-func (s *DatabaseService) InsertPatient(req *patient.Patient) error {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	_, err := s.DB.Collection("patient").InsertOne(ctx, req)
-	if err != nil {
-		log.Println(err)
-		return err
-	}
-	return nil
-}
-
-func (s *DatabaseService) GetAllDataPatient() ([]*patient.Patient, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	dataUser, err := s.DB.Collection("patient").Find(ctx, bson.D{})
-	if err != nil {
-		log.Println(err)
-	}
-	var users []*patient.Patient
-	err = dataUser.All(ctx, &users)
-	if err != nil {
-		log.Println(err)
-		return nil, err
-	}
-	return users, nil
-}

pkg/database/mongo/user.go

@@ -1,88 +0,0 @@
-package mongo
-
-import (
-	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"log"
-	"template_blueprint/pkg/models/user"
-	"time"
-)
-
-func (s *DatabaseService) InsertUser(req user.ReqInsertUser) error {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	_, err := s.DB.Collection("user").InsertOne(ctx, user.ReqInsertUser{
-		ID:       req.ID,
-		Name:     req.Name,
-		Age:      req.Age,
-		Address:  req.Address,
-		Gender:   req.Gender,
-		Religion: req.Religion,
-	})
-	if err != nil {
-		log.Println(err)
-		return err
-	}
-	return nil
-}
-
-func (s *DatabaseService) GetAllDataUser() ([]*user.User, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	dataUser, err := s.DB.Collection("user").Find(ctx, bson.D{})
-	if err != nil {
-		log.Println(err)
-	}
-	var users []*user.User
-	err = dataUser.All(ctx, &users)
-	if err != nil {
-		log.Println(err)
-		return nil, err
-	}
-	return users, nil
-}
-
-func (s *DatabaseService) GetUserById(id string) (*user.User, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	dataUser := s.DB.Collection("user").FindOne(ctx, bson.D{{Key: "_id", Value: id}})
-	var user *user.User
-	err := dataUser.Decode(&user)
-	if err != nil {
-		log.Println(err)
-		return nil, err
-	}
-	return user, nil
-}
-
-func (s *DatabaseService) UpdateUser(reqUpdate *user.ReqUpdateUser) error {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	log.Println(reqUpdate.ID)
-	filter := bson.M{"_id": reqUpdate.ID}
-	update := bson.M{"$set": bson.M{
-		"name":     reqUpdate.Name,
-		"age":      reqUpdate.Age,
-		"address":  reqUpdate.Address,
-		"gender":   reqUpdate.Gender,
-		"religion": reqUpdate.Religion,
-	}}
-	updatedData, err := s.DB.Collection("user").UpdateOne(ctx, filter, update)
-	if err != nil {
-		log.Println(err)
-		return err
-	}
-	log.Println(updatedData)
-	return nil
-}
-
-func (s *DatabaseService) DeleteUserById(id string) error {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	_, err := s.DB.Collection("user").DeleteOne(ctx, bson.D{{Key: "_id", Value: id}})
-	if err != nil {
-		log.Println(err)
-		return err
-	}
-	return nil
-}