diff --git a/go.mod b/go.mod
index 4a82fbec0e49aa45415ca88d6e6331d477fdd44b..f53323bb290e119feda2d24ebe935d02cfdc9e38 100644
--- a/go.mod
+++ b/go.mod
@@ -8,10 +8,12 @@ require (
github.com/golang/protobuf v1.5.2
github.com/gosimple/slug v1.13.1
github.com/hashicorp/go-multierror v1.1.1
+ github.com/hashicorp/golang-lru v0.5.4
github.com/pkg/errors v0.9.1
github.com/rs/xid v1.4.0
github.com/stretchr/testify v1.8.0
go.mongodb.org/mongo-driver v1.11.4
+ go.uber.org/zap v1.19.1
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2
google.golang.org/grpc v1.45.0
@@ -28,6 +30,8 @@ require (
github.com/hashicorp/errwrap v1.0.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/stretchr/objx v0.4.0 // indirect
+ go.uber.org/atomic v1.9.0 // indirect
+ go.uber.org/multierr v1.7.0 // indirect
golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac // indirect
golang.org/x/text v0.3.7 // indirect
google.golang.org/genproto v0.0.0-20210917145530-b395a37504d4 // indirect
diff --git a/go.sum b/go.sum
index 1f26de451e3ef4f777baaefada69e5af8b447921..9dea84ab8c222f13374d0a59a405fa290feed61a 100644
--- a/go.sum
+++ b/go.sum
@@ -6,6 +6,8 @@ github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAE
github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
github.com/antonmedv/expr v1.9.0 h1:j4HI3NHEdgDnN9p6oI6Ndr0G5QryMY0FNxT4ONrFDGU=
github.com/antonmedv/expr v1.9.0/go.mod h1:5qsM3oLGDND7sDmQGDXHkYfkjYMUX14qsgqmHhwGEk8=
+github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
@@ -75,6 +77,8 @@ github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/U
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
+github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
@@ -91,6 +95,7 @@ github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i
github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -108,6 +113,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/testify v0.0.0-20161117074351-18a02ba4a312/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -124,6 +130,16 @@ github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1
go.mongodb.org/mongo-driver v1.11.4 h1:4ayjakA013OdpGyL2K3ZqylTac/rMjrJOMZ1EHizXas=
go.mongodb.org/mongo-driver v1.11.4/go.mod h1:PTSz5yu21bkT/wXpkS7WR5f0ddqw5quethTUn9WM+2g=
go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
+go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.1.11-0.20210813005559-691160354723 h1:sHOAIxRGBp443oHZIPB+HsUGaksVCXVQENPxwTfQdH4=
+go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/multierr v1.7.0 h1:zaiO/rmgFjbmCXdSYJWQcdvOCsthmdaHfr3Gm2Kx4Ec=
+go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak=
+go.uber.org/zap v1.19.1 h1:ue41HOKd1vGURxrmeKIgELGb3jPW9DMUDGtsinblHwI=
+go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
@@ -133,6 +149,7 @@ golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
@@ -228,7 +245,10 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..7f7248e5208f1691d7e094eaf640f361383faab6
--- /dev/null
+++ b/pkg/cache/cache.go
@@ -0,0 +1,90 @@
+package cache
+
+import (
+ "errors"
+ "fmt"
+ "time"
+
+ lru "github.com/hashicorp/golang-lru"
+ "go.uber.org/zap"
+)
+
+const (
+ defaultCacheSize = 1000
+ defaultTTL = 30 * time.Second
+)
+
+var ErrNotFound = errors.New("not found")
+
+type Cache struct {
+ cache *lru.Cache
+ ttl time.Duration
+ logger *zap.Logger
+}
+
+type item struct {
+ value interface{}
+ expiredAt time.Time
+}
+
+func NewCache(size int, ttl time.Duration, opts ...interface{}) *Cache {
+ if size == 0 {
+ size = defaultCacheSize
+ }
+ if ttl == 0 {
+ ttl = defaultTTL
+ }
+ c, err := lru.New(size)
+ if err != nil {
+ panic(err)
+ }
+ ch := &Cache{
+ cache: c,
+ ttl: ttl,
+ logger: zap.NewNop(),
+ }
+
+ for _, o := range opts {
+ switch p := o.(type) {
+ case *zap.Logger:
+ ch.logger = p
+ }
+ }
+
+ ch.logger = ch.logger.Named("Cache")
+
+ return ch
+}
+
+func (c *Cache) Set(key, value interface{}) (err error) {
+ c.cache.Add(key, &item{value: value, expiredAt: time.Now().Add(c.ttl)})
+ c.logger.Debug("Set", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", value)))
+ return nil
+}
+
+func (c *Cache) Get(key interface{}) (value interface{}, err error) {
+ val, ok := c.cache.Get(key)
+ if ok {
+ v := val.(*item)
+ if v.expiredAt.Before(time.Now()) {
+ c.Remove(key)
+ c.logger.Debug("Expired", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", v.value)))
+ return nil, ErrNotFound
+ }
+ c.logger.Debug("Hit", zap.String("key", fmt.Sprintf("%v", key)), zap.String("ptr", fmt.Sprintf("%p", v.value)))
+ return v.value, nil
+ }
+ c.logger.Debug("Miss", zap.String("key", fmt.Sprintf("%v", key)))
+ return nil, ErrNotFound
+}
+
+func (c *Cache) Remove(key interface{}) (err error) {
+ present := c.cache.Remove(key)
+ c.logger.Debug("Remove", zap.String("key", fmt.Sprintf("%v", key)))
+
+ if !present {
+ err = ErrNotFound
+ }
+
+ return
+}
diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..345a391c09044b61ebac4f869ba26bbcd9def13d
--- /dev/null
+++ b/pkg/cache/cache_test.go
@@ -0,0 +1,82 @@
+package cache
+
+import (
+ "errors"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestCache(t *testing.T) {
+
+ t.Run("Simple", func(t *testing.T) {
+ c := NewCache(10, 0)
+
+ {
+ val, err := c.Get("test_key")
+ require.Error(t, err)
+ assert.True(t, errors.Is(err, ErrNotFound))
+ assert.Nil(t, val)
+ }
+ {
+ err := c.Set("test_key", "test_val")
+ require.NoError(t, err)
+
+ val, err := c.Get("test_key")
+ require.NoError(t, err)
+ assert.Equal(t, "test_val", val.(string))
+ }
+
+ {
+ err := c.Remove("test_key")
+ require.NoError(t, err)
+
+ val, err := c.Get("test_key")
+ assert.True(t, errors.Is(err, ErrNotFound))
+ assert.Nil(t, val)
+ }
+ })
+ t.Run("Value Evicted", func(t *testing.T) {
+ c := NewCache(1, 0)
+
+ {
+ err := c.Set("test_key_1", "test_val_1")
+ require.NoError(t, err)
+
+ val, err := c.Get("test_key_1")
+ require.NoError(t, err)
+ assert.Equal(t, "test_val_1", val.(string))
+ }
+
+ {
+ err := c.Set("test_key_2", "test_val_2")
+ require.NoError(t, err)
+
+ val, err := c.Get("test_key_1")
+ assert.True(t, errors.Is(err, ErrNotFound))
+ assert.Nil(t, val)
+ val, err = c.Get("test_key_2")
+ require.NoError(t, err)
+ assert.Equal(t, "test_val_2", val.(string))
+ }
+
+ })
+ t.Run("TTL expired", func(t *testing.T) {
+ c := NewCache(10, 10*time.Millisecond)
+
+ err := c.Set("test_key", "test_val")
+ require.NoError(t, err)
+
+ val, err := c.Get("test_key")
+ require.NoError(t, err)
+ assert.Equal(t, "test_val", val.(string))
+
+ time.Sleep(15 * time.Millisecond)
+
+ val, err = c.Get("test_key")
+ assert.True(t, errors.Is(err, ErrNotFound))
+ assert.Nil(t, val)
+ })
+}
diff --git a/pkg/collaborators/collaborator.go b/pkg/collaborators/collaborator.go
new file mode 100644
index 0000000000000000000000000000000000000000..701d8e85b578dafc2036c281c204720080412ac5
--- /dev/null
+++ b/pkg/collaborators/collaborator.go
@@ -0,0 +1,7 @@
+package collaborators
+
+type Collaborator struct {
+ SpaceID string `bson:"spaceId"`
+ Subject string `bson:"subject"`
+ Role string `bson:"role"`
+}
diff --git a/pkg/collaborators/mocks/Collaborators.go b/pkg/collaborators/mocks/Collaborators.go
new file mode 100644
index 0000000000000000000000000000000000000000..6bcd7fb1c462ae85ef01ca50efa6145ce2f8d591
--- /dev/null
+++ b/pkg/collaborators/mocks/Collaborators.go
@@ -0,0 +1,110 @@
+// Code generated by mockery v2.7.4. DO NOT EDIT.
+
+package mocks
+
+import (
+ context "context"
+
+ collaborators "git.perx.ru/perxis/perxis-go/pkg/collaborators"
+ mock "github.com/stretchr/testify/mock"
+)
+
+// Collaborators is an autogenerated mock type for the Collaborators type
+type Collaborators struct {
+ mock.Mock
+}
+
+// Get provides a mock function with given fields: ctx, spaceId, userId
+func (_m *Collaborators) Get(ctx context.Context, spaceId, subject string) (string, error) {
+ ret := _m.Called(ctx, spaceId, subject)
+
+ var r0 string
+ if rf, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
+ r0 = rf(ctx, spaceId, subject)
+ } else {
+ r0 = ret.Get(0).(string)
+ }
+
+ var r1 error
+ if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
+ r1 = rf(ctx, spaceId, subject)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// ListCollaborators provides a mock function with given fields: ctx, spaceId
+func (_m *Collaborators) ListCollaborators(ctx context.Context, spaceId string) ([]*collaborators.Collaborator, error) {
+ ret := _m.Called(ctx, spaceId)
+
+ var r0 []*collaborators.Collaborator
+ if rf, ok := ret.Get(0).(func(context.Context, string) []*collaborators.Collaborator); ok {
+ r0 = rf(ctx, spaceId)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]*collaborators.Collaborator)
+ }
+ }
+
+ var r1 error
+ if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+ r1 = rf(ctx, spaceId)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// ListSpaces provides a mock function with given fields: ctx, userId
+func (_m *Collaborators) ListSpaces(ctx context.Context, subject string) ([]*collaborators.Collaborator, error) {
+ ret := _m.Called(ctx, subject)
+
+ var r0 []*collaborators.Collaborator
+ if rf, ok := ret.Get(0).(func(context.Context, string) []*collaborators.Collaborator); ok {
+ r0 = rf(ctx, subject)
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]*collaborators.Collaborator)
+ }
+ }
+
+ var r1 error
+ if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+ r1 = rf(ctx, subject)
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// Remove provides a mock function with given fields: ctx, spaceId, userId
+func (_m *Collaborators) Remove(ctx context.Context, spaceId, subject string) error {
+ ret := _m.Called(ctx, spaceId, subject)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
+ r0 = rf(ctx, spaceId, subject)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
+// Set provides a mock function with given fields: ctx, spaceId, userId, role
+func (_m *Collaborators) Set(ctx context.Context, spaceId, subject, role string) error {
+ ret := _m.Called(ctx, spaceId, subject, role)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
+ r0 = rf(ctx, spaceId, subject, role)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
diff --git a/pkg/collaborators/service.go b/pkg/collaborators/service.go
new file mode 100644
index 0000000000000000000000000000000000000000..fa56271b89e57a87fc501a11a1ae648f6214a7d5
--- /dev/null
+++ b/pkg/collaborators/service.go
@@ -0,0 +1,26 @@
+package collaborators
+
+import (
+ "context"
+)
+
+// @microgen grpc, recovering, middleware
+// @protobuf git.perx.ru/perxis/perxis-go/proto/collaborators
+// @grpc-addr content.collaborators.Collaborators
+type Collaborators interface {
+
+ // Set - устанавливает участие пользователя в пространстве и его роль
+ Set(ctx context.Context, spaceId, subject, role string) (err error)
+
+ // Get - возвращает роль пользователя в пространстве
+ Get(ctx context.Context, spaceId, subject string) (role string, err error)
+
+ // Remove - удаляет участие пользователя в пространстве
+ Remove(ctx context.Context, spaceId, subject string) (err error)
+
+ // ListCollaborators - возвращает участников пространства и их ролей
+ ListCollaborators(ctx context.Context, spaceId string) (collaborators []*Collaborator, err error)
+
+ // ListSpaces - возвращает список пространств пользователя
+ ListSpaces(ctx context.Context, subject string) (spaces []*Collaborator, err error)
+}
diff --git a/pkg/collaborators/transport/client.microgen.go b/pkg/collaborators/transport/client.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..eb0dbbe7bc1ea7bad07220fba5cdc6e3b1c9e503
--- /dev/null
+++ b/pkg/collaborators/transport/client.microgen.go
@@ -0,0 +1,82 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+ "context"
+ "errors"
+
+ collaborators "git.perx.ru/perxis/perxis-go/pkg/collaborators"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+)
+
+func (set EndpointsSet) Set(arg0 context.Context, arg1 string, arg2 string, arg3 string) (res0 error) {
+ request := SetRequest{
+ Role: arg3,
+ SpaceId: arg1,
+ Subject: arg2,
+ }
+ _, res0 = set.SetEndpoint(arg0, &request)
+ if res0 != nil {
+ if e, ok := status.FromError(res0); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+ res0 = errors.New(e.Message())
+ }
+ return
+ }
+ return res0
+}
+
+func (set EndpointsSet) Get(arg0 context.Context, arg1 string, arg2 string) (res0 string, res1 error) {
+ request := GetRequest{
+ SpaceId: arg1,
+ Subject: arg2,
+ }
+ response, res1 := set.GetEndpoint(arg0, &request)
+ if res1 != nil {
+ if e, ok := status.FromError(res1); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+ res1 = errors.New(e.Message())
+ }
+ return
+ }
+ return response.(*GetResponse).Role, res1
+}
+
+func (set EndpointsSet) Remove(arg0 context.Context, arg1 string, arg2 string) (res0 error) {
+ request := RemoveRequest{
+ SpaceId: arg1,
+ Subject: arg2,
+ }
+ _, res0 = set.RemoveEndpoint(arg0, &request)
+ if res0 != nil {
+ if e, ok := status.FromError(res0); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+ res0 = errors.New(e.Message())
+ }
+ return
+ }
+ return res0
+}
+
+func (set EndpointsSet) ListCollaborators(arg0 context.Context, arg1 string) (res0 []*collaborators.Collaborator, res1 error) {
+ request := ListCollaboratorsRequest{SpaceId: arg1}
+ response, res1 := set.ListCollaboratorsEndpoint(arg0, &request)
+ if res1 != nil {
+ if e, ok := status.FromError(res1); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+ res1 = errors.New(e.Message())
+ }
+ return
+ }
+ return response.(*ListCollaboratorsResponse).Collaborators, res1
+}
+
+func (set EndpointsSet) ListSpaces(arg0 context.Context, arg1 string) (res0 []*collaborators.Collaborator, res1 error) {
+ request := ListSpacesRequest{Subject: arg1}
+ response, res1 := set.ListSpacesEndpoint(arg0, &request)
+ if res1 != nil {
+ if e, ok := status.FromError(res1); ok || e.Code() == codes.Internal || e.Code() == codes.Unknown {
+ res1 = errors.New(e.Message())
+ }
+ return
+ }
+ return response.(*ListSpacesResponse).Spaces, res1
+}
diff --git a/pkg/collaborators/transport/endpoints.microgen.go b/pkg/collaborators/transport/endpoints.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..022bf403e3a574918d006786c54cfc854f318915
--- /dev/null
+++ b/pkg/collaborators/transport/endpoints.microgen.go
@@ -0,0 +1,14 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import endpoint "github.com/go-kit/kit/endpoint"
+
+// EndpointsSet implements Collaborators API and used for transport purposes.
+type EndpointsSet struct {
+ SetEndpoint endpoint.Endpoint
+ GetEndpoint endpoint.Endpoint
+ RemoveEndpoint endpoint.Endpoint
+ ListCollaboratorsEndpoint endpoint.Endpoint
+ ListSpacesEndpoint endpoint.Endpoint
+}
diff --git a/pkg/collaborators/transport/exchanges.microgen.go b/pkg/collaborators/transport/exchanges.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..a51674f40f696f15d1f625fbf7923bdd4879e6b5
--- /dev/null
+++ b/pkg/collaborators/transport/exchanges.microgen.go
@@ -0,0 +1,44 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import collaborators "git.perx.ru/perxis/perxis-go/pkg/collaborators"
+
+type (
+ SetRequest struct {
+ SpaceId string `json:"space_id"`
+ Subject string `json:"subject"`
+ Role string `json:"role"`
+ }
+ // Formal exchange type, please do not delete.
+ SetResponse struct{}
+
+ GetRequest struct {
+ SpaceId string `json:"space_id"`
+ Subject string `json:"subject"`
+ }
+ GetResponse struct {
+ Role string `json:"role"`
+ }
+
+ RemoveRequest struct {
+ SpaceId string `json:"space_id"`
+ Subject string `json:"subject"`
+ }
+ // Formal exchange type, please do not delete.
+ RemoveResponse struct{}
+
+ ListCollaboratorsRequest struct {
+ SpaceId string `json:"space_id"`
+ }
+ ListCollaboratorsResponse struct {
+ Collaborators []*collaborators.Collaborator `json:"collaborators"`
+ }
+
+ ListSpacesRequest struct {
+ Subject string `json:"subject"`
+ }
+ ListSpacesResponse struct {
+ Spaces []*collaborators.Collaborator `json:"spaces"`
+ }
+)
diff --git a/pkg/collaborators/transport/grpc/client.microgen.go b/pkg/collaborators/transport/grpc/client.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..eaf778f878438fc2a44ef980a25a3aed803fcee8
--- /dev/null
+++ b/pkg/collaborators/transport/grpc/client.microgen.go
@@ -0,0 +1,54 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transportgrpc
+
+import (
+ transport "git.perx.ru/perxis/perxis-go/pkg/collaborators/transport"
+ pb "git.perx.ru/perxis/perxis-go/proto/collaborators"
+ grpckit "github.com/go-kit/kit/transport/grpc"
+ empty "github.com/golang/protobuf/ptypes/empty"
+ grpc "google.golang.org/grpc"
+)
+
+func NewGRPCClient(conn *grpc.ClientConn, addr string, opts ...grpckit.ClientOption) transport.EndpointsSet {
+ if addr == "" {
+ addr = "content.collaborators.Collaborators"
+ }
+ return transport.EndpointsSet{
+ GetEndpoint: grpckit.NewClient(
+ conn, addr, "Get",
+ _Encode_Get_Request,
+ _Decode_Get_Response,
+ pb.GetResponse{},
+ opts...,
+ ).Endpoint(),
+ ListCollaboratorsEndpoint: grpckit.NewClient(
+ conn, addr, "ListCollaborators",
+ _Encode_ListCollaborators_Request,
+ _Decode_ListCollaborators_Response,
+ pb.ListCollaboratorsResponse{},
+ opts...,
+ ).Endpoint(),
+ ListSpacesEndpoint: grpckit.NewClient(
+ conn, addr, "ListSpaces",
+ _Encode_ListSpaces_Request,
+ _Decode_ListSpaces_Response,
+ pb.ListSpacesResponse{},
+ opts...,
+ ).Endpoint(),
+ RemoveEndpoint: grpckit.NewClient(
+ conn, addr, "Remove",
+ _Encode_Remove_Request,
+ _Decode_Remove_Response,
+ empty.Empty{},
+ opts...,
+ ).Endpoint(),
+ SetEndpoint: grpckit.NewClient(
+ conn, addr, "Set",
+ _Encode_Set_Request,
+ _Decode_Set_Response,
+ empty.Empty{},
+ opts...,
+ ).Endpoint(),
+ }
+}
diff --git a/pkg/collaborators/transport/grpc/protobuf_endpoint_converters.microgen.go b/pkg/collaborators/transport/grpc/protobuf_endpoint_converters.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..ec484dfe3b9a8ee1cb38d1d1d03cbfc5ce7a1f8a
--- /dev/null
+++ b/pkg/collaborators/transport/grpc/protobuf_endpoint_converters.microgen.go
@@ -0,0 +1,193 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+// Please, do not change functions names!
+package transportgrpc
+
+import (
+ "context"
+ "errors"
+
+ transport "git.perx.ru/perxis/perxis-go/pkg/collaborators/transport"
+ pb "git.perx.ru/perxis/perxis-go/proto/collaborators"
+ empty "github.com/golang/protobuf/ptypes/empty"
+)
+
+func _Encode_Set_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil SetRequest")
+ }
+ req := request.(*transport.SetRequest)
+ return &pb.SetRequest{
+ Role: req.Role,
+ SpaceId: req.SpaceId,
+ Subject: req.Subject,
+ }, nil
+}
+
+func _Encode_Get_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil GetRequest")
+ }
+ req := request.(*transport.GetRequest)
+ return &pb.GetRequest{
+ SpaceId: req.SpaceId,
+ Subject: req.Subject,
+ }, nil
+}
+
+func _Encode_Remove_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil RemoveRequest")
+ }
+ req := request.(*transport.RemoveRequest)
+ return &pb.RemoveRequest{
+ SpaceId: req.SpaceId,
+ Subject: req.Subject,
+ }, nil
+}
+
+func _Encode_ListCollaborators_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil ListCollaboratorsRequest")
+ }
+ req := request.(*transport.ListCollaboratorsRequest)
+ return &pb.ListCollaboratorsRequest{SpaceId: req.SpaceId}, nil
+}
+
+func _Encode_ListSpaces_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil ListSpacesRequest")
+ }
+ req := request.(*transport.ListSpacesRequest)
+ return &pb.ListSpacesRequest{Subject: req.Subject}, nil
+}
+
+func _Encode_Set_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ return &empty.Empty{}, nil
+}
+
+func _Encode_Get_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ if response == nil {
+ return nil, errors.New("nil GetResponse")
+ }
+ resp := response.(*transport.GetResponse)
+ return &pb.GetResponse{Role: resp.Role}, nil
+}
+
+func _Encode_Remove_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ return &empty.Empty{}, nil
+}
+
+func _Encode_ListCollaborators_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ if response == nil {
+ return nil, errors.New("nil ListCollaboratorsResponse")
+ }
+ resp := response.(*transport.ListCollaboratorsResponse)
+ respCollaborators, err := ListPtrCollaboratorToProto(resp.Collaborators)
+ if err != nil {
+ return nil, err
+ }
+ return &pb.ListCollaboratorsResponse{Collaborators: respCollaborators}, nil
+}
+
+func _Encode_ListSpaces_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ if response == nil {
+ return nil, errors.New("nil ListSpacesResponse")
+ }
+ resp := response.(*transport.ListSpacesResponse)
+ respSpaces, err := ListPtrCollaboratorToProto(resp.Spaces)
+ if err != nil {
+ return nil, err
+ }
+ return &pb.ListSpacesResponse{Spaces: respSpaces}, nil
+}
+
+func _Decode_Set_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil SetRequest")
+ }
+ req := request.(*pb.SetRequest)
+ return &transport.SetRequest{
+ Role: string(req.Role),
+ SpaceId: string(req.SpaceId),
+ Subject: string(req.Subject),
+ }, nil
+}
+
+func _Decode_Get_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil GetRequest")
+ }
+ req := request.(*pb.GetRequest)
+ return &transport.GetRequest{
+ SpaceId: string(req.SpaceId),
+ Subject: string(req.Subject),
+ }, nil
+}
+
+func _Decode_Remove_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil RemoveRequest")
+ }
+ req := request.(*pb.RemoveRequest)
+ return &transport.RemoveRequest{
+ SpaceId: string(req.SpaceId),
+ Subject: string(req.Subject),
+ }, nil
+}
+
+func _Decode_ListCollaborators_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil ListCollaboratorsRequest")
+ }
+ req := request.(*pb.ListCollaboratorsRequest)
+ return &transport.ListCollaboratorsRequest{SpaceId: string(req.SpaceId)}, nil
+}
+
+func _Decode_ListSpaces_Request(ctx context.Context, request interface{}) (interface{}, error) {
+ if request == nil {
+ return nil, errors.New("nil ListSpacesRequest")
+ }
+ req := request.(*pb.ListSpacesRequest)
+ return &transport.ListSpacesRequest{Subject: string(req.Subject)}, nil
+}
+
+func _Decode_Set_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ return &empty.Empty{}, nil
+}
+
+func _Decode_Get_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ if response == nil {
+ return nil, errors.New("nil GetResponse")
+ }
+ resp := response.(*pb.GetResponse)
+ return &transport.GetResponse{Role: string(resp.Role)}, nil
+}
+
+func _Decode_Remove_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ return &empty.Empty{}, nil
+}
+
+func _Decode_ListCollaborators_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ if response == nil {
+ return nil, errors.New("nil ListCollaboratorsResponse")
+ }
+ resp := response.(*pb.ListCollaboratorsResponse)
+ respCollaborators, err := ProtoToListPtrCollaborator(resp.Collaborators)
+ if err != nil {
+ return nil, err
+ }
+ return &transport.ListCollaboratorsResponse{Collaborators: respCollaborators}, nil
+}
+
+func _Decode_ListSpaces_Response(ctx context.Context, response interface{}) (interface{}, error) {
+ if response == nil {
+ return nil, errors.New("nil ListSpacesResponse")
+ }
+ resp := response.(*pb.ListSpacesResponse)
+ respSpaces, err := ProtoToListPtrCollaborator(resp.Spaces)
+ if err != nil {
+ return nil, err
+ }
+ return &transport.ListSpacesResponse{Spaces: respSpaces}, nil
+}
diff --git a/pkg/collaborators/transport/grpc/protobuf_type_converters.microgen.go b/pkg/collaborators/transport/grpc/protobuf_type_converters.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..5752acdf6235ab7b1bd09a46fc9ff3c8467ca7df
--- /dev/null
+++ b/pkg/collaborators/transport/grpc/protobuf_type_converters.microgen.go
@@ -0,0 +1,34 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+// It is better for you if you do not change functions names!
+// This file will never be overwritten.
+package transportgrpc
+
+import (
+ service "git.perx.ru/perxis/perxis-go/pkg/collaborators"
+ pbcommon "git.perx.ru/perxis/perxis-go/proto/common"
+)
+
+func ListPtrCollaboratorToProto(collaborators []*service.Collaborator) ([]*pbcommon.Collaborator, error) {
+ protoCollaborators := make([]*pbcommon.Collaborator, 0, len(collaborators))
+ for _, c := range collaborators {
+ protoCollaborators = append(protoCollaborators, &pbcommon.Collaborator{
+ SpaceId: c.SpaceID,
+ Subject: c.Subject,
+ Role: c.Role,
+ })
+ }
+ return protoCollaborators, nil
+}
+
+func ProtoToListPtrCollaborator(protoCollaborators []*pbcommon.Collaborator) ([]*service.Collaborator, error) {
+ collaborators := make([]*service.Collaborator, 0, len(protoCollaborators))
+ for _, c := range protoCollaborators {
+ collaborators = append(collaborators, &service.Collaborator{
+ SpaceID: c.SpaceId,
+ Subject: c.Subject,
+ Role: c.Role,
+ })
+ }
+ return collaborators, nil
+}
diff --git a/pkg/collaborators/transport/grpc/server.microgen.go b/pkg/collaborators/transport/grpc/server.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ece1b8b7d40f2c78d178ea88cf2aeb2ff7bb44f
--- /dev/null
+++ b/pkg/collaborators/transport/grpc/server.microgen.go
@@ -0,0 +1,97 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+// DO NOT EDIT.
+package transportgrpc
+
+import (
+ transport "git.perx.ru/perxis/perxis-go/pkg/collaborators/transport"
+ pb "git.perx.ru/perxis/perxis-go/proto/collaborators"
+ grpc "github.com/go-kit/kit/transport/grpc"
+ empty "github.com/golang/protobuf/ptypes/empty"
+ context "golang.org/x/net/context"
+)
+
+type collaboratorsServer struct {
+ set grpc.Handler
+ get grpc.Handler
+ remove grpc.Handler
+ listCollaborators grpc.Handler
+ listSpaces grpc.Handler
+
+ pb.UnimplementedCollaboratorsServer
+}
+
+func NewGRPCServer(endpoints *transport.EndpointsSet, opts ...grpc.ServerOption) pb.CollaboratorsServer {
+ return &collaboratorsServer{
+ get: grpc.NewServer(
+ endpoints.GetEndpoint,
+ _Decode_Get_Request,
+ _Encode_Get_Response,
+ opts...,
+ ),
+ listCollaborators: grpc.NewServer(
+ endpoints.ListCollaboratorsEndpoint,
+ _Decode_ListCollaborators_Request,
+ _Encode_ListCollaborators_Response,
+ opts...,
+ ),
+ listSpaces: grpc.NewServer(
+ endpoints.ListSpacesEndpoint,
+ _Decode_ListSpaces_Request,
+ _Encode_ListSpaces_Response,
+ opts...,
+ ),
+ remove: grpc.NewServer(
+ endpoints.RemoveEndpoint,
+ _Decode_Remove_Request,
+ _Encode_Remove_Response,
+ opts...,
+ ),
+ set: grpc.NewServer(
+ endpoints.SetEndpoint,
+ _Decode_Set_Request,
+ _Encode_Set_Response,
+ opts...,
+ ),
+ }
+}
+
+func (S *collaboratorsServer) Set(ctx context.Context, req *pb.SetRequest) (*empty.Empty, error) {
+ _, resp, err := S.set.ServeGRPC(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return resp.(*empty.Empty), nil
+}
+
+func (S *collaboratorsServer) Get(ctx context.Context, req *pb.GetRequest) (*pb.GetResponse, error) {
+ _, resp, err := S.get.ServeGRPC(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return resp.(*pb.GetResponse), nil
+}
+
+func (S *collaboratorsServer) Remove(ctx context.Context, req *pb.RemoveRequest) (*empty.Empty, error) {
+ _, resp, err := S.remove.ServeGRPC(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return resp.(*empty.Empty), nil
+}
+
+func (S *collaboratorsServer) ListCollaborators(ctx context.Context, req *pb.ListCollaboratorsRequest) (*pb.ListCollaboratorsResponse, error) {
+ _, resp, err := S.listCollaborators.ServeGRPC(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return resp.(*pb.ListCollaboratorsResponse), nil
+}
+
+func (S *collaboratorsServer) ListSpaces(ctx context.Context, req *pb.ListSpacesRequest) (*pb.ListSpacesResponse, error) {
+ _, resp, err := S.listSpaces.ServeGRPC(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return resp.(*pb.ListSpacesResponse), nil
+}
diff --git a/pkg/collaborators/transport/server.microgen.go b/pkg/collaborators/transport/server.microgen.go
new file mode 100644
index 0000000000000000000000000000000000000000..7d0a571d32ebe2ec2a49190a5d79136ff96ba8c1
--- /dev/null
+++ b/pkg/collaborators/transport/server.microgen.go
@@ -0,0 +1,60 @@
+// Code generated by microgen 0.9.1. DO NOT EDIT.
+
+package transport
+
+import (
+ "context"
+
+ collaborators "git.perx.ru/perxis/perxis-go/pkg/collaborators"
+ endpoint "github.com/go-kit/kit/endpoint"
+)
+
+func Endpoints(svc collaborators.Collaborators) EndpointsSet {
+ return EndpointsSet{
+ GetEndpoint: GetEndpoint(svc),
+ ListCollaboratorsEndpoint: ListCollaboratorsEndpoint(svc),
+ ListSpacesEndpoint: ListSpacesEndpoint(svc),
+ RemoveEndpoint: RemoveEndpoint(svc),
+ SetEndpoint: SetEndpoint(svc),
+ }
+}
+
+func SetEndpoint(svc collaborators.Collaborators) endpoint.Endpoint {
+ return func(arg0 context.Context, request interface{}) (interface{}, error) {
+ req := request.(*SetRequest)
+ res0 := svc.Set(arg0, req.SpaceId, req.Subject, req.Role)
+ return &SetResponse{}, res0
+ }
+}
+
+func GetEndpoint(svc collaborators.Collaborators) endpoint.Endpoint {
+ return func(arg0 context.Context, request interface{}) (interface{}, error) {
+ req := request.(*GetRequest)
+ res0, res1 := svc.Get(arg0, req.SpaceId, req.Subject)
+ return &GetResponse{Role: res0}, res1
+ }
+}
+
+func RemoveEndpoint(svc collaborators.Collaborators) endpoint.Endpoint {
+ return func(arg0 context.Context, request interface{}) (interface{}, error) {
+ req := request.(*RemoveRequest)
+ res0 := svc.Remove(arg0, req.SpaceId, req.Subject)
+ return &RemoveResponse{}, res0
+ }
+}
+
+func ListCollaboratorsEndpoint(svc collaborators.Collaborators) endpoint.Endpoint {
+ return func(arg0 context.Context, request interface{}) (interface{}, error) {
+ req := request.(*ListCollaboratorsRequest)
+ res0, res1 := svc.ListCollaborators(arg0, req.SpaceId)
+ return &ListCollaboratorsResponse{Collaborators: res0}, res1
+ }
+}
+
+func ListSpacesEndpoint(svc collaborators.Collaborators) endpoint.Endpoint {
+ return func(arg0 context.Context, request interface{}) (interface{}, error) {
+ req := request.(*ListSpacesRequest)
+ res0, res1 := svc.ListSpaces(arg0, req.Subject)
+ return &ListSpacesResponse{Spaces: res0}, res1
+ }
+}