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

package mongo

import (
	patient "api-poliklinik/pkg/models/mongo/insertpatient"
	"api-poliklinik/pkg/models/mongo/person"
	relatedperson "api-poliklinik/pkg/models/mongo/relatedperson"
	_struct "api-poliklinik/pkg/models/struct"

	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
	"strings"
	"time"
)

func addRekamMedikIdentifier(identifierList *[]_struct.Identifier, rekamMedikNumber string) {
	identifier := _struct.Identifier{
		Use: "usual",
		Type: _struct.CodeableConcept{
			Coding: []_struct.Coding{
				{
					Code:         "RM",
					Display:      "RekamMedik",
					UserSelected: true,
				},
			},
			Text: "RM",
		},
		Value: rekamMedikNumber,
		Period: _struct.Period{
			Start: time.Now().Format("2006-01-02"),
		},
		Assigner: _struct.Reference{},
	}
	*identifierList = append(*identifierList, identifier)
}

func (s *DatabaseService) GetAllDataPatientWithRelated(limit int64, skip int64) ([]*relatedperson.Getrelatedperson, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	findOptions := options.Find()
	findOptions.SetLimit(limit)
	findOptions.SetSkip(skip)

	cursor, err := s.DBMongo.Collection("patientbaru").Find(ctx, bson.D{}, findOptions)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	defer cursor.Close(ctx)

	var patients []*patient.Patient
	if err := cursor.All(ctx, &patients); err != nil {
		log.Println(err)
		return nil, err
	}

	var results []*relatedperson.Getrelatedperson
	for _, patientData := range patients {
		dataGabungan := &relatedperson.Getrelatedperson{
			Patient: *patientData,
		}

		if len(patientData.Link) > 0 {
			refStr := patientData.Link[0].Other.Reference
			idStr := strings.TrimPrefix(refStr, "RelatedPerson/")
			if objectID, err := primitive.ObjectIDFromHex(idStr); err == nil {
				var relatedPerson relatedperson.RelatedPerson
				err := s.DBMongo.Collection("relatedperson").FindOne(ctx, bson.M{"_id": objectID}).Decode(&relatedPerson)
				if err == nil {
					dataGabungan.RelatedPerson = relatedPerson
				}
			}
		}

		results = append(results, dataGabungan)
	}

	return results, nil
}

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

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

	oid, ok := result.InsertedID.(primitive.ObjectID)
	if !ok {
		return primitive.NilObjectID, fmt.Errorf("Failed to assert insertedID to ObjectID")
	}

	return oid, nil
}

func (s *DatabaseService) UpdateIDpatient(id primitive.ObjectID, related patient.Patient) error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	filter := bson.M{"_id": id}
	update := bson.M{"$set": related}
	_, err := s.DBMongo.Collection("patientbaru").UpdateOne(ctx, filter, update)
	return err
}

/* PUNYA RELATED PERSON */
func (s *DatabaseService) CreateRelatedperson(req relatedperson.RelatedPerson) (primitive.ObjectID, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

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

	oid, ok := result.InsertedID.(primitive.ObjectID)
	if !ok {
		return primitive.NilObjectID, fmt.Errorf("Failed to assert insertedID to ObjectID")
	}

	return oid, nil
}

func (s *DatabaseService) UpdateIDrelated(id primitive.ObjectID, related relatedperson.RelatedPerson) error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	filter := bson.M{"_id": id}
	update := bson.M{"$set": related}
	_, err := s.DBMongo.Collection("relatedperson").UpdateOne(ctx, filter, update)
	return err
}

/* PUNYA PERSON */
func (s *DatabaseService) InsertPERSON(req person.Person) (primitive.ObjectID, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

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

	oid, ok := result.InsertedID.(primitive.ObjectID)
	if !ok {
		return primitive.NilObjectID, fmt.Errorf("Failed to assert insertedID to ObjectID")
	}

	return oid, nil
}

func (s *DatabaseService) UpdateIDperson(id primitive.ObjectID, related person.Person) error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	filter := bson.M{"_id": id}
	update := bson.M{"$set": related}
	_, err := s.DBMongo.Collection("person").UpdateOne(ctx, filter, update)
	return err
}