@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/templates/go-backend/internal/common/response/response_test.go

@@ -0,0 +1,463 @@
+package response
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"{{module}}/internal/common/types"
+	"{{module}}/pkg/apierror"
+)
+
+func init() {
+	gin.SetMode(gin.TestMode)
+}
+
+// newTestContext 创建用于测试的 gin.Context 和 httptest.ResponseRecorder
+func newTestContext() (*gin.Context, *httptest.ResponseRecorder) {
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest(http.MethodGet, "/", nil)
+	return c, w
+}
+
+// TestOK 验证 200 状态码和响应体
+func TestOK(t *testing.T) {
+	tests := []struct {
+		name string
+		data any
+	}{
+		{
+			name: "返回 map 数据",
+			data: map[string]string{"id": "123", "name": "test"},
+		},
+		{
+			name: "返回 nil",
+			data: nil,
+		},
+		{
+			name: "返回字符串",
+			data: "hello",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			c, w := newTestContext()
+			OK(c, tc.data)
+			assert.Equal(t, http.StatusOK, w.Code)
+		})
+	}
+}
+
+// TestCreated 验证 201 状态码和响应体
+func TestCreated(t *testing.T) {
+	tests := []struct {
+		name string
+		data any
+	}{
+		{
+			name: "返回新建资源",
+			data: map[string]any{"id": 1, "name": "new-resource"},
+		},
+		{
+			name: "返回包含 ID 的结构体",
+			data: struct {
+				ID   int64  `json:"id"`
+				Name string `json:"name"`
+			}{ID: 42, Name: "example"},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			c, w := newTestContext()
+			Created(c, tc.data)
+			assert.Equal(t, http.StatusCreated, w.Code)
+
+			// 验证响应体是有效的 JSON
+			var body any
+			err := json.Unmarshal(w.Body.Bytes(), &body)
+			require.NoError(t, err, "响应体应为有效 JSON")
+		})
+	}
+}
+
+// TestNoContent 验证 204 状态码且无响应体
+func TestNoContent(t *testing.T) {
+	c, w := newTestContext()
+	NoContent(c)
+	// gin 的 WriteHeader 只缓存状态码，须调用 WriteHeaderNow 才会写入 recorder
+	c.Writer.WriteHeaderNow()
+	assert.Equal(t, http.StatusNoContent, w.Code)
+	assert.Empty(t, w.Body.Bytes(), "204 响应不应有 body")
+}
+
+// TestError_APIError 验证 Error 对 *apierror.APIError 的状态码提取
+func TestError_APIError(t *testing.T) {
+	tests := []struct {
+		name          string
+		err           error
+		wantStatus    int
+		wantErrorCode string
+		wantErrorType string
+	}{
+		{
+			name:          "404 NotFound",
+			err:           apierror.NotFound("User", 1),
+			wantStatus:    http.StatusNotFound,
+			wantErrorCode: apierror.CodeResourceNotFound,
+			wantErrorType: apierror.TypeNotFound,
+		},
+		{
+			name:          "401 Unauthorized",
+			err:           apierror.Unauthorized(),
+			wantStatus:    http.StatusUnauthorized,
+			wantErrorCode: apierror.CodeUnauthorized,
+			wantErrorType: apierror.TypeAuthentication,
+		},
+		{
+			name:          "403 Forbidden",
+			err:           apierror.Forbidden(),
+			wantStatus:    http.StatusForbidden,
+			wantErrorCode: apierror.CodeAccessDenied,
+			wantErrorType: apierror.TypeAuthorization,
+		},
+		{
+			name:          "409 Conflict",
+			err:           apierror.AlreadyExists("Email", "email"),
+			wantStatus:    http.StatusConflict,
+			wantErrorCode: apierror.CodeResourceExists,
+			wantErrorType: apierror.TypeInvalidRequest,
+		},
+		{
+			name:          "422 Business",
+			err:           apierror.Business("plan_limit_exceeded", "Plan limit reached"),
+			wantStatus:    http.StatusUnprocessableEntity,
+			wantErrorCode: "plan_limit_exceeded",
+			wantErrorType: apierror.TypeInvalidRequest,
+		},
+		{
+			name:          "429 TooManyRequests",
+			err:           apierror.TooManyRequests(),
+			wantStatus:    http.StatusTooManyRequests,
+			wantErrorCode: apierror.CodeTooManyRequests,
+			wantErrorType: apierror.TypeRateLimit,
+		},
+		{
+			name:          "500 Internal",
+			err:           apierror.Internal(),
+			wantStatus:    http.StatusInternalServerError,
+			wantErrorCode: apierror.CodeInternalError,
+			wantErrorType: apierror.TypeAPI,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			c, w := newTestContext()
+			Error(c, tc.err)
+
+			assert.Equal(t, tc.wantStatus, w.Code, "HTTP 状态码不匹配")
+
+			var body apierror.ErrorResponse
+			err := json.Unmarshal(w.Body.Bytes(), &body)
+			require.NoError(t, err, "响应体应为有效 JSON")
+			assert.Equal(t, tc.wantErrorCode, body.Error.Code, "错误码不匹配")
+			assert.Equal(t, tc.wantErrorType, body.Error.Type, "错误类型不匹配")
+		})
+	}
+}
+
+func TestErrorProjectsValidatedRetryAfterMetadata(t *testing.T) {
+	headers := make(http.Header)
+	headers.Set("Content-Type", "application/json")
+	headers.Set(types.HeaderRetryAfter, "37")
+	headers.Set("X-Upstream-Internal", "must-not-leak")
+	decoded := apierror.DecodeHTTPResponse(
+		http.StatusTooManyRequests,
+		headers,
+		[]byte(`{"error":{"type":"rate_limit_error","code":"rate_limited","message":"Too many requests"}}`),
+		nil,
+	)
+
+	c, w := newTestContext()
+	Error(c, fmt.Errorf("platform request failed: %w", decoded))
+
+	assert.Equal(t, http.StatusTooManyRequests, w.Code)
+	assert.Equal(t, []string{"37"}, w.Header().Values(types.HeaderRetryAfter))
+	assert.Empty(t, w.Header().Get("X-Upstream-Internal"))
+	var body apierror.ErrorResponse
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &body))
+	assert.Equal(t, apierror.ErrorDetail{
+		Type: "rate_limit_error", Code: "rate_limited", Message: "Too many requests",
+	}, body.Error)
+}
+
+func TestErrorDoesNotProjectRetryAfterForOtherStatus(t *testing.T) {
+	headers := make(http.Header)
+	headers.Set("Content-Type", "application/json")
+	headers.Set(types.HeaderRetryAfter, "37")
+	decoded := apierror.DecodeHTTPResponse(
+		http.StatusTooManyRequests,
+		headers,
+		[]byte(`{"error":{"type":"rate_limit_error","code":"rate_limited","message":"Too many requests"}}`),
+		nil,
+	)
+	decoded.Status = http.StatusBadRequest
+
+	c, w := newTestContext()
+	Error(c, decoded)
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+	assert.Empty(t, w.Header().Get(types.HeaderRetryAfter))
+}
+
+// TestError_UnknownError 验证非 APIError 的普通 error 返回 500
+func TestError_UnknownError(t *testing.T) {
+	c, w := newTestContext()
+	Error(c, fmt.Errorf("some unexpected database error"))
+
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
+
+	var body apierror.ErrorResponse
+	err := json.Unmarshal(w.Body.Bytes(), &body)
+	require.NoError(t, err)
+	assert.Equal(t, apierror.CodeInternalError, body.Error.Code)
+	assert.Equal(t, apierror.TypeAPI, body.Error.Type)
+}
+
+// TestNewPaginated 验证 TotalPages 向上取整计算和空数据处理
+func TestNewPaginated(t *testing.T) {
+	tests := []struct {
+		name           string
+		data           []string
+		page           int
+		pageSize       int
+		total          int64
+		wantTotalPages int
+		wantDataLen    int
+	}{
+		{
+			name:           "整除情况 10/5=2",
+			data:           []string{"a", "b", "c", "d", "e"},
+			page:           1,
+			pageSize:       5,
+			total:          10,
+			wantTotalPages: 2,
+			wantDataLen:    5,
+		},
+		{
+			name:           "向上取整 11/5=3",
+			data:           []string{"a"},
+			page:           3,
+			pageSize:       5,
+			total:          11,
+			wantTotalPages: 3,
+			wantDataLen:    1,
+		},
+		{
+			name:           "向上取整 1/20=1",
+			data:           []string{"only-one"},
+			page:           1,
+			pageSize:       20,
+			total:          1,
+			wantTotalPages: 1,
+			wantDataLen:    1,
+		},
+		{
+			name:           "total 为 0 时 totalPages 为 0",
+			data:           []string{},
+			page:           1,
+			pageSize:       20,
+			total:          0,
+			wantTotalPages: 0,
+			wantDataLen:    0,
+		},
+		{
+			name:           "nil data 应被转换为空切片",
+			data:           nil,
+			page:           1,
+			pageSize:       20,
+			total:          0,
+			wantTotalPages: 0,
+			wantDataLen:    0,
+		},
+		{
+			name:           "100 条数据每页 3 条共 34 页",
+			data:           make([]string, 3),
+			page:           1,
+			pageSize:       3,
+			total:          100,
+			wantTotalPages: 34,
+			wantDataLen:    3,
+		},
+		{
+			name:           "pageSize 为 0 时 totalPages 为 0",
+			data:           nil,
+			page:           1,
+			pageSize:       0,
+			total:          50,
+			wantTotalPages: 0,
+			wantDataLen:    0,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := NewPaginated(tc.data, tc.page, tc.pageSize, tc.total)
+
+			assert.Equal(t, tc.wantTotalPages, result.Pagination.TotalPages, "TotalPages 计算错误")
+			assert.Equal(t, tc.wantDataLen, len(result.Data), "Data 长度不匹配")
+			assert.Equal(t, tc.page, result.Pagination.Page, "Page 不匹配")
+			assert.Equal(t, tc.pageSize, result.Pagination.PageSize, "PageSize 不匹配")
+			assert.Equal(t, tc.total, result.Pagination.Total, "Total 不匹配")
+			assert.NotNil(t, result.Data, "Data 不应为 nil")
+		})
+	}
+}
+
+// TestNewPaginated_JSONSerializable 验证分页响应可以正常序列化为 JSON
+func TestNewPaginated_JSONSerializable(t *testing.T) {
+	type Item struct {
+		ID   int    `json:"id"`
+		Name string `json:"name"`
+	}
+
+	data := []Item{{ID: 1, Name: "foo"}, {ID: 2, Name: "bar"}}
+	result := NewPaginated(data, 1, 10, 2)
+
+	raw, err := json.Marshal(result)
+	require.NoError(t, err)
+
+	var decoded Paginated[Item]
+	err = json.Unmarshal(raw, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, 2, len(decoded.Data))
+	assert.Equal(t, 1, decoded.Pagination.TotalPages)
+	assert.Equal(t, int64(2), decoded.Pagination.Total)
+}
+
+// TestValidationError_NonValidatorError 验证普通 error 走 BadRequest 路径
+func TestValidationError_NonValidatorError(t *testing.T) {
+	c, w := newTestContext()
+	ValidationError(c, fmt.Errorf("plain error"))
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+
+	var body apierror.ErrorResponse
+	err := json.Unmarshal(w.Body.Bytes(), &body)
+	require.NoError(t, err)
+	assert.Equal(t, apierror.CodeValidationFailed, body.Error.Code)
+	assert.Equal(t, apierror.TypeInvalidRequest, body.Error.Type)
+}
+
+// TestValidationError_ValidatorErrors 验证 go-playground/validator 校验错误的格式化
+func TestValidationError_ValidatorErrors(t *testing.T) {
+	type SampleDTO struct {
+		Name  string `json:"name" validate:"required"`
+		Email string `json:"email" validate:"required,email"`
+		Age   int    `json:"age" validate:"min=18"`
+	}
+
+	v := validator.New()
+	// 注册 JSON tag 名映射，与 response.go 中行为一致
+	v.RegisterTagNameFunc(func(fld reflect.StructField) string {
+		name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
+		if name == "-" {
+			return ""
+		}
+		return name
+	})
+
+	// 空结构体会触发 required 和 min 校验失败
+	dto := SampleDTO{Age: 10}
+	validationErr := v.Struct(dto)
+	require.Error(t, validationErr)
+
+	c, w := newTestContext()
+	ValidationError(c, validationErr)
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+
+	var body apierror.ErrorResponse
+	err := json.Unmarshal(w.Body.Bytes(), &body)
+	require.NoError(t, err)
+	assert.Equal(t, apierror.CodeValidationFailed, body.Error.Code)
+	assert.Equal(t, apierror.TypeValidation, body.Error.Type)
+	assert.NotEmpty(t, body.Error.Errors, "应包含字段级错误列表")
+}
+
+// TestFormatValidationMessage 通过完整校验流程间接验证 formatValidationMessage 的各个 tag 分支
+func TestFormatValidationMessage_Tags(t *testing.T) {
+	type DTO struct {
+		Email  string `json:"email" validate:"email"`
+		MinVal string `json:"min_val" validate:"min=5"`
+		MaxVal string `json:"max_val" validate:"max=3"`
+		OneOf  string `json:"one_of" validate:"oneof=a b c"`
+		GteVal int    `json:"gte_val" validate:"gte=10"`
+		LteVal int    `json:"lte_val" validate:"lte=5"`
+		GtVal  int    `json:"gt_val" validate:"gt=0"`
+		LtVal  int    `json:"lt_val" validate:"lt=10"`
+	}
+
+	v := validator.New()
+
+	// 触发 email 校验失败
+	dto := DTO{
+		Email:  "not-an-email",
+		MinVal: "ab",      // 长度不足 5
+		MaxVal: "toolong", // 长度超过 3
+		OneOf:  "x",       // 不在枚举中
+		GteVal: 5,         // 小于 10
+		LteVal: 10,        // 大于 5
+		GtVal:  0,         // 不大于 0
+		LtVal:  10,        // 不小于 10
+	}
+	errs := v.Struct(dto)
+	require.Error(t, errs)
+
+	var ve validator.ValidationErrors
+	require.ErrorAs(t, errs, &ve)
+
+	// 建立 tag -> message 的映射，用于快速断言
+	tagMessages := make(map[string]string)
+	for _, fe := range ve {
+		tagMessages[fe.Tag()] = formatValidationMessage(fe)
+	}
+
+	assert.Equal(t, "must be a valid email", tagMessages["email"])
+	assert.Contains(t, tagMessages["min"], "5")
+	assert.Contains(t, tagMessages["max"], "3")
+	assert.Contains(t, tagMessages["oneof"], "a b c")
+	assert.Contains(t, tagMessages["gte"], "10")
+	assert.Contains(t, tagMessages["lte"], "5")
+	assert.Contains(t, tagMessages["gt"], "0")
+	assert.Contains(t, tagMessages["lt"], "10")
+}
+
+// TestFormatValidationMessage_DefaultBranch 验证未知 tag 走 default 分支
+func TestFormatValidationMessage_DefaultBranch(t *testing.T) {
+	type DTO struct {
+		URL string `json:"url" validate:"url"`
+	}
+	v := validator.New()
+	errs := v.Struct(DTO{URL: "not-a-url"})
+	require.Error(t, errs)
+
+	var ve validator.ValidationErrors
+	require.ErrorAs(t, errs, &ve)
+
+	msg := formatValidationMessage(ve[0])
+	assert.Equal(t, "must be a valid URL", msg)
+}

