Merge branch 'master' into QILIN-96

.helm/values.yaml

@@ -31,6 +31,7 @@ backend:
     - QILINAPI_DATABASE_DEBUG
     - QILINAPI_ENFORCER_HOST
     - QILINAPI_ENFORCER_PORT
+    - QILINAPI_EVENTBUS_CONNECTION
     - QILINAPI_LOG_LEVEL
     - QILINAPI_LOG_REPORT_CALLER
     - QILINAPI_MAILER_HOST
@@ -47,7 +48,8 @@ backend:
     - QILINAPI_AUTH1_CLIENTID
     - QILINAPI_AUTH1_CLIENTSECRET
     - QILINAPI_EVENTBUS_CONNECTION
-
+    - QILINAPI_IMAGINARY_SECRET        
+
 resources: {}
   # We usually recommend not to specify default resources and to leave this as a conscious
   # choice for the user. This also increases chances charts run on environments with little

docker-compose.yaml

@@ -23,6 +23,14 @@ services:
     ports: 
       - "6379:6379"
       - "6380:6380"
+
+  qilineventbus:
+    image: "rabbitmq:3-management"
+    ports:
+      - "15672:15672"
+      - "5672:5672"
+    networks:
+      - p1devnet
 
   qilinapi-postgres:
     image: postgres:10.5
@@ -59,6 +67,7 @@ services:
     depends_on:
       - qilinapi-postgres
       - qilin-redis
+      - qilineventbus
     ports:
       - "3001:3001"
     networks: 
@@ -71,6 +80,7 @@ services:
     environment:
       - GO111MODULE=on
       - QILINAPI_ENFORCER_HOST=qilin-redis
+      - QILINAPI_EVENTBUS_CONNECTION=amqp://qilineventbus:5672
       - QILINAPI_SERVER_PORT=3001
       - QILINAPI_SERVER_ALLOW_ORIGINS=http://127.0.0.1
       - QILINAPI_SERVER_DEBUG=true
@@ -86,4 +96,4 @@ services:
 
 networks:
   p1devnet:
-    external: true      
+    external: true      

go.mod

