api-poliklinik/pkg/database/mongo/patient.go

package mongo

import (
	patient "api-poliklinik/pkg/models/mongo/insertpatient"
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"time"
)

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

	filter := bson.M{"_id": "RekamMedik"}
	update := bson.M{"$inc": bson.M{"seq": 1}}
	opts := options.FindOneAndUpdate().SetUpsert(true).SetReturnDocument(options.After)

	var result struct {
		Seq int `bson:"seq"`
	}

	err := s.DBMongo.Collection("counters").FindOneAndUpdate(ctx, filter, update, opts).Decode(&result)
	if err != nil {
		log.Println("Error generating rekamedik number:", err)
		return "", err
	}

	// Format nomor menjadi 7 digit, misalnya "0002032"
	return fmt.Sprintf("%012d", result.Seq), nil
}

func (s *DatabaseService) InsertPatient(req patient.Patient) error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	_, err := s.DBMongo.Collection("patient").InsertOne(ctx, req)
	if err != nil {
		log.Println(err)
		return err
	}
	return nil
}

func (s *DatabaseService) InsertPatientmongo(req *patient.Patient) error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Jika ID belum diinisialisasi, set ID baru
	if req.ID.IsZero() {
		req.ID = primitive.NewObjectID()
	}

	result, err := s.DBMongo.Collection("patient").InsertOne(ctx, req)
	if err != nil {
		log.Println(err)
		return err
	}

	// Mengambil ID yang dihasilkan dan memasukkannya kembali ke struct
	if oid, ok := result.InsertedID.(primitive.ObjectID); ok {
		req.ID = oid
	}

	return nil
}

func (s *DatabaseService) GetPatientByIdentifier(display string, value string) ([]*patient.Patient, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	filter := bson.M{
		"identifier": bson.M{
			"$elemMatch": bson.M{
				"type.coding.display": display,
				"value":               value,
			},
		},
	}

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

//filter := bson.M{
//"identifier": bson.M{
//"$elemMatch": bson.M{
//"type.coding.display": display,
//"value":               value,
//},
//},
//}

func (s *DatabaseService) GetAllDataPatient(limit int64, skip int64) ([]*patient.Patient, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	findOptions := options.Find()
	findOptions.SetLimit(limit)
	findOptions.SetSkip(skip)
	findOptions.SetSort(bson.D{{"_id", -1}})

	filter := bson.M{
		"active": true,
	}
	dataUser, err := s.DBMongo.Collection("patient").Find(ctx, filter, findOptions)
	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
}

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

	// Konversi id menjadi ObjectID
	objectID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		log.Println(err)
		return err
	}

	req.ID = "" // Kosongkan ID agar tidak ikut terupdate

	filter := bson.M{"_id": objectID}

	update := bson.M{
		"$set": req,
	}

	_, err = s.DBMongo.Collection("patient").UpdateOne(ctx, filter, update)
	if err != nil {
		log.Println(err)
		return err
	}

	return nil
}

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

	// Konversi id menjadi ObjectID
	objectID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		log.Println(err)
		return err
	}

	req.ID = "" // Kosongkan ID agar tidak ikut terupdate

	filter := bson.M{"_id": objectID}

	update := bson.M{
		"$set": bson.M{
			"active": req.Active,
		},
	}

	_, err = s.DBMongo.Collection("patient").UpdateOne(ctx, filter, update)
	if err != nil {
		log.Println(err)
		return err
	}

	return nil
}

func (s *DatabaseService) GetPasienByid(id string) ([]*patient.Patient, 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("patient").Find(ctx, filter)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	defer cursor.Close(ctx)
	var results []*patient.Patient
	if err = cursor.All(ctx, &results); err != nil {
		log.Println(err)
		return nil, err
	}
	return results, nil
}