.
├── api            # Proto files and the generated *pb.go directory
├── assets         # Directory of other assets used with the repository (images, logos, etc.)
├── build          # Package and continuous integration directory
├── cmd            # Program entry directory
├── configs        # Directory for configuration files
├── deployments    # Configuration and template directories for IaaS, PaaS, system and container orchestrated deployments
├─ docs            # Design documentation and interface documentation directory
├── internal       # The code directory for private applications and libraries
│ ├── cache        # Business wrapper based cache directory
│ ├── config       # The configuration file directory for the Go structure
│ ├── dao          # Data access directory
│ ├── ecode        # Custom business error code directory
│ ├── handler      # Http's business function implementation directory
│ ├── model        # Database model directory
│ ├── routers      # Http routing directory
│ ├── rpcclient    # The client directory to connect to the rpc service
│ ├── server       # Service entry, including http, rpc, etc.
│ ├── service      # Rpc's business function implementation directory
│ └── types        # Directory of request and response types for http
├── pkg            # The directory of libraries that external applications can use
├── scripts        # A directory of scripts for performing various build, installation, analysis, etc. operations
├── test           # Additional external test procedures and test data
└── third_party    # External helpers, forked code, and other third-party tools

# linux environment
sponge tools

# windows environment, need to specify bash.exe location
sponge tools --executor="D:\Program Files\cmder\vendor\git-for-windows\bin\bash.exe"

Installed dependency tools:
    ✔  go
    ✔  protoc
    ✔  protoc-gen-go
    ✔  protoc-gen-go-grpc
    ✔  protoc-gen-validate
    ✔  protoc-gen-gotag
    ✔  protoc-gen-go-gin
    ✔  protoc-gen-go-rpc-tmpl
    ✔  protoc-gen-openapiv2
    ✔  protoc-gen-doc
    ✔  swag
    ✔  golangci-lint
    ✔  go-callvis

CREATE DATABASE IF NOT EXISTS school DEFAULT CHARSET utf8mb4 COLLATE utf8mb4_unicode_ci;

use school;

create table teacher
(
    id bigint unsigned auto_increment
        primary key,
    created_at datetime null,
    updated_at datetime null,
    deleted_at datetime null,
    name varchar(50) not null comment 'username',
    password varchar(100) not null comment 'password',
    email varchar(50) not null comment 'mail',
    phone varchar(30) not null comment 'mobile phone number',
    avatar varchar(200) null comment 'avatar',
    gender tinyint not null comment 'gender, 1:male, 2:female, other values:unknown',
    age tinyint not null comment 'age',
    birthday varchar(30) not null comment 'date of birth',
    school_name varchar(50) not null comment 'school name',
    college varchar(50) not null comment 'college',
    title varchar(10) not null comment 'title',
    profile text not null comment 'personal profile'
)
    comment 'teacher';

create index teacher_deleted_at_index
    on teacher (deleted_at);

sponge web http \
  --module-name=edusys \
  --server-name=edusys \
  --project-name=edusys \
  --repo-addr=zhufuyi \
  --db-dsn=root:123456@(192.168.3.37:3306)/school \
  --db-table=teacher \
  --out=./edusys

.
├── build
├── cmd
│    └── edusys
│          └── initial
├── configs
├── deployments
│    ├── docker-compose
│    └── kubernetes
├── docs
├── internal
│    ├── cache
│    ├── config
│    ├── dao
│    ├── ecode
│    ├── handler
│    ├── model
│    ├── routers
│    ├── server
│    └── types
└── scripts

# Update swagger documentation
make docs

# Compile and run services
make run

create table course
(
    id bigint unsigned auto_increment
        primary key,
    created_at datetime null,
    updated_at datetime null,
    deleted_at datetime null,
    code varchar(10) not null comment 'course code',
    name varchar(50) not null comment 'course name',
    credit tinyint not null comment 'credits',
    college varchar(50) not null comment 'college',
    semester varchar(20) not null comment 'semester',
    time varchar(30) not null comment 'class time',
    place varchar(30) not null comment 'place of class'
)
    comment 'course';

create index course_deleted_at_index
    on course (deleted_at);


create table teach
(
    id bigint unsigned auto_increment
        primary key,
    created_at datetime null,
    updated_at datetime null,
    deleted_at datetime null,
    teacher_id bigint not null comment 'teacher id',
    teacher_name varchar(50) not null comment 'teacher name',
    course_id bigint not null comment 'course id',
    course_name varchar(50) not null comment 'course name',
    score char(5) not null comment 'students evaluate the quality of teaching, 5 grades: A,B,C,D,E'
)
    comment 'teacher course';

create index teach_course_id_index
    on teach (course_id);

create index teach_deleted_at_index
    on teach (deleted_at);

create index teach_teacher_id_index
    on teach (teacher_id);

sponge web handler \
  --db-dsn=root:123456@(192.168.3.37:3306)/school \
  --db-table=course,teach \
  --out=./edusys