@@ -3,7 +3,7 @@ module qilin-api
 require (
 	cloud.google.com/go v0.34.0 // indirect
 	github.com/ProtocolONE/authone-jwt-verifier-golang v0.0.0-20190415120635-9cfb6c93ff5e
-	github.com/ProtocolONE/qilin-common v0.0.0-20190426102144-91ad4f805cfd
+	github.com/ProtocolONE/qilin-common v0.0.0-20190612131602-2a1edd55e5c2
 	github.com/ProtocolONE/rabbitmq v0.0.0-20190129162844-9f24367e139c
 	github.com/ProtocolONE/rbac v0.0.0-20190520124240-22f5d2b74988
 	github.com/casbin/redis-adapter v0.0.0-20190105032110-b36d844dade5

pkg/api/key_list_router.go

@@ -0,0 +1,99 @@
+package api
+
+import (
+	"bufio"
+	"github.com/labstack/echo/v4"
+	uuid "github.com/satori/go.uuid"
+	"io"
+	"net/http"
+	"qilin-api/pkg/api/rbac_echo"
+	"qilin-api/pkg/model"
+	"qilin-api/pkg/orm"
+	"strings"
+)
+
+type AddKeyListDTO struct {
+	Keys []string `json:"keys" validate:"required"`
+}
+
+type KeyListRouter struct {
+	keyListService model.KeyListService
+}
+
+func InitKeyListRouter(router *echo.Group, keyListService model.KeyListService) (*KeyListRouter, error){
+	keyRouter := KeyListRouter{
+		keyListService: keyListService,
+	}
+	r := rbac_echo.Group(router, "/packages/:packageId/keypackages/:keyPackageId", &keyRouter, []string{"*", model.PackageType, model.VendorDomain})
+	r.POST("/keys", keyRouter.AddKeys, nil)
+	r.POST("/file", keyRouter.AddFileKeys, nil)
+
+	return &keyRouter, nil
+}
+
+func (router *KeyListRouter) AddFileKeys(ctx echo.Context) error {
+	keyPackageIdParam := ctx.Param("keyPackageId")
+	keyPackageId, err := uuid.FromString(keyPackageIdParam)
+	if err != nil {
+		return orm.NewServiceError(http.StatusBadRequest, "keyPackageId is wrong")
+	}
+
+	file, err := ctx.FormFile("keys")
+	if err != nil {
+		return orm.NewServiceError(http.StatusBadRequest, err)
+	}
+
+	src, err := file.Open()
+	if err != nil {
+		return orm.NewServiceError(http.StatusBadRequest, err)
+	}
+	defer src.Close()
+
+	reader := bufio.NewReader(src)
+	var line string
+	var codes []string
+	shouldBreak := false
+	for shouldBreak == false {
+		line, err = reader.ReadString('\n')
+		if err != nil {
+			if err != io.EOF {
+				return orm.NewServiceError(http.StatusBadRequest, err)
+			}
+			shouldBreak = true
+		}
+		line = strings.Trim(line, "\t\n")
+		codes = append(codes, line)
+	}
+	if err := router.keyListService.AddKeys(keyPackageId, codes); err != nil {
+		return err
+	}
+
+	return ctx.NoContent(http.StatusOK)
+}
+
+func (router *KeyListRouter) AddKeys(ctx echo.Context) error {
+	keyPackageIdParam := ctx.Param("keyPackageId")
+	keyPackageId, err := uuid.FromString(keyPackageIdParam)
+	if err != nil {
+		return orm.NewServiceError(http.StatusBadRequest, "keyPackageId is wrong")
+	}
+
+	dto := &AddKeyListDTO{}
+	if err := ctx.Bind(dto); err != nil {
+		return orm.NewServiceError(http.StatusBadRequest, err)
+	}
+	if errs := ctx.Validate(dto); errs != nil {
+		return orm.NewServiceError(http.StatusUnprocessableEntity, errs)
+	}
+
+	err = router.keyListService.AddKeys(keyPackageId, dto.Keys)
+	if err != nil {
+		return err
+	}
+
+	return ctx.NoContent(http.StatusOK)
+}
+
+func (*KeyListRouter) GetOwner(ctx rbac_echo.AppContext) (string, error) {
+	return GetOwnerForPackage(ctx)
+}

pkg/api/key_list_router_test.go

@@ -0,0 +1,188 @@
+package api
+
+import (
+	"bytes"
+	"github.com/labstack/echo/v4"
+	uuid "github.com/satori/go.uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	"gopkg.in/go-playground/validator.v9"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"qilin-api/pkg/model"
+	"qilin-api/pkg/model/utils"
+	"qilin-api/pkg/orm"
+	qilintest "qilin-api/pkg/test"
+	"strings"
+	"testing"
+)
+
+type KeyListRouterTestSuite struct {
+	suite.Suite
+	db              *orm.Database
+	echo            *echo.Echo
+	router          *KeyListRouter
+	rightKeyPackage uuid.UUID
+	wrongKeyPackage uuid.UUID
+	rightKeyStream  uuid.UUID
+	keyPackage      uuid.UUID
+}
+
+func Test_KeyListRouter(t *testing.T) {
+	suite.Run(t, new(KeyListRouterTestSuite))
+}
+
+func (suite *KeyListRouterTestSuite) SetupTest() {
+	shouldBe := require.New(suite.T())
+	config, err := qilintest.LoadTestConfig()
+	if err != nil {
+		suite.FailNow("Unable to load config", "%v", err)
+	}
+	db, err := orm.NewDatabase(&config.Database)
+	if err != nil {
+		suite.FailNow("Unable to connect to database", "%v", err)
+	}
+
+	if err := db.DropAllTables(); err != nil {
+		assert.FailNow(suite.T(), "Unable to drop tables", err)
+	}
+	if err := db.Init(); err != nil {
+		assert.FailNow(suite.T(), "Unable to init tables", err)
+	}
+
+	suite.rightKeyPackage = uuid.NewV4()
+	suite.wrongKeyPackage = uuid.NewV4()
+	suite.keyPackage = uuid.NewV4()
+
+	keyListStreeam := model.KeyStream{
+		Type: model.ListKeyStream,
+	}
+	keyListStreeam.ID = uuid.NewV4()
+	suite.rightKeyStream = keyListStreeam.ID
+	shouldBe.Nil(db.DB().Model(model.KeyStream{}).Create(&keyListStreeam).Error)
+
+	gamePackage := model.Package{Name: utils.LocalizedString{EN: "test package"}}
+	gamePackage.ID = suite.keyPackage
+
+	shouldBe.Nil(db.DB().Model(model.Package{}).Create(&gamePackage).Error)
+
+	keyPackage := model.KeyPackage{
+		Name:          "Test name",
+		PackageID:     suite.keyPackage,
+		KeyStreamID:   suite.rightKeyStream,
+		KeyStreamType: model.ListKeyStream,
+	}
+	keyPackage.ID = suite.rightKeyPackage
+	shouldBe.Nil(db.DB().Model(model.KeyPackage{}).Create(&keyPackage).Error)
+
+	platformListStreeam := model.KeyStream{
+		Type: model.PlatformKeysStream,
+	}
+	platformListStreeam.ID = uuid.NewV4()
+	shouldBe.Nil(db.DB().Model(model.KeyStream{}).Create(&platformListStreeam).Error)
+	suite.wrongKeyPackage = platformListStreeam.ID
+
+	platformKeyPackage := model.KeyPackage{
+		Name:          "Another name",
+		PackageID:     uuid.NewV4(),
+		KeyStreamType: model.PlatformKeysStream,
+	}
+	platformKeyPackage.ID = suite.wrongKeyPackage
+	shouldBe.Nil(db.DB().Model(model.KeyPackage{}).Create(&platformKeyPackage).Error)
+
+	e := echo.New()
+	e.Validator = &QilinValidator{validator: validator.New()}
+
+	service := orm.NewKeyListService(db)
+	suite.router, err = InitKeyListRouter(e.Group("/api/v1"), service)
+	suite.db = db
+	suite.echo = e
+	shouldBe.Nil(err)
+}
+
+func (suite *KeyListRouterTestSuite) TearDownTest() {
+	if err := suite.db.DropAllTables(); err != nil {
+		panic(err)
+	}
+	if err := suite.db.Close(); err != nil {
+		panic(err)
+	}
+}
+
+func (suite *KeyListRouterTestSuite) TestAddKeys() {
+	shouldBe := require.New(suite.T())
+	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"keys":["QWERTY","TESTSOMECODE"]}`))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := suite.echo.NewContext(req, rec)
+	c.SetPath("/api/v1/packages/:packageId/keypackages/:keyPackageId")
+	c.SetParamNames("packageId", "keyPackageId")
+	c.SetParamValues(suite.keyPackage.String(), suite.rightKeyPackage.String())
+
+	err := suite.router.AddKeys(c)
+	shouldBe.Nil(err)
+	shouldBe.Equal(200, rec.Code)
+}
+
+func (suite *KeyListRouterTestSuite) TestAddKeysBadRequest() {
+	shouldBe := require.New(suite.T())
+	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"":somethingwronghere"}`))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := suite.echo.NewContext(req, rec)
+	c.SetPath("/api/v1/packages/:packageId/keypackages/:keyPackageId")
+	c.SetParamNames("packageId", "keyPackageId")
+	c.SetParamValues(suite.keyPackage.String(), suite.rightKeyPackage.String())
+
+	err := suite.router.AddKeys(c)
+	shouldBe.NotNil(err)
+	shouldBe.Equal(400, err.(*orm.ServiceError).Code)
+}
+
+func (suite *KeyListRouterTestSuite) TestAddKeysNotFound() {
+	shouldBe := require.New(suite.T())
+	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"keys":["QWERTY","TESTSOMECODE"]}`))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := suite.echo.NewContext(req, rec)
+	c.SetPath("/api/v1/packages/:packageId/keypackages/:keyPackageId")
+	c.SetParamNames("packageId", "keyPackageId")
+	c.SetParamValues(uuid.NewV4().String(), uuid.NewV4().String())
+
+	err := suite.router.AddKeys(c)
+	shouldBe.NotNil(err)
+	shouldBe.Equal(404, err.(*orm.ServiceError).Code)
+}
+
+func (suite *KeyListRouterTestSuite) TestAddFile() {
+	shouldBe := require.New(suite.T())
+	values := map[string]io.Reader {
+		"keys": strings.NewReader("QWERTY\nTEST\nOPIUY"),
+	}
+	var b bytes.Buffer
+	w := multipart.NewWriter(&b)
+	for key, r := range values {
+		var fw io.Writer
+		fw, err := w.CreateFormFile(key, key)
+		shouldBe.Nil(err)
+		if _, err := io.Copy(fw, r); err != nil {
+			shouldBe.FailNow("Can't copy fw to r")
+		}
+	}
+	shouldBe.Nil(w.Close())
+
+	req := httptest.NewRequest(http.MethodPost, "/", &b)
+	req.Header.Set(echo.HeaderContentType, w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	c := suite.echo.NewContext(req, rec)
+	c.SetPath("/api/v1/packages/:packageId/keypackages/:keyPackageId")
+	c.SetParamNames("packageId", "keyPackageId")
+	c.SetParamValues(suite.keyPackage.String(), suite.rightKeyPackage.String())
+
+	err := suite.router.AddFileKeys(c)
+	shouldBe.Nil(err)
+	shouldBe.Equal(200, rec.Code)
+}