package/dist/resources/templates/go-backend/internal/common/ruleexpression/ast.go

@@ -0,0 +1,141 @@
+package ruleexpression
+
+// SchemaVersionV1 是 Requirement Expression V1 的唯一受支持版本。
+const SchemaVersionV1 = 1
+
+// NodeKind 标识封闭 AST 中的节点类型。
+type NodeKind string
+
+const (
+	NodeKindAll       NodeKind = "all"
+	NodeKindAny       NodeKind = "any"
+	NodeKindNot       NodeKind = "not"
+	NodeKindPredicate NodeKind = "predicate"
+)
+
+// Subject 标识 predicate 读取的通用事实命名空间。
+type Subject string
+
+const (
+	SubjectProduct        Subject = "product"
+	SubjectAttribute      Subject = "attribute"
+	SubjectCapability     Subject = "capability"
+	SubjectInsightsMetric Subject = "insights_metric"
+	SubjectProductDataset Subject = "product_dataset"
+)
+
+// Operator 标识 Requirement Expression V1 支持的比较操作。
+type Operator string
+
+const (
+	OperatorEqual              Operator = "eq"
+	OperatorNotEqual           Operator = "neq"
+	OperatorIn                 Operator = "in"
+	OperatorNotIn              Operator = "not_in"
+	OperatorExists             Operator = "exists"
+	OperatorActive             Operator = "active"
+	OperatorInactive           Operator = "inactive"
+	OperatorAvailable          Operator = "available"
+	OperatorFreshWithinSeconds Operator = "fresh_within_seconds"
+)
+
+// ExpressionV1 是带版本信封的 Requirement Expression V1。
+type ExpressionV1 struct {
+	// SchemaVersion 固定为 SchemaVersionV1。
+	SchemaVersion int `json:"schema_version"`
+	// Root 是表达式的根节点。
+	Root Node `json:"root"`
+}
+
+// Node 封闭 AST 节点集合，外部包不能扩展节点类型。
+type Node interface {
+	Kind() NodeKind
+	isRequirementNode()
+}
+
+// AllNode 表示全部子节点都通过的组合条件。
+type AllNode struct {
+	// Children 按声明顺序参与确定性求值。
+	Children []Node `json:"children"`
+}
+
+// Kind 返回 all 节点类型。
+func (*AllNode) Kind() NodeKind { return NodeKindAll }
+
+func (*AllNode) isRequirementNode() {}
+
+// AnyNode 表示至少一个子节点通过的组合条件。
+type AnyNode struct {
+	// Children 按声明顺序参与确定性求值。
+	Children []Node `json:"children"`
+}
+
+// Kind 返回 any 节点类型。
+func (*AnyNode) Kind() NodeKind { return NodeKindAny }
+
+func (*AnyNode) isRequirementNode() {}
+
+// NotNode 表示对子节点执行三值逻辑取反。
+type NotNode struct {
+	// Child 是唯一子节点。
+	Child Node `json:"child"`
+}
+
+// Kind 返回 not 节点类型。
+func (*NotNode) Kind() NodeKind { return NodeKindNot }
+
+func (*NotNode) isRequirementNode() {}
+
+// PredicateNode 表示由消费方解析的叶子条件。
+type PredicateNode struct {
+	// Subject 标识事实命名空间。
+	Subject Subject `json:"subject"`
+	// Key 标识命名空间内的事实键。
+	Key string `json:"key"`
+	// Operator 标识比较语义。
+	Operator Operator `json:"operator"`
+	// Value 是操作符需要的可选类型化值。
+	Value Value `json:"value,omitempty"`
+}
+
+// Kind 返回 predicate 节点类型。
+func (*PredicateNode) Kind() NodeKind { return NodeKindPredicate }
+
+func (*PredicateNode) isRequirementNode() {}
+
+// Value 封闭 predicate 值集合，外部包不能扩展值类型。
+type Value interface {
+	isRequirementValue()
+}
+
+// BooleanValue 保存布尔 predicate 值。
+type BooleanValue struct {
+	// Value 是布尔值本身。
+	Value bool
+}
+
+func (*BooleanValue) isRequirementValue() {}
+
+// NumberValue 保存 IEEE 754 双精度 predicate 值。
+type NumberValue struct {
+	// Value 是数值本身。
+	Value float64
+}
+
+func (*NumberValue) isRequirementValue() {}
+
+// StringValue 保存字符串 predicate 值。
+type StringValue struct {
+	// Value 是字符串本身。
+	Value string
+}
+
+func (*StringValue) isRequirementValue() {}
+
+// StringArrayValue 保存有序字符串数组 predicate 值。
+type StringArrayValue struct {
+	// Values 保留输入顺序，canonical encoding 不重排数组。
+	Values []string
+}
+
+func (*StringArrayValue) isRequirementValue() {}