.
└── internal
      ├── cache
      ├── dao
      ├── ecode
      ├── handler
      ├── model
      ├── routers
      └── types

# Update swagger documentation
make docs

# Compile and run services
make run

syntax = "proto3";

package api.edusys.v1;

import "google/api/annotations.proto";
import "protoc-gen-openapiv2/options/annotations.proto";

option go_package = "edusys/api/edusys/v1;v1";

// Generate *.swagger.json basic information
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
  host: "localhost:8080"
  base_path: ""
  info: {
    title: "edusys api docs";
    version: "v0.0.0";
  };
  schemes: HTTP;
  schemes: HTTPS;
  consumes: "application/json";
  produces: "application/json";
};

service teacher {
  rpc Register(RegisterRequest) returns (RegisterReply) {
    // Set up routing
    option (google.api.http) = {
      post: "/api/v1/Register"
      body: "*"
    };
    // Set the swagger document corresponding to the route
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      summary: "Registered Users",
      description: "Submit information for registration",
      tags: "teacher",
    };
  }

  rpc Login(LoginRequest) returns (LoginReply) {
    option (google.api.http) = {
      post: "/api/v1/login"
      body: "*"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      summary: "Login",
      description: "Login",
      tags: "teacher",
    };
  }
}

message RegisterRequest {
  string name = 1;
  string email = 2;
  string password = 3;
}

message RegisterReply {
  int64 id = 1;
}

message LoginRequest {
  string email = 1;
  string password = 2;
}

message LoginReply {
  string token = 1;
}

sponge web http-pb \
  --module-name=edusys \
  --server-name=edusys \
  --project-name=edusys \
  --repo-addr=zhufuyi \
  --protobuf-file=./teacher.proto \
  --out=./edusys

.  
├── api
│    └── edusys
│          └──v1
├── build
├── cmd
│    └── edusys
│          └── initial
├── configs
├── deployments
│    ├── docker-compose
│    └── kubernetes
├── docs
├── internal
│    ├── config
│    ├── ecode
│    ├── routers
│    └── server
├── scripts
└── third_party

# Generate *pb.go file, generate handler template code, update swagger documentation
make proto

# Compile and run services
make run

# Generate *pb.go file, generate handler template code, update swagger documentation
make proto

# Generate *pb.go file, generate handler template code, update swagger documentation
make proto

sponge web dao \
  --db-dsn=root:123456@(192.168.3.37:3306)/school \
  --db-table=teacher \
  --include-init-db=true \
  --out=./edusys

go mod tidy

# Compile and run services
make run

.
├── api
│    └── edusys
│          └── v1
├── build
├── cmd
│    └── edusys
│          └── initial
├── configs
├── deployments
│    ├── docker-compose
│    └── kubernetes
├── docs
├── internal
│    ├── config
│    ├── ecode
│    ├── server
│    └── service
├── scripts
└── third_party

# Generate *pb.go file, generate service template code
make proto

# Compile and run services
make run

# Generate *pb.go file, generate service template code
make proto

sponge micro dao \
  --db-dsn=root:123456@(192.168.3.37:3306)/school \
  --db-table=teacher \
  --include-init-db=true \
  --out=./edusys

go mod tidy

# Compile and run services
make run

.
├── comment
│    └── v1
│          └──comment.proto
├── inventory
│    └── v1
│          └── inventory.proto
├── product
│    └── v1
│          └── product.proto
└── shopgw
      └── v1
            └── shopgw.proto

syntax = "proto3";

package api.comment.v1;

option go_package = "shopgw/api/comment/v1;v1";

service Comment {
  rpc ListByProductID(ListByProductIDRequest) returns (ListByProductIDReply) {}
}

message ListByProductIDRequest {
  int64 productID = 1;
}

message CommentDetail {
  int64 id=1;
  string username = 2;
  string content = 3;
}

message ListByProductIDReply {
  int32 total = 1;
  int64 productID = 2;
  repeated CommentDetail commentDetails = 3;
}

syntax = "proto3";

package api.inventory.v1;

option go_package = "shopgw/api/inventory/v1;v1";

service Inventory {
  rpc GetByID(GetByIDRequest) returns (GetByIDReply) {}
}

message GetByIDRequest {
  int64 id = 1;
}

message InventoryDetail {
  int64 id = 1;
  float num = 4;
  int32 soldNum =3;
}

message GetByIDReply {
  InventoryDetail inventoryDetail = 1;
}

syntax = "proto3";

package api.product.v1;

option go_package = "shopgw/api/product/v1;v1";

service Product {
  rpc GetByID(GetByIDRequest) returns (GetByIDReply) {}
}

message GetByIDRequest {
  int64 id = 1;
}

message ProductDetail {
  int64 id = 1;
  string name = 2;
  float price = 3;
  string description = 4;
}

message GetByIDReply {
  ProductDetail productDetail = 1;
  int64 inventoryID = 2;
}

syntax = "proto3";

package api.shopgw.v1;

