init project

pkg/database/mongo/database.go

@@ -0,0 +1,13 @@
+package mongo
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+type DatabaseService struct {
+	DB *mongo.Database
+}
+
+func NewDatabaseService(db *mongo.Database) *DatabaseService {
+	return &DatabaseService{DB: db}
+}

pkg/database/mongo/master_data.go

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,44 @@
+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, patient.Patient{
+		ID:        req.ID,
+		NoRM:      req.NoRM,
+		Name:      req.Name,
+		Telecom:   req.Telecom,
+		Gender:    req.Gender,
+		BirthDate: req.BirthDate,
+		Address:   req.Address,
+	})
+	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

@@ -0,0 +1,88 @@
+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
+}

pkg/handlers/master_data/master_data.go

@@ -0,0 +1,33 @@
+package master_data
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"net/http"
+	"os"
+	"template_blueprint/internal/database"
+	"template_blueprint/pkg/database/mongo"
+	"template_blueprint/pkg/models/master_data"
+)
+
+func InsertDataMaster(c *gin.Context) {
+	master := os.Getenv("BLUEPRINT_DB_MASTER")
+	var ReqInsertData master_data.ReqInsertData
+	errBind := c.Bind(&ReqInsertData)
+	if errBind != nil {
+		c.JSON(400, gin.H{
+			"code": 400,
+		})
+	}
+	db := database.New(master).GetDB()
+	mongoDB := mongo.NewDatabaseService(db)
+	ReqInsertData.ID = uuid.New().String()
+	errInsert := mongoDB.InsertDataMaster(ReqInsertData)
+	if errInsert != nil {
+		c.JSON(400, gin.H{
+			"message": "Failed Insert User",
+		})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Successfully Inserted User"})
+}

pkg/handlers/mongo/mongo.go

@@ -0,0 +1,42 @@
+package mongo
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+	"go.mongodb.org/mongo-driver/bson"
+	"log"
+	"net/http"
+	"os"
+	"template_blueprint/internal/database"
+	"template_blueprint/pkg/database/mongo"
+	"template_blueprint/pkg/models/local"
+	"time"
+)
+
+func GetDataLog(c *gin.Context) {
+	locals := os.Getenv("BLUEPRINT_DB_LOCAL")
+	db := database.New(locals).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	mongoDB := mongo.NewDatabaseService(db)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	cursor, err := mongoDB.DB.Collection("startup_log").Find(ctx, bson.M{})
+	if err != nil {
+		log.Println(err)
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database query failed"})
+		return
+	}
+
+	var dataLog []*local.StartUpLog
+	errDecode := cursor.All(ctx, &dataLog)
+	if errDecode != nil {
+		log.Println(errDecode)
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database query failed"})
+		return
+	}
+	c.JSON(http.StatusOK, dataLog)
+}

pkg/handlers/patient/patient.go

@@ -0,0 +1,50 @@
+package patient
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"net/http"
+	"os"
+	"template_blueprint/internal/database"
+	"template_blueprint/pkg/database/mongo"
+	"template_blueprint/pkg/models/patient"
+)
+
+func InsertPatient(c *gin.Context) {
+	local := os.Getenv("MONGODB_DEV_LOCAL")
+	db := database.New(local).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	mongoDB := mongo.NewDatabaseService(db)
+	var reqInsert *patient.Patient
+	err := c.Bind(&reqInsert)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": err.Error()})
+		return
+	}
+	reqInsert.ID = uuid.New().String()
+	errInsert := mongoDB.InsertPatient(reqInsert)
+	if errInsert != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": errInsert.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Patient successfully inserted"})
+}
+
+func GetAllPatient(c *gin.Context) {
+	local := os.Getenv("MONGODB_DEV_LOCAL")
+	db := database.New(local).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	mongoDB := mongo.NewDatabaseService(db)
+	dataPatient, errSelect := mongoDB.GetAllDataPatient()
+	if errSelect != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": errSelect.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, dataPatient)
+}

pkg/handlers/user/user.go

