Clean Architecture
kita sudah pernah mempelajari clean arcitecture
kali ini kita akan menggunakan konsep domain
structure folder sebagai berikut
---- [domain]
---- [ddrivers]
---- [handler]
grpc.go
---- [repositories]
repo.go
---- [usecase]
usecase.go
otherfile.go
---- [validation]
validationfile.go
repository_interface.go
usecase_interface.go
validation_interface.goKita akan memecah file domain/ddrivers/handler.go menjadi mengikuti structur folder di atas.
Helper
untuk fungsi-fungsi pendukung akan dikelompokkan ke dalam folder lib/helper
Buat file lib/helper/error_ctx.go
package helper
import (
"context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func ContextError(ctx context.Context) error {
switch ctx.Err() {
case context.Canceled:
return status.Error(codes.Canceled, context.Canceled.Error())
case context.DeadlineExceeded:
return status.Error(codes.DeadlineExceeded, context.DeadlineExceeded.Error())
default:
return nil
}
}Repository
repository adalah kode-kode yang mengakses transaksi database
Buat file domain/ddrivers/repository_interface.go
package ddrivers
import (
"context"
"skeleton/pb/drivers"
"skeleton/pb/generic"
)
type DriverRepoInterface interface {
Find(ctx context.Context, id string) error
FindAll(ctx context.Context, in *drivers.DriverListInput) (*drivers.Drivers, error)
Create(ctx context.Context) error
Update(ctx context.Context) error
Delete(ctx context.Context, in *generic.Id) error
GetPb() *drivers.Driver
SetPb(*drivers.Driver)
}Buat folder domain/ddrivers/repositories. Semua file yang mengimplementasikan repository interface akan dibuat dalam filder ini.
Buat file domain/ddrivers/repositories/repo.go
package repositories
import (
"database/sql"
"log"
"skeleton/domain/ddrivers"
"skeleton/pb/drivers"
)
type repo struct {
db *sql.DB
log *log.Logger
pb drivers.Driver
}
func NewDriverRepo(db *sql.DB, log *log.Logger) ddrivers.DriverRepoInterface {
return &repo{
db: db,
log: log,
}
}
func (u *repo) GetPb() *drivers.Driver {
return &u.pb
}
func (u *repo) SetPb(in *drivers.Driver) {
if len(in.Id) > 0 {
u.pb.Id = in.Id
}
if len(in.Name) > 0 {
u.pb.Name = in.Name
}
if len(in.Phone) > 0 {
u.pb.Phone = in.Phone
}
if len(in.LicenceNumber) > 0 {
u.pb.LicenceNumber = in.LicenceNumber
}
if len(in.CompanyId) > 0 {
u.pb.CompanyId = in.CompanyId
}
if len(in.CompanyName) > 0 {
u.pb.CompanyName = in.CompanyName
}
u.pb.IsDelete = in.IsDelete
if len(in.Created) > 0 {
u.pb.Created = in.Created
}
if len(in.CreatedBy) > 0 {
u.pb.CreatedBy = in.CreatedBy
}
if len(in.Updated) > 0 {
u.pb.Updated = in.Updated
}
if len(in.UpdatedBy) > 0 {
u.pb.UpdatedBy = in.UpdatedBy
}
}Buat file domain/ddrivers/repositories/find_all.go
package repositories
import (
"context"
"fmt"
"skeleton/lib/helper"
"skeleton/pb/drivers"
"skeleton/pb/generic"
"strconv"
"strings"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (u *repo) FindAll(ctx context.Context, in *drivers.DriverListInput) (*drivers.Drivers, error) {
select {
case <-ctx.Done():
return nil, helper.ContextError(ctx)
default:
}
out := &drivers.Drivers{}
query := `SELECT id, name, phone, licence_number, company_id, company_name FROM drivers`
where := []string{"is_deleted = false"}
paramQueries := []interface{}{}
if len(in.Ids) > 0 {
orWhere := []string{}
for _, id := range in.Ids {
paramQueries = append(paramQueries, id)
orWhere = append(orWhere, fmt.Sprintf("id = %d", len(paramQueries)))
}
if len(orWhere) > 0 {
where = append(where, "("+strings.Join(orWhere, " OR ")+")")
}
}
if len(in.CompanyIds) > 0 {
orWhere := []string{}
for _, id := range in.CompanyIds {
paramQueries = append(paramQueries, id)
orWhere = append(orWhere, fmt.Sprintf("company_id = %d", len(paramQueries)))
}
if len(orWhere) > 0 {
where = append(where, "("+strings.Join(orWhere, " OR ")+")")
}
}
if len(in.LicenceNumbers) > 0 {
orWhere := []string{}
for _, licenceNumber := range in.LicenceNumbers {
paramQueries = append(paramQueries, licenceNumber)
orWhere = append(orWhere, fmt.Sprintf("licence_number = %d", len(paramQueries)))
}
if len(orWhere) > 0 {
where = append(where, "("+strings.Join(orWhere, " OR ")+")")
}
}
if len(in.Names) > 0 {
orWhere := []string{}
for _, name := range in.Names {
paramQueries = append(paramQueries, name)
orWhere = append(orWhere, fmt.Sprintf("name = %d", len(paramQueries)))
}
if len(orWhere) > 0 {
where = append(where, "("+strings.Join(orWhere, " OR ")+")")
}
}
if len(in.Phones) > 0 {
orWhere := []string{}
for _, phone := range in.Phones {
paramQueries = append(paramQueries, phone)
orWhere = append(orWhere, fmt.Sprintf("phone = %d", len(paramQueries)))
}
if len(orWhere) > 0 {
where = append(where, "("+strings.Join(orWhere, " OR ")+")")
}
}
if in.Pagination == nil {
in.Pagination = &generic.Pagination{}
}
if len(in.Pagination.Keyword) > 0 {
orWhere := []string{}
paramQueries = append(paramQueries, in.Pagination.Keyword)
orWhere = append(orWhere, fmt.Sprintf("name = %d", len(paramQueries)))
paramQueries = append(paramQueries, in.Pagination.Keyword)
orWhere = append(orWhere, fmt.Sprintf("phone = %d", len(paramQueries)))
paramQueries = append(paramQueries, in.Pagination.Keyword)
orWhere = append(orWhere, fmt.Sprintf("licence_number = %d", len(paramQueries)))
paramQueries = append(paramQueries, in.Pagination.Keyword)
orWhere = append(orWhere, fmt.Sprintf("company_name = %d", len(paramQueries)))
if len(orWhere) > 0 {
where = append(where, "("+strings.Join(orWhere, " OR ")+")")
}
}
if len(in.Pagination.Sort) > 0 {
in.Pagination.Sort = strings.ToLower(in.Pagination.Sort)
if in.Pagination.Sort != "asc" {
in.Pagination.Sort = "desc"
}
} else {
in.Pagination.Sort = "desc"
}
if len(in.Pagination.Order) > 0 {
in.Pagination.Order = strings.ToLower(in.Pagination.Order)
if !(in.Pagination.Order == "id" ||
in.Pagination.Order == "name" ||
in.Pagination.Order == "phone" ||
in.Pagination.Order == "licence_number" ||
in.Pagination.Order == "company_id" ||
in.Pagination.Order == "company_name") {
in.Pagination.Order = "id"
}
} else {
in.Pagination.Order = "id"
}
if in.Pagination.Limit <= 0 {
in.Pagination.Limit = 10
}
if in.Pagination.Offset <= 0 {
in.Pagination.Offset = 0
}
if len(where) > 0 {
query += " WHERE " + strings.Join(where, " AND ")
}
query += " ORDER BY " + in.Pagination.Order + " " + in.Pagination.Sort
query += " LIMIT " + strconv.Itoa(int(in.Pagination.Limit))
query += " OFFSET " + strconv.Itoa(int(in.Pagination.Offset))
rows, err := u.db.QueryContext(ctx, query, paramQueries...)
if err != nil {
u.log.Println(err.Error())
return nil, status.Error(codes.Internal, err.Error())
}
defer rows.Close()
for rows.Next() {
var obj drivers.Driver
err = rows.Scan(&obj.Id, &obj.Name, &obj.Phone, &obj.LicenceNumber, &obj.CompanyId, &obj.CompanyName)
if err != nil {
u.log.Println(err.Error())
return nil, status.Error(codes.Internal, err.Error())
}
out.Driver = append(out.Driver, &obj)
}
if rows.Err() != nil {
u.log.Println(rows.Err().Error())
return nil, status.Error(codes.Internal, rows.Err().Error())
}
return out, nil
}Buat file domain/ddrivers/repositories/find_driver_by_id.go
package repositories
import (
"context"
"skeleton/lib/helper"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (u *repo) Find(ctx context.Context, id string) error {
select {
case <-ctx.Done():
return helper.ContextError(ctx)
default:
}
query := `
SELECT id, name, phone, licence_number, company_id, company_name
FROM drivers WHERE id = $1 AND is_deleted = false
`
err := u.db.QueryRowContext(ctx, query, id).Scan(
&u.pb.Id, &u.pb.Name, &u.pb.LicenceNumber, &u.pb.CompanyId, &u.pb.CompanyName)
if err != nil {
u.log.Println(err.Error())
return status.Error(codes.Internal, err.Error())
}
return nil
}Buat file domain/ddrivers/repositories/create_driver.go
package repositories
import (
"context"
"skeleton/lib/helper"
"time"
"github.com/google/uuid"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (u *repo) Create(ctx context.Context) error {
select {
case <-ctx.Done():
return helper.ContextError(ctx)
default:
}
query := `
INSERT INTO drivers (
id, name, phone, licence_number, company_id, company_name, created, created_by, updated, updated_by)
VALUES ($1, $2, $3 ,$4, $5, $6, $7, $8, $9, $10)
`
u.pb.Id = uuid.New().String()
now := time.Now().Format("2006-01-02 15:04:05.000000")
_, err := u.db.ExecContext(ctx, query,
u.pb.Id, u.pb.Name, u.pb.Phone, u.pb.LicenceNumber, u.pb.CompanyId, u.pb.CompanyName,
now, u.pb.CreatedBy, now, u.pb.UpdatedBy)
if err != nil {
u.log.Println(err.Error())
return status.Error(codes.Internal, err.Error())
}
return nil
}Buat file domain/ddrivers/repositories/update_driver_by_id.go
package repositories
import (
"context"
"skeleton/lib/helper"
"time"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (u *repo) Update(ctx context.Context) error {
select {
case <-ctx.Done():
return helper.ContextError(ctx)
default:
}
query := `
UPDATE drivers
SET name = $1,
phone = $2,
licence_number = $3,
updated = $4,
updated_by = $5
WHERE id = $6
`
now := time.Now().Format("2006-01-02 15:04:05.000000")
_, err := u.db.ExecContext(ctx, query,
u.pb.Name, u.pb.Phone, u.pb.LicenceNumber, now, u.pb.UpdatedBy, u.pb.Id)
if err != nil {
u.log.Println(err.Error())
return status.Error(codes.Internal, err.Error())
}
return nil
}Buat file domain/ddrivers/repositories/delete_driver_by_id.go
package repositories
import (
"context"
"skeleton/lib/helper"
"skeleton/pb/generic"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (u *repo) Delete(ctx context.Context, in *generic.Id) error {
select {
case <-ctx.Done():
return helper.ContextError(ctx)
default:
}
query := `
UPDATE drivers
SET is_deleted = true
WHERE id = $1
`
_, err := u.db.ExecContext(ctx, query, in.Id)
if err != nil {
u.log.Println(err.Error())
return status.Error(codes.Internal, err.Error())
}
return nil
}Validation
Setiap request perlu divalidasi
Buat file domain/ddrivers/validation_interface.go
package ddrivers
import (
"context"
"skeleton/pb/drivers"
)
type DriverValidationInterface interface {
Create(ctx context.Context, id *drivers.Driver) error
Update(ctx context.Context, id *drivers.Driver) error
Delete(ctx context.Context, id string) error
}Untuk kemudahan pengelolaan kode, semua implementasi validasi akan dimasukkan dalam folder domain/drivers/validation
Buat file domain/ddrivers/validation/driover_validation.go
package validation
import (
"log"
"skeleton/domain/ddrivers"
)
type driverValidation struct {
log *log.Logger
driverRepo ddrivers.DriverRepoInterface
}
func NewValidation(log *log.Logger, driverRepo ddrivers.DriverRepoInterface) ddrivers.DriverValidationInterface {
return &driverValidation{
log: log,
driverRepo: driverRepo,
}
}Buat file domain/ddrivers/validation/create_driver_validation.go
package validation
import (
"context"
"skeleton/lib/helper"
"skeleton/pb/drivers"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (u *driverValidation) Create(ctx context.Context, in *drivers.Driver) error {
select {
case <-ctx.Done():
return helper.ContextError(ctx)
default:
}
if len(in.Name) == 0 {
u.log.Println("please supply valid name")
return status.Error(codes.InvalidArgument, "please supply valid name")
}
if len(in.Phone) == 0 {
u.log.Println("please supply valid phone")
return status.Error(codes.InvalidArgument, "please supply valid phone")
}
if len(in.CompanyId) == 0 {
u.log.Println("please supply valid company id")
return status.Error(codes.InvalidArgument, "please supply valid company id")
}
if len(in.CompanyName) == 0 {
u.log.Println("please supply valid company name")
return status.Error(codes.InvalidArgument, "please supply valid company name")
}
if len(in.LicenceNumber) == 0 {
u.log.Println("please supply valid licence number")
return status.Error(codes.InvalidArgument, "please supply valid licence number")
}
return nil
}Buat file domain/ddrivers/validation/update_driver_validation.go
package validation
import (
"context"
"skeleton/lib/helper"
"skeleton/pb/drivers"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (u *driverValidation) Create(ctx context.Context, in *drivers.Driver) error {
select {
case <-ctx.Done():
return helper.ContextError(ctx)
default:
}
if len(in.Name) == 0 {
u.log.Println("please supply valid name")
return status.Error(codes.InvalidArgument, "please supply valid name")
}
if len(in.Phone) == 0 {
u.log.Println("please supply valid phone")
return status.Error(codes.InvalidArgument, "please supply valid phone")
}
if len(in.CompanyId) == 0 {
u.log.Println("please supply valid company id")
return status.Error(codes.InvalidArgument, "please supply valid company id")
}
if len(in.CompanyName) == 0 {
u.log.Println("please supply valid company name")
return status.Error(codes.InvalidArgument, "please supply valid company name")
}
if len(in.LicenceNumber) == 0 {
u.log.Println("please supply valid licence number")
return status.Error(codes.InvalidArgument, "please supply valid licence number")
}
return nil
}Buat file domain/ddrivers/validation/delete_driver/validation.fo
package validation
import (
"context"
"skeleton/lib/helper"
)
func (u *driverValidation) Delete(ctx context.Context, id string) error {
select {
case <-ctx.Done():
return helper.ContextError(ctx)
default:
}
err := u.driverRepo.Find(ctx, id)
if err != nil {
return err
}
return nil
}Usecase
usacase digunakan untuk menghandle logic. usecase yang akan memanggil validation maupun repository sekiranya logic membutuhkan hal tersebut.
Buat file usecase_interface.go
package ddrivers
import (
"context"
"skeleton/pb/drivers"
"skeleton/pb/generic"
)
type DriverUsecaseInterface interface {
List(ctx context.Context, in *drivers.DriverListInput) (*drivers.Drivers, error)
Create(ctx context.Context, in *drivers.Driver) (*drivers.Driver, error)
Update(ctx context.Context, in *drivers.Driver) (*drivers.Driver, error)
Delete(ctx context.Context, in *generic.Id) (*generic.BoolMessage, error)
}Buat folder usecase untuk menyimpan seluruh fiule implementasi usecase interface.
Buat file domain/ddrivers/usecase/usecase.go
package usecase
import (
"log"
"skeleton/domain/ddrivers"
)
type service struct {
log *log.Logger
driverRepo ddrivers.DriverRepoInterface
}
func NewService(log *log.Logger, driverRepo ddrivers.DriverRepoInterface) ddrivers.DriverUsecaseInterface {
return &service{
log: log,
driverRepo: driverRepo,
}
}Buat file domain/ddrivers/usecase/create_driver_usecase.go
package usecase
import (
"context"
"skeleton/domain/ddrivers/validation"
"skeleton/lib/helper"
"skeleton/pb/drivers"
)
func (u *service) Create(ctx context.Context, in *drivers.Driver) (*drivers.Driver, error) {
select {
case <-ctx.Done():
return nil, helper.ContextError(ctx)
default:
}
dValidation := validation.NewValidation(u.log, u.driverRepo)
err := dValidation.Create(ctx, in)
if err != nil {
return nil, err
}
u.driverRepo.SetPb(in)
err = u.driverRepo.Create(ctx)
if err != nil {
return nil, err
}
return u.driverRepo.GetPb(), nil
}Buat file domain/ddrivers/usecase/list_driver_usecase.go
package usecase
import (
"context"
"skeleton/lib/helper"
"skeleton/pb/drivers"
)
func (u *service) List(ctx context.Context, in *drivers.DriverListInput) (*drivers.Drivers, error) {
select {
case <-ctx.Done():
return nil, helper.ContextError(ctx)
default:
}
return u.driverRepo.FindAll(ctx, in)
}Buat file domain/ddrivers/usecase/update_driver_usecase.go
package usecase
import (
"context"
"skeleton/domain/ddrivers/validation"
"skeleton/lib/helper"
"skeleton/pb/drivers"
)
func (u *service) Update(ctx context.Context, in *drivers.Driver) (*drivers.Driver, error) {
select {
case <-ctx.Done():
return nil, helper.ContextError(ctx)
default:
}
dValidation := validation.NewValidation(u.log, u.driverRepo)
err := dValidation.Update(ctx, in)
if err != nil {
return nil, err
}
u.driverRepo.SetPb(in)
err = u.driverRepo.Update(ctx)
if err != nil {
return nil, err
}
return u.driverRepo.GetPb(), nil
}Buat file domain.ddrivers/usecase/delete_driver_usecase.go
package usecase
import (
"context"
"skeleton/domain/ddrivers/validation"
"skeleton/lib/helper"
"skeleton/pb/generic"
)
func (u *service) Delete(ctx context.Context, in *generic.Id) (*generic.BoolMessage, error) {
select {
case <-ctx.Done():
return nil, helper.ContextError(ctx)
default:
}
dValidation := validation.NewValidation(u.log, u.driverRepo)
err := dValidation.Delete(ctx, in.Id)
if err != nil {
return nil, err
}
err = u.driverRepo.Delete(ctx, in)
if err != nil {
return nil, err
}
return &generic.BoolMessage{IsTrue: true}, nil
}Perbarui Handler
handler merupakan endpoint service.
handler mengimpolementasikan seluruh seluruh funhgsi dari interface DomainServiceServer
Buat file domain/ddrivers/handler/grpc.go
package handler
import (
"context"
"skeleton/domain/ddrivers"
"skeleton/pb/drivers"
"skeleton/pb/generic"
)
type DriverHandler struct {
usecase ddrivers.DriverUsecaseInterface
}
func NewDriverHandler(usecase ddrivers.DriverUsecaseInterface) *DriverHandler {
handler := new(DriverHandler)
handler.usecase = usecase
return handler
}
func (u *DriverHandler) List(ctx context.Context, in *drivers.DriverListInput) (*drivers.Drivers, error) {
return u.usecase.List(ctx, in)
}
func (u *DriverHandler) Create(ctx context.Context, in *drivers.Driver) (*drivers.Driver, error) {
return u.usecase.Create(ctx, in)
}
func (u *DriverHandler) Update(ctx context.Context, in *drivers.Driver) (*drivers.Driver, error) {
return u.usecase.Update(ctx, in)
}
func (u *DriverHandler) Delete(ctx context.Context, in *generic.Id) (*generic.BoolMessage, error) {
return u.usecase.Delete(ctx, in)
}Perbarui Routing
Ubah file route/route.go
package route
import (
"database/sql"
"log"
driverHandler "skeleton/domain/ddrivers/handler"
driverRepo "skeleton/domain/ddrivers/repositories"
driverUsecase "skeleton/domain/ddrivers/usecase"
"skeleton/pb/drivers"
"google.golang.org/grpc"
)
func GrpcRoute(grpcServer *grpc.Server, log *log.Logger, db *sql.DB) {
driverServer := driverHandler.NewDriverHandler(
driverUsecase.NewService(log, driverRepo.NewDriverRepo(db, log)),
)
drivers.RegisterDriversServiceServer(grpcServer, driverServer)
}Last updated