import "api/product/v1/product.proto";
import "api/comment/v1/comment.proto";
import "api/inventory/v1/inventory.proto";
import "google/api/annotations.proto";
import "protoc-gen-openapiv2/options/annotations.proto";

option go_package = "shopgw/api/shopgw/v1;v1";

// default settings for generating *.swagger.json documents
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
  host: "localhost:8080"
  base_path: ""
  info: {
    title: "eshop api docs";
    version: "v0.0.0";
  };
  schemes: HTTP;
  schemes: HTTPS;
  consumes: "application/json";
  produces: "application/json";
};

service ShopGw {
  rpc GetDetailsByProductID(GetDetailsByProductIDRequest) returns (GetDetailsByProductIDReply) {
    option (google.api.http) = {
      get: "/api/v1/detail"
    };
    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
      summary: "get detail",
      description: "get detail from product id",
      tags: "shopgw",
    };
  }
}

message GetDetailsByProductIDRequest {
  int64 productID = 1;
}

message GetDetailsByProductIDReply {
  api.product.v1.ProductDetail productDetail = 1;
  api.inventory.v1.InventoryDetail inventoryDetail = 2;
  repeated api.comment.v1.CommentDetail commentDetails = 3;
}

sponge micro rpc-gw-pb \
  --module-name=shopgw \
  --server-name=shopgw \
  --project-name=eshop \
  --repo-addr=zhufuyi \
  --protobuf-file=./shopgw/v1/shopgw.proto \
  --out=./shopgw

.
├── api
│    └── shopgw
│          └── v1
├── build
├── cmd
│    └── shopgw
│          └── initial
├── configs
├── deployments
│    ├── docker-compose
│    └── kubernetes
├── docs
├── internal
│    ├── config
│    ├── ecode
│    ├── routers
│    ├── rpcclient
│    └── server
├── scripts
└── third_party

.
├── comment
│    └── v1
│          └── comment.proto
├── inventory
│    └── v1
│          └── inventory.proto
├── product
│    └── v1
│          └── product.proto
└── shopgw
      └── v1
            └── shopgw.proto

# Generate *pb.go files, generate template code, update swagger documentation
make proto

# Compile and run services
make run

sponge micro rpc-cli \
  --rpc-server-name=comment,inventory,product \
  --out=./shopgw

grpcClient:
  - name: "product"
    host: "127.0.0.1"
    port: 8201
    registryDiscoveryType: ""
  - name: "inventory"
    host: "127.0.0.1"
    port: 8202
    registryDiscoveryType: ""  
  - name: "comment"
    host: "127.0.0.1"
    port: 8203
    registryDiscoveryType: ""

sponge config --server-dir=./shopgw

package service

import (
    "context"

    commentV1 "shopgw/api/comment/v1"
    inventoryV1 "shopgw/api/inventory/v1"
    productV1 "shopgw/api/product/v1"
    shopgwV1 "shopgw/api/shopgw/v1"
    "shopgw/internal/rpcclient"
)

var _ shopgwV1.ShopGwLogicer = (*shopGwClient)(nil)

type shopGwClient struct {
    productCli productV1.ProductClient
    inventoryCli inventoryV1.InventoryClient
    commentCli commentV1.CommentClient
}

// NewShopGwClient creating rpc clients
func NewShopGwClient() shopgwV1.ShopGwLogicer {
    return &shopGwClient{
        productCli: productV1.NewProductClient(rpcclient.GetProductRPCConn()),
        inventoryCli: inventoryV1.NewInventoryClient(rpcclient.GetInventoryRPCConn()),
        commentCli: commentV1.NewCommentClient(rpcclient.GetCommentRPCConn()),
    }
}

func (c *shopGwClient) GetDetailsByProductID(ctx context.Context, req *shopgwV1.GetDetailsByProductIDRequest) (*shopgwV1.GetDetailsByProductIDReply, error) {
    productRep, err := c.productCli.GetByID(ctx, &productV1.GetByIDRequest{
        Id: req.ProductID,
    })
    if err ! = nil {
        return nil, err
    }

    inventoryRep, err := c.inventoryCli.GetByID(ctx, &inventoryV1.GetByIDRequest{
        Id: productRep.InventoryID,
    })
    if err ! = nil {
        return nil, err
    }

    commentRep, err := c.commentCli.ListByProductID(ctx, &commentV1.ListByProductIDRequest{
        ProductID: req,
    })
    if err ! = nil {
        return nil, err
    }

    return &shopgwV1.GetDetailsByProductIDReply{
        ProductDetail: productRep.ProductDetail,
        InventoryDetail: inventoryRep.InventoryDetail,
        CommentDetails: commentRep,
    }, nil
}

# Compile and run services
make run

# Compile and run services
make run

import "github.com/zhufuyi/sponge/pkg/tracer"

tags := map[string]interface{}{"foo": "bar"}
_, span := tracer.NewSpan(ctx, "spanName", tags)  
defer span.End()