@@ -0,0 +1,168 @@
+package user
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"log"
+	"net/http"
+	"os"
+	"template_blueprint/internal/database"
+	"template_blueprint/pkg/database/mongo"
+	"template_blueprint/pkg/models/user"
+)
+
+// InsertUser godoc
+// @Summary Insert a new user
+// @Description Adds a new user to the database
+// @Tags users
+// @Accept json
+// @Produce json
+// @Param request body user.ReqInsertUser true "User Data"
+// @Success 200 {object} map[string]string "Successfully Inserted User"
+// @Failure 400 {object} map[string]string "Bad Request"
+// @Failure 500 {object} map[string]string "Database connection failed"
+// @Router /api/localinsertuser [post]
+func InsertUser(c *gin.Context) {
+	local := os.Getenv("BLUEPRINT_DB_LOCAL")
+	db := database.New(local).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	mongoDB := mongo.NewDatabaseService(db)
+	var reqInsert user.ReqInsertUser
+
+	errBind := c.Bind(&reqInsert)
+	if errBind != nil {
+		c.JSON(400, gin.H{
+			"message": errBind.Error(),
+		})
+		return
+	}
+	id := uuid.New().String()
+	reqInsert.ID = id
+	errInsert := mongoDB.InsertUser(reqInsert)
+	if errInsert != nil {
+		c.JSON(400, gin.H{
+			"message": errInsert.Error(),
+		})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Successfully Inserted User"})
+}
+
+// GetAllUser godoc
+// @Summary Get all users
+// @Description Retrieves all users from the database
+// @Tags users
+// @Produce json
+// @Success 200 {array} user.User "List of users"
+// @Failure 500 {object} map[string]string "Database connection failed"
+// @Router /api/local/getalluser [get]
+func GetAllUser(c *gin.Context) {
+	local := os.Getenv("BLUEPRINT_DB_LOCAL")
+	db := database.New(local).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	mongoDB := mongo.NewDatabaseService(db)
+	dataUser, errSelect := mongoDB.GetAllDataUser()
+	if errSelect != nil {
+		c.JSON(400, gin.H{
+			"message": errSelect.Error(),
+		})
+		return
+	}
+	c.JSON(http.StatusOK, dataUser)
+}
+
+// GetUserByID godoc
+// @Summary Get user by ID
+// @Description Retrieves a user by their ID
+// @Tags users
+// @Produce json
+// @Param id path string true "User ID"
+// @Success 200 {object} user.User "User data"
+// @Failure 400 {object} map[string]string "Bad Request"
+// @Router /api/local/getuser/{id} [get]
+func GetUserByID(c *gin.Context) {
+	local := os.Getenv("BLUEPRINT_DB_LOCAL")
+	db := database.New(local).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	id := c.Param("id")
+	log.Println("ID", id)
+	mongoDB := mongo.NewDatabaseService(db)
+	dataUser, errSelect := mongoDB.GetUserById(id)
+	if errSelect != nil {
+		c.JSON(400, gin.H{
+			"message": errSelect.Error(),
+		})
+		return
+	}
+	c.JSON(http.StatusOK, dataUser)
+}
+
+// UpdateUser godoc
+// @Summary Update a user
+// @Description Updates user information
+// @Tags users
+// @Accept json
+// @Produce json
+// @Param request body user.User true "User Data"
+// @Success 200 {object} map[string]string "Successfully Updated User"
+// @Failure 400 {object} map[string]string "Bad Request"
+// @Failure 500 {object} map[string]string "Database connection failed"
+// @Router /users [put]
+func UpdateUser(c *gin.Context) {
+	local := os.Getenv("BLUEPRINT_DB_LOCAL")
+	db := database.New(local).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	mongoDB := mongo.NewDatabaseService(db)
+	var reqUpdate *user.ReqUpdateUser
+	errBind := c.Bind(&reqUpdate)
+	if errBind != nil {
+		c.JSON(400, gin.H{
+			"message": errBind.Error(),
+		})
+		return
+	}
+	log.Println("REQ UPDATE", reqUpdate)
+	errUpdate := mongoDB.UpdateUser(reqUpdate)
+	if errUpdate != nil {
+		c.JSON(400, gin.H{
+			"message": errUpdate.Error(),
+		})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Successfully Updated User"})
+}
+
+func DeleteUser(c *gin.Context) {
+	local := os.Getenv("BLUEPRINT_DB_LOCAL")
+	db := database.New(local).GetDB()
+	if db == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "Database connection failed"})
+		return
+	}
+	mongoDB := mongo.NewDatabaseService(db)
+	var reqDelete *user.ReqDeleteUser
+	errBind := c.Bind(&reqDelete)
+	if errBind != nil {
+		c.JSON(400, gin.H{})
+		return
+	}
+	log.Println("REQ DELETE", reqDelete)
+	errDelete := mongoDB.DeleteUserById(reqDelete.ID)
+	if errDelete != nil {
+		c.JSON(400, gin.H{"message": "Failed to Delete User"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Successfully Deleted User"})
+}

pkg/models/local/local.go

@@ -0,0 +1,72 @@
+package local
+
+type StartUpLog struct {
+	ID             string    `bson:"_id"`
+	HostName       string    `bson:"hostname"`
+	StartTime      string    `bson:"start_time"`
+	StartTimeLocal string    `bson:"start_time_local"`
+	CmdLine        CmdLine   `bson:"cmdline"`
+	Pid            int       `bson:"pid"`
+	BuildInfo      BuildInfo `bson:"buildinfo"`
+}
+
+type CmdLine struct {
+	Net               Net               `bson:"net"`
+	ProcessManagement ProcessManagement `bson:"processManagement"`
+	SystemLog         SystemLog         `bson:"systemLog"`
+}
+
+type Net struct {
+	BindIP string `bson:"bindIp"`
+	Port   int    `bson:"port"`
+	Tls    TLS    `bson:"tls"`
+}
+
+type TLS struct {
+	Mode string `bson:"mode"`
+}
+
+type ProcessManagement struct {
+	Fork        bool   `bson:"fork"`
+	PidFilePath string `bson:"pidFilePath"`
+}
+
+type SystemLog struct {
+	Destination string `bson:"destination"`
+	LogAppend   bool   `bson:"logAppend"`
+	Path        string `bson:"path"`
+}
+
+type BuildInfo struct {
+	Version           string           `bson:"version"`
+	GitVersion        string           `bson:"gitVersion"`
+	Modules           []string         `bson:"modules"`
+	Allocator         string           `bson:"allocator"`
+	JavaScriptEngine  string           `bson:"javaScriptEngine"`
+	SysInfo           string           `bson:"sysInfo"`
+	VersionArray      []int            `bson:"versionArray"`
+	OpenSSL           OpenSSL          `bson:"openssl"`
+	BuildEnvironment  BuildEnvironment `bson:"buildEnvironment"`
+	Bits              int              `bson:"bits"`
+	Debug             bool             `bson:"debug"`
+	MaxBsonObjectSize int              `bson:"maxBsonObjectSize"`
+	StorageEngines    []string         `bson:"storageEngines"`
+}
+
+type OpenSSL struct {
+	Running  string `bson:"running"`
+	Compiled string `bson:"compiled"`
+}
+
+type BuildEnvironment struct {
+	DistMod    string `bson:"distmod"`
+	Distarch   string `bson:"distarch"`
+	CC         string `bson:"cc"`
+	CCFlags    string `bson:"ccflags"`
+	CXX        string `bson:"cxx"`
+	CXXFlags   string `bson:"cxxflags"`
+	LinkFlags  string `bson:"linkflags"`
+	TargetArch string `bson:"target_arch"`
+	TargetOS   string `bson:"target_os"`
+	CPPDefines string `bson:"cppdefines"`
+}

pkg/models/master_data/master_data.go

@@ -0,0 +1,16 @@
+package master_data
+
+type ReqInsertData struct {
+	ID      string `bson:"_id"`
+	Table   string `bson:"table"`
+	System  string `bson:"system"`
+	Code    string `bson:"code"`
+	Display string `bson:"display"`
+}
+
+type ReqInsertDataMaster struct {
+	ID      string `bson:"_id"`
+	System  string `bson:"system"`
+	Code    string `bson:"code"`
+	Display string `bson:"display"`
+}

pkg/models/patient/patient.go

@@ -0,0 +1,11 @@
+package patient
+
+type Patient struct {
+	ID        string `bson:"_id"`
+	NoRM      string `bson:"norm"`
+	Name      string `bson:"name"`
+	Telecom   string `bson:"telecom"`
+	Gender    string `bson:"gender"`
+	BirthDate string `bson:"birthDate"`
+	Address   string `bson:"address"`
+}

pkg/models/user/user.go

@@ -0,0 +1,33 @@
+package user
+
+type User struct {
+	ID       string `bson:"_id"`
+	Name     string `bson:"name"`
+	Age      int    `bson:"age"`
+	Address  string `bson:"address"`
+	Gender   string `bson:"gender"`
+	Religion string `bson:"religion"`
+}
+
+type ReqInsertUser struct {
+	ID       string `bson:"_id"`
+	Name     string `bson:"name"`
+	Age      int    `bson:"age"`
+	Address  string `bson:"address"`
+	Gender   string `bson:"gender"`
+	Religion string `bson:"religion"`
+}
+
+// USING INSERT AND UPDATE
+type ReqUpdateUser struct {
+	ID       string `json:"_id"`
+	Name     string `json:"name"`
+	Age      int    `json:"age"`
+	Address  string `json:"address"`
+	Gender   string `json:"gender"`
+	Religion string `json:"religion"`
+}
+
+type ReqDeleteUser struct {
+	ID string `json:"_id"`
+}