package/dist/resources/templates/go-backend/internal/common/ruleexpression/ast_test.go

@@ -0,0 +1,81 @@
+package ruleexpression
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"testing"
+)
+
+func TestNodeKinds(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		node Node
+		want NodeKind
+	}{
+		{node: &AllNode{Children: []Node{resultPredicate("all")}}, want: NodeKindAll},
+		{node: &AnyNode{Children: []Node{resultPredicate("any")}}, want: NodeKindAny},
+		{node: &NotNode{Child: resultPredicate("not")}, want: NodeKindNot},
+		{node: resultPredicate("predicate"), want: NodeKindPredicate},
+	}
+	for _, test := range tests {
+		if got := test.node.Kind(); got != test.want {
+			t.Fatalf("Kind() = %s, want %s", got, test.want)
+		}
+	}
+}
+
+func TestExpressionV1JSONRoundTripUsesCanonicalContract(t *testing.T) {
+	t.Parallel()
+
+	raw := []byte(`{"root":{"operator":"eq","value":["east","west"],"key":"regions","subject":"attribute","kind":"predicate"},"schema_version":1}`)
+	var expression ExpressionV1
+	if err := json.Unmarshal(raw, &expression); err != nil {
+		t.Fatalf("json.Unmarshal() error = %v", err)
+	}
+	encoded, err := json.Marshal(expression)
+	if err != nil {
+		t.Fatalf("json.Marshal() error = %v", err)
+	}
+	want := []byte(`{"root":{"key":"regions","kind":"predicate","operator":"eq","subject":"attribute","value":["east","west"]},"schema_version":1}`)
+	if !bytes.Equal(encoded, want) {
+		t.Fatalf("json.Marshal() = %s, want %s", encoded, want)
+	}
+}
+
+func TestProgrammaticASTRejectsUnsupportedVersionAndTypedNilNodes(t *testing.T) {
+	t.Parallel()
+
+	invalidVersion := expressionWithRoot(resultPredicate("version"))
+	invalidVersion.SchemaVersion = SchemaVersionV1 + 1
+	_, err := CanonicalJSON(invalidVersion)
+	assertErrorCode(t, err, ErrorCodeUnsupportedSchemaVersion)
+
+	var all *AllNode
+	var anyNode *AnyNode
+	var not *NotNode
+	var predicate *PredicateNode
+	for _, node := range []Node{all, anyNode, not, predicate} {
+		_, err = CanonicalJSON(expressionWithRoot(node))
+		assertErrorCode(t, err, ErrorCodeInvalidNode)
+	}
+}
+
+func TestErrorFormattingAndUnwrap(t *testing.T) {
+	t.Parallel()
+
+	withoutPath := newError(ErrorCodeInvalidJSON, "", "JSON is malformed")
+	if got := withoutPath.Error(); got != "invalid_json: JSON is malformed" {
+		t.Fatalf("Error() = %q", got)
+	}
+
+	cause := errors.New("unexpected token")
+	withPath := wrapError(ErrorCodeInvalidJSON, "$.root", "JSON is malformed", cause)
+	if got := withPath.Error(); got != "invalid_json at $.root: JSON is malformed: unexpected token" {
+		t.Fatalf("Error() = %q", got)
+	}
+	if !errors.Is(withPath, cause) {
+		t.Fatalf("errors.Is() = false, want true")
+	}
+}