From 9a956bba661e8da8026a9a6ddf3754d6da03476e Mon Sep 17 00:00:00 2001 From: Max Levitskiy Date: Sat, 30 Apr 2022 18:51:29 +0200 Subject: [PATCH] scaffold event message --- docs/static/openapi.yml | 305 +++ proto/story/event.proto | 16 + proto/story/genesis.proto | 3 + proto/story/query.proto | 30 +- proto/story/tx.proto | 42 +- .../story/webtree.story.story/index.ts | 150 +- .../story/webtree.story.story/module/index.ts | 9 + .../story/webtree.story.story/module/rest.ts | 148 +- .../module/types/story/event.ts | 251 +++ .../module/types/story/genesis.ts | 75 +- .../module/types/story/query.ts | 345 ++- .../module/types/story/tx.ts | 706 +++++- x/story/client/cli/query.go | 2 + x/story/client/cli/query_event.go | 77 + x/story/client/cli/query_event_test.go | 153 ++ x/story/client/cli/tx.go | 3 + x/story/client/cli/tx_event.go | 115 + x/story/client/cli/tx_event_test.go | 164 ++ x/story/genesis.go | 9 + x/story/genesis_test.go | 11 + x/story/handler.go | 16 +- x/story/keeper/event.go | 106 + x/story/keeper/event_test.go | 59 + x/story/keeper/grpc_query_event.go | 55 + x/story/keeper/grpc_query_event_test.go | 117 + x/story/keeper/msg_server_event.go | 84 + x/story/keeper/msg_server_event_test.go | 96 + x/story/module.go | 4 +- x/story/module_simulation.go | 58 +- x/story/simulation/event.go | 134 ++ x/story/types/codec.go | 10 +- x/story/types/event.pb.go | 712 ++++++ x/story/types/genesis.go | 17 +- x/story/types/genesis.pb.go | 126 +- x/story/types/genesis_test.go | 35 + x/story/types/keys.go | 5 + x/story/types/messages_event.go | 138 ++ x/story/types/messages_event_test.go | 102 + x/story/types/query.pb.go | 878 +++++++- x/story/types/query.pb.gw.go | 184 ++ x/story/types/tx.pb.go | 1947 ++++++++++++++++- 41 files changed, 7433 insertions(+), 64 deletions(-) create mode 100644 proto/story/event.proto create mode 100644 vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/event.ts create mode 100644 x/story/client/cli/query_event.go create mode 100644 x/story/client/cli/query_event_test.go create mode 100644 x/story/client/cli/tx_event.go create mode 100644 x/story/client/cli/tx_event_test.go create mode 100644 x/story/keeper/event.go create mode 100644 x/story/keeper/event_test.go create mode 100644 x/story/keeper/grpc_query_event.go create mode 100644 x/story/keeper/grpc_query_event_test.go create mode 100644 x/story/keeper/msg_server_event.go create mode 100644 x/story/keeper/msg_server_event_test.go create mode 100644 x/story/simulation/event.go create mode 100644 x/story/types/event.pb.go create mode 100644 x/story/types/messages_event.go create mode 100644 x/story/types/messages_event_test.go diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index 550303e..8a7ba1f 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -28270,6 +28270,202 @@ paths: additionalProperties: {} tags: - Query + /web-tree/story/story/event: + get: + summary: Queries a list of Event items. + operationId: WebtreeStoryStoryEventAll + responses: + '200': + description: A successful response. + schema: + type: object + properties: + Event: + type: array + items: + type: object + properties: + id: + type: string + format: uint64 + giverId: + type: string + takerId: + type: string + giverSign: + type: string + takerSign: + type: string + unionId: + type: string + typeId: + type: string + body: + type: string + creator: + type: string + pagination: + type: object + properties: + next_key: + type: string + format: byte + title: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: >- + PageResponse is to be embedded in gRPC response messages where + the + + corresponding request message has used PageRequest. + + message SomeResponse { + repeated Bar results = 1; + PageResponse page = 2; + } + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: pagination.key + description: |- + key is a value returned in PageResponse.next_key to begin + querying the next page most efficiently. Only one of offset or key + should be set. + in: query + required: false + type: string + format: byte + - name: pagination.offset + description: >- + offset is a numeric offset that can be used when key is unavailable. + + It is less efficient than using key. Only one of offset or key + should + + be set. + in: query + required: false + type: string + format: uint64 + - name: pagination.limit + description: >- + limit is the total number of results to be returned in the result + page. + + If left empty it will default to a value to be set by each app. + in: query + required: false + type: string + format: uint64 + - name: pagination.count_total + description: >- + count_total is set to true to indicate that the result set should + include + + a count of the total number of items available for pagination in + UIs. + + count_total is only respected when offset is used. It is ignored + when key + + is set. + in: query + required: false + type: boolean + - name: pagination.reverse + description: >- + reverse is set to true if results are to be returned in the + descending order. + + + Since: cosmos-sdk 0.43 + in: query + required: false + type: boolean + tags: + - Query + '/web-tree/story/story/event/{id}': + get: + summary: Queries a Event by id. + operationId: WebtreeStoryStoryEvent + responses: + '200': + description: A successful response. + schema: + type: object + properties: + Event: + type: object + properties: + id: + type: string + format: uint64 + giverId: + type: string + takerId: + type: string + giverSign: + type: string + takerSign: + type: string + unionId: + type: string + typeId: + type: string + body: + type: string + creator: + type: string + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: id + in: path + required: true + type: string + format: uint64 + tags: + - Query /webtree/story/story/params: get: summary: Parameters queries the parameters of the module. @@ -48502,9 +48698,118 @@ definitions: title: >- SignatureCounts contains information about signature reporting for a number of blocks + webtree.story.story.Event: + type: object + properties: + id: + type: string + format: uint64 + giverId: + type: string + takerId: + type: string + giverSign: + type: string + takerSign: + type: string + unionId: + type: string + typeId: + type: string + body: + type: string + creator: + type: string + webtree.story.story.MsgCreateEventResponse: + type: object + properties: + id: + type: string + format: uint64 + webtree.story.story.MsgDeleteEventResponse: + type: object + webtree.story.story.MsgUpdateEventResponse: + type: object webtree.story.story.Params: type: object description: Params defines the parameters for the module. + webtree.story.story.QueryAllEventResponse: + type: object + properties: + Event: + type: array + items: + type: object + properties: + id: + type: string + format: uint64 + giverId: + type: string + takerId: + type: string + giverSign: + type: string + takerSign: + type: string + unionId: + type: string + typeId: + type: string + body: + type: string + creator: + type: string + pagination: + type: object + properties: + next_key: + type: string + format: byte + title: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: |- + PageResponse is to be embedded in gRPC response messages where the + corresponding request message has used PageRequest. + + message SomeResponse { + repeated Bar results = 1; + PageResponse page = 2; + } + webtree.story.story.QueryGetEventResponse: + type: object + properties: + Event: + type: object + properties: + id: + type: string + format: uint64 + giverId: + type: string + takerId: + type: string + giverSign: + type: string + takerSign: + type: string + unionId: + type: string + typeId: + type: string + body: + type: string + creator: + type: string webtree.story.story.QueryParamsResponse: type: object properties: diff --git a/proto/story/event.proto b/proto/story/event.proto new file mode 100644 index 0000000..1997667 --- /dev/null +++ b/proto/story/event.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; +package webtree.story.story; + +option go_package = "github.com/web-tree/story/x/story/types"; + +message Event { + uint64 id = 1; + string giverId = 2; + string takerId = 3; + string giverSign = 4; + string takerSign = 5; + string unionId = 6; + string typeId = 7; + string body = 8; + string creator = 9; +} \ No newline at end of file diff --git a/proto/story/genesis.proto b/proto/story/genesis.proto index fbbd92d..ac223df 100644 --- a/proto/story/genesis.proto +++ b/proto/story/genesis.proto @@ -3,6 +3,7 @@ package webtree.story.story; import "gogoproto/gogo.proto"; import "story/params.proto"; +import "story/event.proto"; // this line is used by starport scaffolding # genesis/proto/import option go_package = "github.com/web-tree/story/x/story/types"; @@ -11,5 +12,7 @@ option go_package = "github.com/web-tree/story/x/story/types"; message GenesisState { Params params = 1 [(gogoproto.nullable) = false]; string port_id = 2; + repeated Event eventList = 3 [(gogoproto.nullable) = false]; + uint64 eventCount = 4; // this line is used by starport scaffolding # genesis/proto/state } diff --git a/proto/story/query.proto b/proto/story/query.proto index ad9ed3c..943b92d 100644 --- a/proto/story/query.proto +++ b/proto/story/query.proto @@ -5,6 +5,7 @@ import "gogoproto/gogo.proto"; import "google/api/annotations.proto"; import "cosmos/base/query/v1beta1/pagination.proto"; import "story/params.proto"; +import "story/event.proto"; // this line is used by starport scaffolding # 1 option go_package = "github.com/web-tree/story/x/story/types"; @@ -15,7 +16,17 @@ service Query { rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { option (google.api.http).get = "/webtree/story/story/params"; } - // this line is used by starport scaffolding # 2 + // Queries a Event by id. + rpc Event(QueryGetEventRequest) returns (QueryGetEventResponse) { + option (google.api.http).get = "/web-tree/story/story/event/{id}"; + } + + // Queries a list of Event items. + rpc EventAll(QueryAllEventRequest) returns (QueryAllEventResponse) { + option (google.api.http).get = "/web-tree/story/story/event"; + } + +// this line is used by starport scaffolding # 2 } // QueryParamsRequest is request type for the Query/Params RPC method. @@ -27,4 +38,21 @@ message QueryParamsResponse { Params params = 1 [(gogoproto.nullable) = false]; } +message QueryGetEventRequest { + uint64 id = 1; +} + +message QueryGetEventResponse { + Event Event = 1 [(gogoproto.nullable) = false]; +} + +message QueryAllEventRequest { + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +message QueryAllEventResponse { + repeated Event Event = 1 [(gogoproto.nullable) = false]; + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + // this line is used by starport scaffolding # 3 diff --git a/proto/story/tx.proto b/proto/story/tx.proto index ad0eac5..6145427 100644 --- a/proto/story/tx.proto +++ b/proto/story/tx.proto @@ -1,13 +1,53 @@ syntax = "proto3"; package webtree.story.story; +import "story/event.proto"; // this line is used by starport scaffolding # proto/tx/import option go_package = "github.com/web-tree/story/x/story/types"; // Msg defines the Msg service. service Msg { - // this line is used by starport scaffolding # proto/tx/rpc + rpc CreateEvent(MsgCreateEvent) returns (MsgCreateEventResponse); + rpc UpdateEvent(MsgUpdateEvent) returns (MsgUpdateEventResponse); + rpc DeleteEvent(MsgDeleteEvent) returns (MsgDeleteEventResponse); +// this line is used by starport scaffolding # proto/tx/rpc } +message MsgCreateEvent { + string creator = 1; + string giverId = 2; + string takerId = 3; + string giverSign = 4; + string takerSign = 5; + string unionId = 6; + string typeId = 7; + string body = 8; +} + +message MsgCreateEventResponse { + uint64 id = 1; +} + +message MsgUpdateEvent { + string creator = 1; + uint64 id = 2; + string giverId = 3; + string takerId = 4; + string giverSign = 5; + string takerSign = 6; + string unionId = 7; + string typeId = 8; + string body = 9; +} + +message MsgUpdateEventResponse {} + +message MsgDeleteEvent { + string creator = 1; + uint64 id = 2; +} + +message MsgDeleteEventResponse {} + // this line is used by starport scaffolding # proto/tx/message \ No newline at end of file diff --git a/vue/src/store/generated/web-tree/story/webtree.story.story/index.ts b/vue/src/store/generated/web-tree/story/webtree.story.story/index.ts index fd6667e..04a583a 100755 --- a/vue/src/store/generated/web-tree/story/webtree.story.story/index.ts +++ b/vue/src/store/generated/web-tree/story/webtree.story.story/index.ts @@ -1,11 +1,12 @@ import { txClient, queryClient, MissingWalletError , registry} from './module' +import { Event } from "./module/types/story/event" import { StoryPacketData } from "./module/types/story/packet" import { NoData } from "./module/types/story/packet" import { Params } from "./module/types/story/params" -export { StoryPacketData, NoData, Params }; +export { Event, StoryPacketData, NoData, Params }; async function initTxClient(vuexGetters) { return await txClient(vuexGetters['common/wallet/signer'], { @@ -44,8 +45,11 @@ function getStructure(template) { const getDefaultState = () => { return { Params: {}, + Event: {}, + EventAll: {}, _Structure: { + Event: getStructure(Event.fromPartial({})), StoryPacketData: getStructure(StoryPacketData.fromPartial({})), NoData: getStructure(NoData.fromPartial({})), Params: getStructure(Params.fromPartial({})), @@ -83,6 +87,18 @@ export default { } return state.Params[JSON.stringify(params)] ?? {} }, + getEvent: (state) => (params = { params: {}}) => { + if (!( params).query) { + ( params).query=null + } + return state.Event[JSON.stringify(params)] ?? {} + }, + getEventAll: (state) => (params = { params: {}}) => { + if (!( params).query) { + ( params).query=null + } + return state.EventAll[JSON.stringify(params)] ?? {} + }, getTypeStructure: (state) => (type) => { return state._Structure[type].fields @@ -141,5 +157,137 @@ export default { + + + + async QueryEvent({ commit, rootGetters, getters }, { options: { subscribe, all} = { subscribe:false, all:false}, params, query=null }) { + try { + const key = params ?? {}; + const queryClient=await initQueryClient(rootGetters) + let value= (await queryClient.queryEvent( key.id)).data + + + commit('QUERY', { query: 'Event', key: { params: {...key}, query}, value }) + if (subscribe) commit('SUBSCRIBE', { action: 'QueryEvent', payload: { options: { all }, params: {...key},query }}) + return getters['getEvent']( { params: {...key}, query}) ?? {} + } catch (e) { + throw new Error('QueryClient:QueryEvent API Node Unavailable. Could not perform query: ' + e.message) + + } + }, + + + + + + + + async QueryEventAll({ commit, rootGetters, getters }, { options: { subscribe, all} = { subscribe:false, all:false}, params, query=null }) { + try { + const key = params ?? {}; + const queryClient=await initQueryClient(rootGetters) + let value= (await queryClient.queryEventAll(query)).data + + + while (all && ( value).pagination && ( value).pagination.next_key!=null) { + let next_values=(await queryClient.queryEventAll({...query, 'pagination.key':( value).pagination.next_key})).data + value = mergeResults(value, next_values); + } + commit('QUERY', { query: 'EventAll', key: { params: {...key}, query}, value }) + if (subscribe) commit('SUBSCRIBE', { action: 'QueryEventAll', payload: { options: { all }, params: {...key},query }}) + return getters['getEventAll']( { params: {...key}, query}) ?? {} + } catch (e) { + throw new Error('QueryClient:QueryEventAll API Node Unavailable. Could not perform query: ' + e.message) + + } + }, + + + async sendMsgCreateEvent({ rootGetters }, { value, fee = [], memo = '' }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgCreateEvent(value) + const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, + gas: "200000" }, memo}) + return result + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgCreateEvent:Init Could not initialize signing client. Wallet is required.') + }else{ + throw new Error('TxClient:MsgCreateEvent:Send Could not broadcast Tx: '+ e.message) + } + } + }, + async sendMsgUpdateEvent({ rootGetters }, { value, fee = [], memo = '' }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgUpdateEvent(value) + const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, + gas: "200000" }, memo}) + return result + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgUpdateEvent:Init Could not initialize signing client. Wallet is required.') + }else{ + throw new Error('TxClient:MsgUpdateEvent:Send Could not broadcast Tx: '+ e.message) + } + } + }, + async sendMsgDeleteEvent({ rootGetters }, { value, fee = [], memo = '' }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgDeleteEvent(value) + const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, + gas: "200000" }, memo}) + return result + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgDeleteEvent:Init Could not initialize signing client. Wallet is required.') + }else{ + throw new Error('TxClient:MsgDeleteEvent:Send Could not broadcast Tx: '+ e.message) + } + } + }, + + async MsgCreateEvent({ rootGetters }, { value }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgCreateEvent(value) + return msg + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgCreateEvent:Init Could not initialize signing client. Wallet is required.') + } else{ + throw new Error('TxClient:MsgCreateEvent:Create Could not create message: ' + e.message) + } + } + }, + async MsgUpdateEvent({ rootGetters }, { value }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgUpdateEvent(value) + return msg + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgUpdateEvent:Init Could not initialize signing client. Wallet is required.') + } else{ + throw new Error('TxClient:MsgUpdateEvent:Create Could not create message: ' + e.message) + } + } + }, + async MsgDeleteEvent({ rootGetters }, { value }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgDeleteEvent(value) + return msg + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgDeleteEvent:Init Could not initialize signing client. Wallet is required.') + } else{ + throw new Error('TxClient:MsgDeleteEvent:Create Could not create message: ' + e.message) + } + } + }, + } } diff --git a/vue/src/store/generated/web-tree/story/webtree.story.story/module/index.ts b/vue/src/store/generated/web-tree/story/webtree.story.story/module/index.ts index 67d4b09..e1562eb 100755 --- a/vue/src/store/generated/web-tree/story/webtree.story.story/module/index.ts +++ b/vue/src/store/generated/web-tree/story/webtree.story.story/module/index.ts @@ -4,9 +4,15 @@ import { StdFee } from "@cosmjs/launchpad"; import { SigningStargateClient } from "@cosmjs/stargate"; import { Registry, OfflineSigner, EncodeObject, DirectSecp256k1HdWallet } from "@cosmjs/proto-signing"; import { Api } from "./rest"; +import { MsgCreateEvent } from "./types/story/tx"; +import { MsgUpdateEvent } from "./types/story/tx"; +import { MsgDeleteEvent } from "./types/story/tx"; const types = [ + ["/webtree.story.story.MsgCreateEvent", MsgCreateEvent], + ["/webtree.story.story.MsgUpdateEvent", MsgUpdateEvent], + ["/webtree.story.story.MsgDeleteEvent", MsgDeleteEvent], ]; export const MissingWalletError = new Error("wallet is required"); @@ -39,6 +45,9 @@ const txClient = async (wallet: OfflineSigner, { addr: addr }: TxClientOptions = return { signAndBroadcast: (msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions = {fee: defaultFee, memo: ""}) => client.signAndBroadcast(address, msgs, fee,memo), + msgCreateEvent: (data: MsgCreateEvent): EncodeObject => ({ typeUrl: "/webtree.story.story.MsgCreateEvent", value: MsgCreateEvent.fromPartial( data ) }), + msgUpdateEvent: (data: MsgUpdateEvent): EncodeObject => ({ typeUrl: "/webtree.story.story.MsgUpdateEvent", value: MsgUpdateEvent.fromPartial( data ) }), + msgDeleteEvent: (data: MsgDeleteEvent): EncodeObject => ({ typeUrl: "/webtree.story.story.MsgDeleteEvent", value: MsgDeleteEvent.fromPartial( data ) }), }; }; diff --git a/vue/src/store/generated/web-tree/story/webtree.story.story/module/rest.ts b/vue/src/store/generated/web-tree/story/webtree.story.story/module/rest.ts index 9efd775..89f4247 100644 --- a/vue/src/store/generated/web-tree/story/webtree.story.story/module/rest.ts +++ b/vue/src/store/generated/web-tree/story/webtree.story.story/module/rest.ts @@ -20,11 +20,52 @@ export interface RpcStatus { details?: ProtobufAny[]; } +export interface StoryEvent { + /** @format uint64 */ + id?: string; + giverId?: string; + takerId?: string; + giverSign?: string; + takerSign?: string; + unionId?: string; + typeId?: string; + body?: string; + creator?: string; +} + +export interface StoryMsgCreateEventResponse { + /** @format uint64 */ + id?: string; +} + +export type StoryMsgDeleteEventResponse = object; + +export type StoryMsgUpdateEventResponse = object; + /** * Params defines the parameters for the module. */ export type StoryParams = object; +export interface StoryQueryAllEventResponse { + Event?: StoryEvent[]; + + /** + * PageResponse is to be embedded in gRPC response messages where the + * corresponding request message has used PageRequest. + * + * message SomeResponse { + * repeated Bar results = 1; + * PageResponse page = 2; + * } + */ + pagination?: V1Beta1PageResponse; +} + +export interface StoryQueryGetEventResponse { + Event?: StoryEvent; +} + /** * QueryParamsResponse is response type for the Query/Params RPC method. */ @@ -33,6 +74,69 @@ export interface StoryQueryParamsResponse { params?: StoryParams; } +/** +* message SomeRequest { + Foo some_parameter = 1; + PageRequest pagination = 2; + } +*/ +export interface V1Beta1PageRequest { + /** + * key is a value returned in PageResponse.next_key to begin + * querying the next page most efficiently. Only one of offset or key + * should be set. + * @format byte + */ + key?: string; + + /** + * offset is a numeric offset that can be used when key is unavailable. + * It is less efficient than using key. Only one of offset or key should + * be set. + * @format uint64 + */ + offset?: string; + + /** + * limit is the total number of results to be returned in the result page. + * If left empty it will default to a value to be set by each app. + * @format uint64 + */ + limit?: string; + + /** + * count_total is set to true to indicate that the result set should include + * a count of the total number of items available for pagination in UIs. + * count_total is only respected when offset is used. It is ignored when key + * is set. + */ + count_total?: boolean; + + /** + * reverse is set to true if results are to be returned in the descending order. + * + * Since: cosmos-sdk 0.43 + */ + reverse?: boolean; +} + +/** +* PageResponse is to be embedded in gRPC response messages where the +corresponding request message has used PageRequest. + + message SomeResponse { + repeated Bar results = 1; + PageResponse page = 2; + } +*/ +export interface V1Beta1PageResponse { + /** @format byte */ + next_key?: string; + + /** @format uint64 */ + total?: string; +} + export type QueryParamsType = Record; export type ResponseFormat = keyof Omit; @@ -225,10 +329,52 @@ export class HttpClient { } /** - * @title story/genesis.proto + * @title story/event.proto * @version version not set */ export class Api extends HttpClient { + /** + * No description + * + * @tags Query + * @name QueryEventAll + * @summary Queries a list of Event items. + * @request GET:/web-tree/story/story/event + */ + queryEventAll = ( + query?: { + "pagination.key"?: string; + "pagination.offset"?: string; + "pagination.limit"?: string; + "pagination.count_total"?: boolean; + "pagination.reverse"?: boolean; + }, + params: RequestParams = {}, + ) => + this.request({ + path: `/web-tree/story/story/event`, + method: "GET", + query: query, + format: "json", + ...params, + }); + + /** + * No description + * + * @tags Query + * @name QueryEvent + * @summary Queries a Event by id. + * @request GET:/web-tree/story/story/event/{id} + */ + queryEvent = (id: string, params: RequestParams = {}) => + this.request({ + path: `/web-tree/story/story/event/${id}`, + method: "GET", + format: "json", + ...params, + }); + /** * No description * diff --git a/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/event.ts b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/event.ts new file mode 100644 index 0000000..5efda61 --- /dev/null +++ b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/event.ts @@ -0,0 +1,251 @@ +/* eslint-disable */ +import * as Long from "long"; +import { util, configure, Writer, Reader } from "protobufjs/minimal"; + +export const protobufPackage = "webtree.story.story"; + +export interface Event { + id: number; + giverId: string; + takerId: string; + giverSign: string; + takerSign: string; + unionId: string; + typeId: string; + body: string; + creator: string; +} + +const baseEvent: object = { + id: 0, + giverId: "", + takerId: "", + giverSign: "", + takerSign: "", + unionId: "", + typeId: "", + body: "", + creator: "", +}; + +export const Event = { + encode(message: Event, writer: Writer = Writer.create()): Writer { + if (message.id !== 0) { + writer.uint32(8).uint64(message.id); + } + if (message.giverId !== "") { + writer.uint32(18).string(message.giverId); + } + if (message.takerId !== "") { + writer.uint32(26).string(message.takerId); + } + if (message.giverSign !== "") { + writer.uint32(34).string(message.giverSign); + } + if (message.takerSign !== "") { + writer.uint32(42).string(message.takerSign); + } + if (message.unionId !== "") { + writer.uint32(50).string(message.unionId); + } + if (message.typeId !== "") { + writer.uint32(58).string(message.typeId); + } + if (message.body !== "") { + writer.uint32(66).string(message.body); + } + if (message.creator !== "") { + writer.uint32(74).string(message.creator); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Event { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseEvent } as Event; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.id = longToNumber(reader.uint64() as Long); + break; + case 2: + message.giverId = reader.string(); + break; + case 3: + message.takerId = reader.string(); + break; + case 4: + message.giverSign = reader.string(); + break; + case 5: + message.takerSign = reader.string(); + break; + case 6: + message.unionId = reader.string(); + break; + case 7: + message.typeId = reader.string(); + break; + case 8: + message.body = reader.string(); + break; + case 9: + message.creator = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Event { + const message = { ...baseEvent } as Event; + if (object.id !== undefined && object.id !== null) { + message.id = Number(object.id); + } else { + message.id = 0; + } + if (object.giverId !== undefined && object.giverId !== null) { + message.giverId = String(object.giverId); + } else { + message.giverId = ""; + } + if (object.takerId !== undefined && object.takerId !== null) { + message.takerId = String(object.takerId); + } else { + message.takerId = ""; + } + if (object.giverSign !== undefined && object.giverSign !== null) { + message.giverSign = String(object.giverSign); + } else { + message.giverSign = ""; + } + if (object.takerSign !== undefined && object.takerSign !== null) { + message.takerSign = String(object.takerSign); + } else { + message.takerSign = ""; + } + if (object.unionId !== undefined && object.unionId !== null) { + message.unionId = String(object.unionId); + } else { + message.unionId = ""; + } + if (object.typeId !== undefined && object.typeId !== null) { + message.typeId = String(object.typeId); + } else { + message.typeId = ""; + } + if (object.body !== undefined && object.body !== null) { + message.body = String(object.body); + } else { + message.body = ""; + } + if (object.creator !== undefined && object.creator !== null) { + message.creator = String(object.creator); + } else { + message.creator = ""; + } + return message; + }, + + toJSON(message: Event): unknown { + const obj: any = {}; + message.id !== undefined && (obj.id = message.id); + message.giverId !== undefined && (obj.giverId = message.giverId); + message.takerId !== undefined && (obj.takerId = message.takerId); + message.giverSign !== undefined && (obj.giverSign = message.giverSign); + message.takerSign !== undefined && (obj.takerSign = message.takerSign); + message.unionId !== undefined && (obj.unionId = message.unionId); + message.typeId !== undefined && (obj.typeId = message.typeId); + message.body !== undefined && (obj.body = message.body); + message.creator !== undefined && (obj.creator = message.creator); + return obj; + }, + + fromPartial(object: DeepPartial): Event { + const message = { ...baseEvent } as Event; + if (object.id !== undefined && object.id !== null) { + message.id = object.id; + } else { + message.id = 0; + } + if (object.giverId !== undefined && object.giverId !== null) { + message.giverId = object.giverId; + } else { + message.giverId = ""; + } + if (object.takerId !== undefined && object.takerId !== null) { + message.takerId = object.takerId; + } else { + message.takerId = ""; + } + if (object.giverSign !== undefined && object.giverSign !== null) { + message.giverSign = object.giverSign; + } else { + message.giverSign = ""; + } + if (object.takerSign !== undefined && object.takerSign !== null) { + message.takerSign = object.takerSign; + } else { + message.takerSign = ""; + } + if (object.unionId !== undefined && object.unionId !== null) { + message.unionId = object.unionId; + } else { + message.unionId = ""; + } + if (object.typeId !== undefined && object.typeId !== null) { + message.typeId = object.typeId; + } else { + message.typeId = ""; + } + if (object.body !== undefined && object.body !== null) { + message.body = object.body; + } else { + message.body = ""; + } + if (object.creator !== undefined && object.creator !== null) { + message.creator = object.creator; + } else { + message.creator = ""; + } + return message; + }, +}; + +declare var self: any | undefined; +declare var window: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +function longToNumber(long: Long): number { + if (long.gt(Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (util.Long !== Long) { + util.Long = Long as any; + configure(); +} diff --git a/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/genesis.ts b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/genesis.ts index bf587b9..1ddc1c7 100644 --- a/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/genesis.ts +++ b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/genesis.ts @@ -1,17 +1,21 @@ /* eslint-disable */ +import * as Long from "long"; +import { util, configure, Writer, Reader } from "protobufjs/minimal"; import { Params } from "../story/params"; -import { Writer, Reader } from "protobufjs/minimal"; +import { Event } from "../story/event"; export const protobufPackage = "webtree.story.story"; /** GenesisState defines the story module's genesis state. */ export interface GenesisState { params: Params | undefined; - /** this line is used by starport scaffolding # genesis/proto/state */ port_id: string; + eventList: Event[]; + /** this line is used by starport scaffolding # genesis/proto/state */ + eventCount: number; } -const baseGenesisState: object = { port_id: "" }; +const baseGenesisState: object = { port_id: "", eventCount: 0 }; export const GenesisState = { encode(message: GenesisState, writer: Writer = Writer.create()): Writer { @@ -21,6 +25,12 @@ export const GenesisState = { if (message.port_id !== "") { writer.uint32(18).string(message.port_id); } + for (const v of message.eventList) { + Event.encode(v!, writer.uint32(26).fork()).ldelim(); + } + if (message.eventCount !== 0) { + writer.uint32(32).uint64(message.eventCount); + } return writer; }, @@ -28,6 +38,7 @@ export const GenesisState = { const reader = input instanceof Uint8Array ? new Reader(input) : input; let end = length === undefined ? reader.len : reader.pos + length; const message = { ...baseGenesisState } as GenesisState; + message.eventList = []; while (reader.pos < end) { const tag = reader.uint32(); switch (tag >>> 3) { @@ -37,6 +48,12 @@ export const GenesisState = { case 2: message.port_id = reader.string(); break; + case 3: + message.eventList.push(Event.decode(reader, reader.uint32())); + break; + case 4: + message.eventCount = longToNumber(reader.uint64() as Long); + break; default: reader.skipType(tag & 7); break; @@ -47,6 +64,7 @@ export const GenesisState = { fromJSON(object: any): GenesisState { const message = { ...baseGenesisState } as GenesisState; + message.eventList = []; if (object.params !== undefined && object.params !== null) { message.params = Params.fromJSON(object.params); } else { @@ -57,6 +75,16 @@ export const GenesisState = { } else { message.port_id = ""; } + if (object.eventList !== undefined && object.eventList !== null) { + for (const e of object.eventList) { + message.eventList.push(Event.fromJSON(e)); + } + } + if (object.eventCount !== undefined && object.eventCount !== null) { + message.eventCount = Number(object.eventCount); + } else { + message.eventCount = 0; + } return message; }, @@ -65,11 +93,20 @@ export const GenesisState = { message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined); message.port_id !== undefined && (obj.port_id = message.port_id); + if (message.eventList) { + obj.eventList = message.eventList.map((e) => + e ? Event.toJSON(e) : undefined + ); + } else { + obj.eventList = []; + } + message.eventCount !== undefined && (obj.eventCount = message.eventCount); return obj; }, fromPartial(object: DeepPartial): GenesisState { const message = { ...baseGenesisState } as GenesisState; + message.eventList = []; if (object.params !== undefined && object.params !== null) { message.params = Params.fromPartial(object.params); } else { @@ -80,10 +117,30 @@ export const GenesisState = { } else { message.port_id = ""; } + if (object.eventList !== undefined && object.eventList !== null) { + for (const e of object.eventList) { + message.eventList.push(Event.fromPartial(e)); + } + } + if (object.eventCount !== undefined && object.eventCount !== null) { + message.eventCount = object.eventCount; + } else { + message.eventCount = 0; + } return message; }, }; +declare var self: any | undefined; +declare var window: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + type Builtin = Date | Function | Uint8Array | string | number | undefined; export type DeepPartial = T extends Builtin ? T @@ -94,3 +151,15 @@ export type DeepPartial = T extends Builtin : T extends {} ? { [K in keyof T]?: DeepPartial } : Partial; + +function longToNumber(long: Long): number { + if (long.gt(Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (util.Long !== Long) { + util.Long = Long as any; + configure(); +} diff --git a/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/query.ts b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/query.ts index b70edda..5a5a779 100644 --- a/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/query.ts +++ b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/query.ts @@ -1,6 +1,12 @@ /* eslint-disable */ -import { Reader, Writer } from "protobufjs/minimal"; +import { Reader, util, configure, Writer } from "protobufjs/minimal"; +import * as Long from "long"; import { Params } from "../story/params"; +import { Event } from "../story/event"; +import { + PageRequest, + PageResponse, +} from "../cosmos/base/query/v1beta1/pagination"; export const protobufPackage = "webtree.story.story"; @@ -13,6 +19,23 @@ export interface QueryParamsResponse { params: Params | undefined; } +export interface QueryGetEventRequest { + id: number; +} + +export interface QueryGetEventResponse { + Event: Event | undefined; +} + +export interface QueryAllEventRequest { + pagination: PageRequest | undefined; +} + +export interface QueryAllEventResponse { + Event: Event[]; + pagination: PageResponse | undefined; +} + const baseQueryParamsRequest: object = {}; export const QueryParamsRequest = { @@ -110,10 +133,284 @@ export const QueryParamsResponse = { }, }; +const baseQueryGetEventRequest: object = { id: 0 }; + +export const QueryGetEventRequest = { + encode( + message: QueryGetEventRequest, + writer: Writer = Writer.create() + ): Writer { + if (message.id !== 0) { + writer.uint32(8).uint64(message.id); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryGetEventRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryGetEventRequest } as QueryGetEventRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.id = longToNumber(reader.uint64() as Long); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryGetEventRequest { + const message = { ...baseQueryGetEventRequest } as QueryGetEventRequest; + if (object.id !== undefined && object.id !== null) { + message.id = Number(object.id); + } else { + message.id = 0; + } + return message; + }, + + toJSON(message: QueryGetEventRequest): unknown { + const obj: any = {}; + message.id !== undefined && (obj.id = message.id); + return obj; + }, + + fromPartial(object: DeepPartial): QueryGetEventRequest { + const message = { ...baseQueryGetEventRequest } as QueryGetEventRequest; + if (object.id !== undefined && object.id !== null) { + message.id = object.id; + } else { + message.id = 0; + } + return message; + }, +}; + +const baseQueryGetEventResponse: object = {}; + +export const QueryGetEventResponse = { + encode( + message: QueryGetEventResponse, + writer: Writer = Writer.create() + ): Writer { + if (message.Event !== undefined) { + Event.encode(message.Event, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryGetEventResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryGetEventResponse } as QueryGetEventResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.Event = Event.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryGetEventResponse { + const message = { ...baseQueryGetEventResponse } as QueryGetEventResponse; + if (object.Event !== undefined && object.Event !== null) { + message.Event = Event.fromJSON(object.Event); + } else { + message.Event = undefined; + } + return message; + }, + + toJSON(message: QueryGetEventResponse): unknown { + const obj: any = {}; + message.Event !== undefined && + (obj.Event = message.Event ? Event.toJSON(message.Event) : undefined); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryGetEventResponse { + const message = { ...baseQueryGetEventResponse } as QueryGetEventResponse; + if (object.Event !== undefined && object.Event !== null) { + message.Event = Event.fromPartial(object.Event); + } else { + message.Event = undefined; + } + return message; + }, +}; + +const baseQueryAllEventRequest: object = {}; + +export const QueryAllEventRequest = { + encode( + message: QueryAllEventRequest, + writer: Writer = Writer.create() + ): Writer { + if (message.pagination !== undefined) { + PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryAllEventRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryAllEventRequest } as QueryAllEventRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pagination = PageRequest.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryAllEventRequest { + const message = { ...baseQueryAllEventRequest } as QueryAllEventRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAllEventRequest): unknown { + const obj: any = {}; + message.pagination !== undefined && + (obj.pagination = message.pagination + ? PageRequest.toJSON(message.pagination) + : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): QueryAllEventRequest { + const message = { ...baseQueryAllEventRequest } as QueryAllEventRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + +const baseQueryAllEventResponse: object = {}; + +export const QueryAllEventResponse = { + encode( + message: QueryAllEventResponse, + writer: Writer = Writer.create() + ): Writer { + for (const v of message.Event) { + Event.encode(v!, writer.uint32(10).fork()).ldelim(); + } + if (message.pagination !== undefined) { + PageResponse.encode( + message.pagination, + writer.uint32(18).fork() + ).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryAllEventResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryAllEventResponse } as QueryAllEventResponse; + message.Event = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.Event.push(Event.decode(reader, reader.uint32())); + break; + case 2: + message.pagination = PageResponse.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryAllEventResponse { + const message = { ...baseQueryAllEventResponse } as QueryAllEventResponse; + message.Event = []; + if (object.Event !== undefined && object.Event !== null) { + for (const e of object.Event) { + message.Event.push(Event.fromJSON(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAllEventResponse): unknown { + const obj: any = {}; + if (message.Event) { + obj.Event = message.Event.map((e) => (e ? Event.toJSON(e) : undefined)); + } else { + obj.Event = []; + } + message.pagination !== undefined && + (obj.pagination = message.pagination + ? PageResponse.toJSON(message.pagination) + : undefined); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryAllEventResponse { + const message = { ...baseQueryAllEventResponse } as QueryAllEventResponse; + message.Event = []; + if (object.Event !== undefined && object.Event !== null) { + for (const e of object.Event) { + message.Event.push(Event.fromPartial(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + /** Query defines the gRPC querier service. */ export interface Query { /** Parameters queries the parameters of the module. */ Params(request: QueryParamsRequest): Promise; + /** Queries a Event by id. */ + Event(request: QueryGetEventRequest): Promise; + /** Queries a list of Event items. */ + EventAll(request: QueryAllEventRequest): Promise; } export class QueryClientImpl implements Query { @@ -130,6 +427,30 @@ export class QueryClientImpl implements Query { ); return promise.then((data) => QueryParamsResponse.decode(new Reader(data))); } + + Event(request: QueryGetEventRequest): Promise { + const data = QueryGetEventRequest.encode(request).finish(); + const promise = this.rpc.request( + "webtree.story.story.Query", + "Event", + data + ); + return promise.then((data) => + QueryGetEventResponse.decode(new Reader(data)) + ); + } + + EventAll(request: QueryAllEventRequest): Promise { + const data = QueryAllEventRequest.encode(request).finish(); + const promise = this.rpc.request( + "webtree.story.story.Query", + "EventAll", + data + ); + return promise.then((data) => + QueryAllEventResponse.decode(new Reader(data)) + ); + } } interface Rpc { @@ -140,6 +461,16 @@ interface Rpc { ): Promise; } +declare var self: any | undefined; +declare var window: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + type Builtin = Date | Function | Uint8Array | string | number | undefined; export type DeepPartial = T extends Builtin ? T @@ -150,3 +481,15 @@ export type DeepPartial = T extends Builtin : T extends {} ? { [K in keyof T]?: DeepPartial } : Partial; + +function longToNumber(long: Long): number { + if (long.gt(Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (util.Long !== Long) { + util.Long = Long as any; + configure(); +} diff --git a/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/tx.ts b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/tx.ts index 66b689f..9868c4d 100644 --- a/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/tx.ts +++ b/vue/src/store/generated/web-tree/story/webtree.story.story/module/types/story/tx.ts @@ -1,14 +1,685 @@ /* eslint-disable */ +import { Reader, util, configure, Writer } from "protobufjs/minimal"; +import * as Long from "long"; + export const protobufPackage = "webtree.story.story"; +export interface MsgCreateEvent { + creator: string; + giverId: string; + takerId: string; + giverSign: string; + takerSign: string; + unionId: string; + typeId: string; + body: string; +} + +export interface MsgCreateEventResponse { + id: number; +} + +export interface MsgUpdateEvent { + creator: string; + id: number; + giverId: string; + takerId: string; + giverSign: string; + takerSign: string; + unionId: string; + typeId: string; + body: string; +} + +export interface MsgUpdateEventResponse {} + +export interface MsgDeleteEvent { + creator: string; + id: number; +} + +export interface MsgDeleteEventResponse {} + +const baseMsgCreateEvent: object = { + creator: "", + giverId: "", + takerId: "", + giverSign: "", + takerSign: "", + unionId: "", + typeId: "", + body: "", +}; + +export const MsgCreateEvent = { + encode(message: MsgCreateEvent, writer: Writer = Writer.create()): Writer { + if (message.creator !== "") { + writer.uint32(10).string(message.creator); + } + if (message.giverId !== "") { + writer.uint32(18).string(message.giverId); + } + if (message.takerId !== "") { + writer.uint32(26).string(message.takerId); + } + if (message.giverSign !== "") { + writer.uint32(34).string(message.giverSign); + } + if (message.takerSign !== "") { + writer.uint32(42).string(message.takerSign); + } + if (message.unionId !== "") { + writer.uint32(50).string(message.unionId); + } + if (message.typeId !== "") { + writer.uint32(58).string(message.typeId); + } + if (message.body !== "") { + writer.uint32(66).string(message.body); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgCreateEvent { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgCreateEvent } as MsgCreateEvent; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.creator = reader.string(); + break; + case 2: + message.giverId = reader.string(); + break; + case 3: + message.takerId = reader.string(); + break; + case 4: + message.giverSign = reader.string(); + break; + case 5: + message.takerSign = reader.string(); + break; + case 6: + message.unionId = reader.string(); + break; + case 7: + message.typeId = reader.string(); + break; + case 8: + message.body = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgCreateEvent { + const message = { ...baseMsgCreateEvent } as MsgCreateEvent; + if (object.creator !== undefined && object.creator !== null) { + message.creator = String(object.creator); + } else { + message.creator = ""; + } + if (object.giverId !== undefined && object.giverId !== null) { + message.giverId = String(object.giverId); + } else { + message.giverId = ""; + } + if (object.takerId !== undefined && object.takerId !== null) { + message.takerId = String(object.takerId); + } else { + message.takerId = ""; + } + if (object.giverSign !== undefined && object.giverSign !== null) { + message.giverSign = String(object.giverSign); + } else { + message.giverSign = ""; + } + if (object.takerSign !== undefined && object.takerSign !== null) { + message.takerSign = String(object.takerSign); + } else { + message.takerSign = ""; + } + if (object.unionId !== undefined && object.unionId !== null) { + message.unionId = String(object.unionId); + } else { + message.unionId = ""; + } + if (object.typeId !== undefined && object.typeId !== null) { + message.typeId = String(object.typeId); + } else { + message.typeId = ""; + } + if (object.body !== undefined && object.body !== null) { + message.body = String(object.body); + } else { + message.body = ""; + } + return message; + }, + + toJSON(message: MsgCreateEvent): unknown { + const obj: any = {}; + message.creator !== undefined && (obj.creator = message.creator); + message.giverId !== undefined && (obj.giverId = message.giverId); + message.takerId !== undefined && (obj.takerId = message.takerId); + message.giverSign !== undefined && (obj.giverSign = message.giverSign); + message.takerSign !== undefined && (obj.takerSign = message.takerSign); + message.unionId !== undefined && (obj.unionId = message.unionId); + message.typeId !== undefined && (obj.typeId = message.typeId); + message.body !== undefined && (obj.body = message.body); + return obj; + }, + + fromPartial(object: DeepPartial): MsgCreateEvent { + const message = { ...baseMsgCreateEvent } as MsgCreateEvent; + if (object.creator !== undefined && object.creator !== null) { + message.creator = object.creator; + } else { + message.creator = ""; + } + if (object.giverId !== undefined && object.giverId !== null) { + message.giverId = object.giverId; + } else { + message.giverId = ""; + } + if (object.takerId !== undefined && object.takerId !== null) { + message.takerId = object.takerId; + } else { + message.takerId = ""; + } + if (object.giverSign !== undefined && object.giverSign !== null) { + message.giverSign = object.giverSign; + } else { + message.giverSign = ""; + } + if (object.takerSign !== undefined && object.takerSign !== null) { + message.takerSign = object.takerSign; + } else { + message.takerSign = ""; + } + if (object.unionId !== undefined && object.unionId !== null) { + message.unionId = object.unionId; + } else { + message.unionId = ""; + } + if (object.typeId !== undefined && object.typeId !== null) { + message.typeId = object.typeId; + } else { + message.typeId = ""; + } + if (object.body !== undefined && object.body !== null) { + message.body = object.body; + } else { + message.body = ""; + } + return message; + }, +}; + +const baseMsgCreateEventResponse: object = { id: 0 }; + +export const MsgCreateEventResponse = { + encode( + message: MsgCreateEventResponse, + writer: Writer = Writer.create() + ): Writer { + if (message.id !== 0) { + writer.uint32(8).uint64(message.id); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgCreateEventResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgCreateEventResponse } as MsgCreateEventResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.id = longToNumber(reader.uint64() as Long); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgCreateEventResponse { + const message = { ...baseMsgCreateEventResponse } as MsgCreateEventResponse; + if (object.id !== undefined && object.id !== null) { + message.id = Number(object.id); + } else { + message.id = 0; + } + return message; + }, + + toJSON(message: MsgCreateEventResponse): unknown { + const obj: any = {}; + message.id !== undefined && (obj.id = message.id); + return obj; + }, + + fromPartial( + object: DeepPartial + ): MsgCreateEventResponse { + const message = { ...baseMsgCreateEventResponse } as MsgCreateEventResponse; + if (object.id !== undefined && object.id !== null) { + message.id = object.id; + } else { + message.id = 0; + } + return message; + }, +}; + +const baseMsgUpdateEvent: object = { + creator: "", + id: 0, + giverId: "", + takerId: "", + giverSign: "", + takerSign: "", + unionId: "", + typeId: "", + body: "", +}; + +export const MsgUpdateEvent = { + encode(message: MsgUpdateEvent, writer: Writer = Writer.create()): Writer { + if (message.creator !== "") { + writer.uint32(10).string(message.creator); + } + if (message.id !== 0) { + writer.uint32(16).uint64(message.id); + } + if (message.giverId !== "") { + writer.uint32(26).string(message.giverId); + } + if (message.takerId !== "") { + writer.uint32(34).string(message.takerId); + } + if (message.giverSign !== "") { + writer.uint32(42).string(message.giverSign); + } + if (message.takerSign !== "") { + writer.uint32(50).string(message.takerSign); + } + if (message.unionId !== "") { + writer.uint32(58).string(message.unionId); + } + if (message.typeId !== "") { + writer.uint32(66).string(message.typeId); + } + if (message.body !== "") { + writer.uint32(74).string(message.body); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgUpdateEvent { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgUpdateEvent } as MsgUpdateEvent; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.creator = reader.string(); + break; + case 2: + message.id = longToNumber(reader.uint64() as Long); + break; + case 3: + message.giverId = reader.string(); + break; + case 4: + message.takerId = reader.string(); + break; + case 5: + message.giverSign = reader.string(); + break; + case 6: + message.takerSign = reader.string(); + break; + case 7: + message.unionId = reader.string(); + break; + case 8: + message.typeId = reader.string(); + break; + case 9: + message.body = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgUpdateEvent { + const message = { ...baseMsgUpdateEvent } as MsgUpdateEvent; + if (object.creator !== undefined && object.creator !== null) { + message.creator = String(object.creator); + } else { + message.creator = ""; + } + if (object.id !== undefined && object.id !== null) { + message.id = Number(object.id); + } else { + message.id = 0; + } + if (object.giverId !== undefined && object.giverId !== null) { + message.giverId = String(object.giverId); + } else { + message.giverId = ""; + } + if (object.takerId !== undefined && object.takerId !== null) { + message.takerId = String(object.takerId); + } else { + message.takerId = ""; + } + if (object.giverSign !== undefined && object.giverSign !== null) { + message.giverSign = String(object.giverSign); + } else { + message.giverSign = ""; + } + if (object.takerSign !== undefined && object.takerSign !== null) { + message.takerSign = String(object.takerSign); + } else { + message.takerSign = ""; + } + if (object.unionId !== undefined && object.unionId !== null) { + message.unionId = String(object.unionId); + } else { + message.unionId = ""; + } + if (object.typeId !== undefined && object.typeId !== null) { + message.typeId = String(object.typeId); + } else { + message.typeId = ""; + } + if (object.body !== undefined && object.body !== null) { + message.body = String(object.body); + } else { + message.body = ""; + } + return message; + }, + + toJSON(message: MsgUpdateEvent): unknown { + const obj: any = {}; + message.creator !== undefined && (obj.creator = message.creator); + message.id !== undefined && (obj.id = message.id); + message.giverId !== undefined && (obj.giverId = message.giverId); + message.takerId !== undefined && (obj.takerId = message.takerId); + message.giverSign !== undefined && (obj.giverSign = message.giverSign); + message.takerSign !== undefined && (obj.takerSign = message.takerSign); + message.unionId !== undefined && (obj.unionId = message.unionId); + message.typeId !== undefined && (obj.typeId = message.typeId); + message.body !== undefined && (obj.body = message.body); + return obj; + }, + + fromPartial(object: DeepPartial): MsgUpdateEvent { + const message = { ...baseMsgUpdateEvent } as MsgUpdateEvent; + if (object.creator !== undefined && object.creator !== null) { + message.creator = object.creator; + } else { + message.creator = ""; + } + if (object.id !== undefined && object.id !== null) { + message.id = object.id; + } else { + message.id = 0; + } + if (object.giverId !== undefined && object.giverId !== null) { + message.giverId = object.giverId; + } else { + message.giverId = ""; + } + if (object.takerId !== undefined && object.takerId !== null) { + message.takerId = object.takerId; + } else { + message.takerId = ""; + } + if (object.giverSign !== undefined && object.giverSign !== null) { + message.giverSign = object.giverSign; + } else { + message.giverSign = ""; + } + if (object.takerSign !== undefined && object.takerSign !== null) { + message.takerSign = object.takerSign; + } else { + message.takerSign = ""; + } + if (object.unionId !== undefined && object.unionId !== null) { + message.unionId = object.unionId; + } else { + message.unionId = ""; + } + if (object.typeId !== undefined && object.typeId !== null) { + message.typeId = object.typeId; + } else { + message.typeId = ""; + } + if (object.body !== undefined && object.body !== null) { + message.body = object.body; + } else { + message.body = ""; + } + return message; + }, +}; + +const baseMsgUpdateEventResponse: object = {}; + +export const MsgUpdateEventResponse = { + encode(_: MsgUpdateEventResponse, writer: Writer = Writer.create()): Writer { + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgUpdateEventResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgUpdateEventResponse } as MsgUpdateEventResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): MsgUpdateEventResponse { + const message = { ...baseMsgUpdateEventResponse } as MsgUpdateEventResponse; + return message; + }, + + toJSON(_: MsgUpdateEventResponse): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial(_: DeepPartial): MsgUpdateEventResponse { + const message = { ...baseMsgUpdateEventResponse } as MsgUpdateEventResponse; + return message; + }, +}; + +const baseMsgDeleteEvent: object = { creator: "", id: 0 }; + +export const MsgDeleteEvent = { + encode(message: MsgDeleteEvent, writer: Writer = Writer.create()): Writer { + if (message.creator !== "") { + writer.uint32(10).string(message.creator); + } + if (message.id !== 0) { + writer.uint32(16).uint64(message.id); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgDeleteEvent { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgDeleteEvent } as MsgDeleteEvent; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.creator = reader.string(); + break; + case 2: + message.id = longToNumber(reader.uint64() as Long); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgDeleteEvent { + const message = { ...baseMsgDeleteEvent } as MsgDeleteEvent; + if (object.creator !== undefined && object.creator !== null) { + message.creator = String(object.creator); + } else { + message.creator = ""; + } + if (object.id !== undefined && object.id !== null) { + message.id = Number(object.id); + } else { + message.id = 0; + } + return message; + }, + + toJSON(message: MsgDeleteEvent): unknown { + const obj: any = {}; + message.creator !== undefined && (obj.creator = message.creator); + message.id !== undefined && (obj.id = message.id); + return obj; + }, + + fromPartial(object: DeepPartial): MsgDeleteEvent { + const message = { ...baseMsgDeleteEvent } as MsgDeleteEvent; + if (object.creator !== undefined && object.creator !== null) { + message.creator = object.creator; + } else { + message.creator = ""; + } + if (object.id !== undefined && object.id !== null) { + message.id = object.id; + } else { + message.id = 0; + } + return message; + }, +}; + +const baseMsgDeleteEventResponse: object = {}; + +export const MsgDeleteEventResponse = { + encode(_: MsgDeleteEventResponse, writer: Writer = Writer.create()): Writer { + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgDeleteEventResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgDeleteEventResponse } as MsgDeleteEventResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): MsgDeleteEventResponse { + const message = { ...baseMsgDeleteEventResponse } as MsgDeleteEventResponse; + return message; + }, + + toJSON(_: MsgDeleteEventResponse): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial(_: DeepPartial): MsgDeleteEventResponse { + const message = { ...baseMsgDeleteEventResponse } as MsgDeleteEventResponse; + return message; + }, +}; + /** Msg defines the Msg service. */ -export interface Msg {} +export interface Msg { + CreateEvent(request: MsgCreateEvent): Promise; + UpdateEvent(request: MsgUpdateEvent): Promise; + /** this line is used by starport scaffolding # proto/tx/rpc */ + DeleteEvent(request: MsgDeleteEvent): Promise; +} export class MsgClientImpl implements Msg { private readonly rpc: Rpc; constructor(rpc: Rpc) { this.rpc = rpc; } + CreateEvent(request: MsgCreateEvent): Promise { + const data = MsgCreateEvent.encode(request).finish(); + const promise = this.rpc.request( + "webtree.story.story.Msg", + "CreateEvent", + data + ); + return promise.then((data) => + MsgCreateEventResponse.decode(new Reader(data)) + ); + } + + UpdateEvent(request: MsgUpdateEvent): Promise { + const data = MsgUpdateEvent.encode(request).finish(); + const promise = this.rpc.request( + "webtree.story.story.Msg", + "UpdateEvent", + data + ); + return promise.then((data) => + MsgUpdateEventResponse.decode(new Reader(data)) + ); + } + + DeleteEvent(request: MsgDeleteEvent): Promise { + const data = MsgDeleteEvent.encode(request).finish(); + const promise = this.rpc.request( + "webtree.story.story.Msg", + "DeleteEvent", + data + ); + return promise.then((data) => + MsgDeleteEventResponse.decode(new Reader(data)) + ); + } } interface Rpc { @@ -18,3 +689,36 @@ interface Rpc { data: Uint8Array ): Promise; } + +declare var self: any | undefined; +declare var window: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +function longToNumber(long: Long): number { + if (long.gt(Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (util.Long !== Long) { + util.Long = Long as any; + configure(); +} diff --git a/x/story/client/cli/query.go b/x/story/client/cli/query.go index efaa8b1..2a03baa 100644 --- a/x/story/client/cli/query.go +++ b/x/story/client/cli/query.go @@ -25,6 +25,8 @@ func GetQueryCmd(queryRoute string) *cobra.Command { } cmd.AddCommand(CmdQueryParams()) + cmd.AddCommand(CmdListEvent()) + cmd.AddCommand(CmdShowEvent()) // this line is used by starport scaffolding # 1 return cmd diff --git a/x/story/client/cli/query_event.go b/x/story/client/cli/query_event.go new file mode 100644 index 0000000..288ad58 --- /dev/null +++ b/x/story/client/cli/query_event.go @@ -0,0 +1,77 @@ +package cli + +import ( + "context" + "strconv" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/spf13/cobra" + "github.com/web-tree/story/x/story/types" +) + +func CmdListEvent() *cobra.Command { + cmd := &cobra.Command{ + Use: "list-event", + Short: "list all event", + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + + pageReq, err := client.ReadPageRequest(cmd.Flags()) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryAllEventRequest{ + Pagination: pageReq, + } + + res, err := queryClient.EventAll(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddPaginationFlagsToCmd(cmd, cmd.Use) + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func CmdShowEvent() *cobra.Command { + cmd := &cobra.Command{ + Use: "show-event [id]", + Short: "shows a event", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + + queryClient := types.NewQueryClient(clientCtx) + + id, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + params := &types.QueryGetEventRequest{ + Id: id, + } + + res, err := queryClient.Event(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/story/client/cli/query_event_test.go b/x/story/client/cli/query_event_test.go new file mode 100644 index 0000000..9b282b0 --- /dev/null +++ b/x/story/client/cli/query_event_test.go @@ -0,0 +1,153 @@ +package cli_test + +import ( + "fmt" + "testing" + + "github.com/cosmos/cosmos-sdk/client/flags" + clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli" + "github.com/stretchr/testify/require" + tmcli "github.com/tendermint/tendermint/libs/cli" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/web-tree/story/testutil/network" + "github.com/web-tree/story/testutil/nullify" + "github.com/web-tree/story/x/story/client/cli" + "github.com/web-tree/story/x/story/types" +) + +func networkWithEventObjects(t *testing.T, n int) (*network.Network, []types.Event) { + t.Helper() + cfg := network.DefaultConfig() + state := types.GenesisState{} + require.NoError(t, cfg.Codec.UnmarshalJSON(cfg.GenesisState[types.ModuleName], &state)) + + for i := 0; i < n; i++ { + event := types.Event{ + Id: uint64(i), + } + nullify.Fill(&event) + state.EventList = append(state.EventList, event) + } + buf, err := cfg.Codec.MarshalJSON(&state) + require.NoError(t, err) + cfg.GenesisState[types.ModuleName] = buf + return network.New(t, cfg), state.EventList +} + +func TestShowEvent(t *testing.T) { + net, objs := networkWithEventObjects(t, 2) + + ctx := net.Validators[0].ClientCtx + common := []string{ + fmt.Sprintf("--%s=json", tmcli.OutputFlag), + } + for _, tc := range []struct { + desc string + id string + args []string + err error + obj types.Event + }{ + { + desc: "found", + id: fmt.Sprintf("%d", objs[0].Id), + args: common, + obj: objs[0], + }, + { + desc: "not found", + id: "not_found", + args: common, + err: status.Error(codes.NotFound, "not found"), + }, + } { + tc := tc + t.Run(tc.desc, func(t *testing.T) { + args := []string{tc.id} + args = append(args, tc.args...) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdShowEvent(), args) + if tc.err != nil { + stat, ok := status.FromError(tc.err) + require.True(t, ok) + require.ErrorIs(t, stat.Err(), tc.err) + } else { + require.NoError(t, err) + var resp types.QueryGetEventResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.NotNil(t, resp.Event) + require.Equal(t, + nullify.Fill(&tc.obj), + nullify.Fill(&resp.Event), + ) + } + }) + } +} + +func TestListEvent(t *testing.T) { + net, objs := networkWithEventObjects(t, 5) + + ctx := net.Validators[0].ClientCtx + request := func(next []byte, offset, limit uint64, total bool) []string { + args := []string{ + fmt.Sprintf("--%s=json", tmcli.OutputFlag), + } + if next == nil { + args = append(args, fmt.Sprintf("--%s=%d", flags.FlagOffset, offset)) + } else { + args = append(args, fmt.Sprintf("--%s=%s", flags.FlagPageKey, next)) + } + args = append(args, fmt.Sprintf("--%s=%d", flags.FlagLimit, limit)) + if total { + args = append(args, fmt.Sprintf("--%s", flags.FlagCountTotal)) + } + return args + } + t.Run("ByOffset", func(t *testing.T) { + step := 2 + for i := 0; i < len(objs); i += step { + args := request(nil, uint64(i), uint64(step), false) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdListEvent(), args) + require.NoError(t, err) + var resp types.QueryAllEventResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.LessOrEqual(t, len(resp.Event), step) + require.Subset(t, + nullify.Fill(objs), + nullify.Fill(resp.Event), + ) + } + }) + t.Run("ByKey", func(t *testing.T) { + step := 2 + var next []byte + for i := 0; i < len(objs); i += step { + args := request(next, 0, uint64(step), false) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdListEvent(), args) + require.NoError(t, err) + var resp types.QueryAllEventResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.LessOrEqual(t, len(resp.Event), step) + require.Subset(t, + nullify.Fill(objs), + nullify.Fill(resp.Event), + ) + next = resp.Pagination.NextKey + } + }) + t.Run("Total", func(t *testing.T) { + args := request(nil, 0, uint64(len(objs)), true) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdListEvent(), args) + require.NoError(t, err) + var resp types.QueryAllEventResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.NoError(t, err) + require.Equal(t, len(objs), int(resp.Pagination.Total)) + require.ElementsMatch(t, + nullify.Fill(objs), + nullify.Fill(resp.Event), + ) + }) +} diff --git a/x/story/client/cli/tx.go b/x/story/client/cli/tx.go index cecc957..c9ff579 100644 --- a/x/story/client/cli/tx.go +++ b/x/story/client/cli/tx.go @@ -30,6 +30,9 @@ func GetTxCmd() *cobra.Command { RunE: client.ValidateCmd, } + cmd.AddCommand(CmdCreateEvent()) + cmd.AddCommand(CmdUpdateEvent()) + cmd.AddCommand(CmdDeleteEvent()) // this line is used by starport scaffolding # 1 return cmd diff --git a/x/story/client/cli/tx_event.go b/x/story/client/cli/tx_event.go new file mode 100644 index 0000000..d14f0b6 --- /dev/null +++ b/x/story/client/cli/tx_event.go @@ -0,0 +1,115 @@ +package cli + +import ( + "strconv" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/spf13/cobra" + "github.com/web-tree/story/x/story/types" +) + +func CmdCreateEvent() *cobra.Command { + cmd := &cobra.Command{ + Use: "create-event [giver-id] [taker-id] [giver-sign] [taker-sign] [union-id] [type-id] [body]", + Short: "Create a new event", + Args: cobra.ExactArgs(7), + RunE: func(cmd *cobra.Command, args []string) (err error) { + argGiverId := args[0] + argTakerId := args[1] + argGiverSign := args[2] + argTakerSign := args[3] + argUnionId := args[4] + argTypeId := args[5] + argBody := args[6] + + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgCreateEvent(clientCtx.GetFromAddress().String(), argGiverId, argTakerId, argGiverSign, argTakerSign, argUnionId, argTypeId, argBody) + if err := msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +func CmdUpdateEvent() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-event [id] [giver-id] [taker-id] [giver-sign] [taker-sign] [union-id] [type-id] [body]", + Short: "Update a event", + Args: cobra.ExactArgs(8), + RunE: func(cmd *cobra.Command, args []string) (err error) { + id, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + argGiverId := args[1] + + argTakerId := args[2] + + argGiverSign := args[3] + + argTakerSign := args[4] + + argUnionId := args[5] + + argTypeId := args[6] + + argBody := args[7] + + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgUpdateEvent(clientCtx.GetFromAddress().String(), id, argGiverId, argTakerId, argGiverSign, argTakerSign, argUnionId, argTypeId, argBody) + if err := msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +func CmdDeleteEvent() *cobra.Command { + cmd := &cobra.Command{ + Use: "delete-event [id]", + Short: "Delete a event by id", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + id, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgDeleteEvent(clientCtx.GetFromAddress().String(), id) + if err := msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} diff --git a/x/story/client/cli/tx_event_test.go b/x/story/client/cli/tx_event_test.go new file mode 100644 index 0000000..7dc1969 --- /dev/null +++ b/x/story/client/cli/tx_event_test.go @@ -0,0 +1,164 @@ +package cli_test + +import ( + "fmt" + "testing" + + "github.com/cosmos/cosmos-sdk/client/flags" + clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/stretchr/testify/require" + + "github.com/web-tree/story/testutil/network" + "github.com/web-tree/story/x/story/client/cli" +) + +func TestCreateEvent(t *testing.T) { + net := network.New(t) + val := net.Validators[0] + ctx := val.ClientCtx + + fields := []string{"xyz", "xyz", "xyz", "xyz", "xyz", "xyz", "xyz"} + for _, tc := range []struct { + desc string + args []string + err error + code uint32 + }{ + { + desc: "valid", + args: []string{ + fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(net.Config.BondDenom, sdk.NewInt(10))).String()), + }, + }, + } { + tc := tc + t.Run(tc.desc, func(t *testing.T) { + args := []string{} + args = append(args, fields...) + args = append(args, tc.args...) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdCreateEvent(), args) + if tc.err != nil { + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + var resp sdk.TxResponse + require.NoError(t, ctx.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.Equal(t, tc.code, resp.Code) + } + }) + } +} + +func TestUpdateEvent(t *testing.T) { + net := network.New(t) + + val := net.Validators[0] + ctx := val.ClientCtx + + fields := []string{"xyz", "xyz", "xyz", "xyz", "xyz", "xyz", "xyz"} + common := []string{ + fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(net.Config.BondDenom, sdk.NewInt(10))).String()), + } + args := []string{} + args = append(args, fields...) + args = append(args, common...) + _, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdCreateEvent(), args) + require.NoError(t, err) + + for _, tc := range []struct { + desc string + id string + args []string + code uint32 + err error + }{ + { + desc: "valid", + id: "0", + args: common, + }, + { + desc: "key not found", + id: "1", + args: common, + code: sdkerrors.ErrKeyNotFound.ABCICode(), + }, + } { + tc := tc + t.Run(tc.desc, func(t *testing.T) { + args := []string{tc.id} + args = append(args, fields...) + args = append(args, tc.args...) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdUpdateEvent(), args) + if tc.err != nil { + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + var resp sdk.TxResponse + require.NoError(t, ctx.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.Equal(t, tc.code, resp.Code) + } + }) + } +} + +func TestDeleteEvent(t *testing.T) { + net := network.New(t) + + val := net.Validators[0] + ctx := val.ClientCtx + + fields := []string{"xyz", "xyz", "xyz", "xyz", "xyz", "xyz", "xyz"} + common := []string{ + fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(net.Config.BondDenom, sdk.NewInt(10))).String()), + } + args := []string{} + args = append(args, fields...) + args = append(args, common...) + _, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdCreateEvent(), args) + require.NoError(t, err) + + for _, tc := range []struct { + desc string + id string + args []string + code uint32 + err error + }{ + { + desc: "valid", + id: "0", + args: common, + }, + { + desc: "key not found", + id: "1", + args: common, + code: sdkerrors.ErrKeyNotFound.ABCICode(), + }, + } { + tc := tc + t.Run(tc.desc, func(t *testing.T) { + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdDeleteEvent(), append([]string{tc.id}, tc.args...)) + if tc.err != nil { + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + var resp sdk.TxResponse + require.NoError(t, ctx.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.Equal(t, tc.code, resp.Code) + } + }) + } +} diff --git a/x/story/genesis.go b/x/story/genesis.go index ef42ccb..d60b1ef 100644 --- a/x/story/genesis.go +++ b/x/story/genesis.go @@ -9,6 +9,13 @@ import ( // InitGenesis initializes the capability module's state from a provided genesis // state. func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) { + // Set all the event + for _, elem := range genState.EventList { + k.SetEvent(ctx, elem) + } + + // Set event count + k.SetEventCount(ctx, genState.EventCount) // this line is used by starport scaffolding # genesis/module/init k.SetPort(ctx, genState.PortId) // Only try to bind to port if it is not already bound, since we may already own @@ -30,6 +37,8 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { genesis.Params = k.GetParams(ctx) genesis.PortId = k.GetPort(ctx) + genesis.EventList = k.GetAllEvent(ctx) + genesis.EventCount = k.GetEventCount(ctx) // this line is used by starport scaffolding # genesis/module/export return genesis diff --git a/x/story/genesis_test.go b/x/story/genesis_test.go index 8bdd7f1..a041839 100644 --- a/x/story/genesis_test.go +++ b/x/story/genesis_test.go @@ -14,6 +14,15 @@ func TestGenesis(t *testing.T) { genesisState := types.GenesisState{ Params: types.DefaultParams(), PortId: types.PortID, + EventList: []types.Event{ + { + Id: 0, + }, + { + Id: 1, + }, + }, + EventCount: 2, // this line is used by starport scaffolding # genesis/test/state } @@ -27,5 +36,7 @@ func TestGenesis(t *testing.T) { require.Equal(t, genesisState.PortId, got.PortId) + require.ElementsMatch(t, genesisState.EventList, got.EventList) + require.Equal(t, genesisState.EventCount, got.EventCount) // this line is used by starport scaffolding # genesis/test/assert } diff --git a/x/story/handler.go b/x/story/handler.go index 79b0348..1a6401c 100644 --- a/x/story/handler.go +++ b/x/story/handler.go @@ -11,13 +11,25 @@ import ( // NewHandler ... func NewHandler(k keeper.Keeper) sdk.Handler { - // this line is used by starport scaffolding # handler/msgServer + msgServer := keeper.NewMsgServerImpl(k) return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) { ctx = ctx.WithEventManager(sdk.NewEventManager()) switch msg := msg.(type) { - // this line is used by starport scaffolding # 1 + case *types.MsgCreateEvent: + res, err := msgServer.CreateEvent(sdk.WrapSDKContext(ctx), msg) + return sdk.WrapServiceResult(ctx, res, err) + + case *types.MsgUpdateEvent: + res, err := msgServer.UpdateEvent(sdk.WrapSDKContext(ctx), msg) + return sdk.WrapServiceResult(ctx, res, err) + + case *types.MsgDeleteEvent: + res, err := msgServer.DeleteEvent(sdk.WrapSDKContext(ctx), msg) + return sdk.WrapServiceResult(ctx, res, err) + + // this line is used by starport scaffolding # 1 default: errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg) return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg) diff --git a/x/story/keeper/event.go b/x/story/keeper/event.go new file mode 100644 index 0000000..429e2cf --- /dev/null +++ b/x/story/keeper/event.go @@ -0,0 +1,106 @@ +package keeper + +import ( + "encoding/binary" + + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/web-tree/story/x/story/types" +) + +// GetEventCount get the total number of event +func (k Keeper) GetEventCount(ctx sdk.Context) uint64 { + store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte{}) + byteKey := types.KeyPrefix(types.EventCountKey) + bz := store.Get(byteKey) + + // Count doesn't exist: no element + if bz == nil { + return 0 + } + + // Parse bytes + return binary.BigEndian.Uint64(bz) +} + +// SetEventCount set the total number of event +func (k Keeper) SetEventCount(ctx sdk.Context, count uint64) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte{}) + byteKey := types.KeyPrefix(types.EventCountKey) + bz := make([]byte, 8) + binary.BigEndian.PutUint64(bz, count) + store.Set(byteKey, bz) +} + +// AppendEvent appends a event in the store with a new id and update the count +func (k Keeper) AppendEvent( + ctx sdk.Context, + event types.Event, +) uint64 { + // Create the event + count := k.GetEventCount(ctx) + + // Set the ID of the appended value + event.Id = count + + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.EventKey)) + appendedValue := k.cdc.MustMarshal(&event) + store.Set(GetEventIDBytes(event.Id), appendedValue) + + // Update event count + k.SetEventCount(ctx, count+1) + + return count +} + +// SetEvent set a specific event in the store +func (k Keeper) SetEvent(ctx sdk.Context, event types.Event) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.EventKey)) + b := k.cdc.MustMarshal(&event) + store.Set(GetEventIDBytes(event.Id), b) +} + +// GetEvent returns a event from its id +func (k Keeper) GetEvent(ctx sdk.Context, id uint64) (val types.Event, found bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.EventKey)) + b := store.Get(GetEventIDBytes(id)) + if b == nil { + return val, false + } + k.cdc.MustUnmarshal(b, &val) + return val, true +} + +// RemoveEvent removes a event from the store +func (k Keeper) RemoveEvent(ctx sdk.Context, id uint64) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.EventKey)) + store.Delete(GetEventIDBytes(id)) +} + +// GetAllEvent returns all event +func (k Keeper) GetAllEvent(ctx sdk.Context) (list []types.Event) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.EventKey)) + iterator := sdk.KVStorePrefixIterator(store, []byte{}) + + defer iterator.Close() + + for ; iterator.Valid(); iterator.Next() { + var val types.Event + k.cdc.MustUnmarshal(iterator.Value(), &val) + list = append(list, val) + } + + return +} + +// GetEventIDBytes returns the byte representation of the ID +func GetEventIDBytes(id uint64) []byte { + bz := make([]byte, 8) + binary.BigEndian.PutUint64(bz, id) + return bz +} + +// GetEventIDFromBytes returns ID in uint64 format from a byte array +func GetEventIDFromBytes(bz []byte) uint64 { + return binary.BigEndian.Uint64(bz) +} diff --git a/x/story/keeper/event_test.go b/x/story/keeper/event_test.go new file mode 100644 index 0000000..1dfcfab --- /dev/null +++ b/x/story/keeper/event_test.go @@ -0,0 +1,59 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" + keepertest "github.com/web-tree/story/testutil/keeper" + "github.com/web-tree/story/testutil/nullify" + "github.com/web-tree/story/x/story/keeper" + "github.com/web-tree/story/x/story/types" +) + +func createNEvent(keeper *keeper.Keeper, ctx sdk.Context, n int) []types.Event { + items := make([]types.Event, n) + for i := range items { + items[i].Id = keeper.AppendEvent(ctx, items[i]) + } + return items +} + +func TestEventGet(t *testing.T) { + keeper, ctx := keepertest.StoryKeeper(t) + items := createNEvent(keeper, ctx, 10) + for _, item := range items { + got, found := keeper.GetEvent(ctx, item.Id) + require.True(t, found) + require.Equal(t, + nullify.Fill(&item), + nullify.Fill(&got), + ) + } +} + +func TestEventRemove(t *testing.T) { + keeper, ctx := keepertest.StoryKeeper(t) + items := createNEvent(keeper, ctx, 10) + for _, item := range items { + keeper.RemoveEvent(ctx, item.Id) + _, found := keeper.GetEvent(ctx, item.Id) + require.False(t, found) + } +} + +func TestEventGetAll(t *testing.T) { + keeper, ctx := keepertest.StoryKeeper(t) + items := createNEvent(keeper, ctx, 10) + require.ElementsMatch(t, + nullify.Fill(items), + nullify.Fill(keeper.GetAllEvent(ctx)), + ) +} + +func TestEventCount(t *testing.T) { + keeper, ctx := keepertest.StoryKeeper(t) + items := createNEvent(keeper, ctx, 10) + count := uint64(len(items)) + require.Equal(t, count, keeper.GetEventCount(ctx)) +} diff --git a/x/story/keeper/grpc_query_event.go b/x/story/keeper/grpc_query_event.go new file mode 100644 index 0000000..0fe2abc --- /dev/null +++ b/x/story/keeper/grpc_query_event.go @@ -0,0 +1,55 @@ +package keeper + +import ( + "context" + + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/web-tree/story/x/story/types" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +func (k Keeper) EventAll(c context.Context, req *types.QueryAllEventRequest) (*types.QueryAllEventResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + var events []types.Event + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + eventStore := prefix.NewStore(store, types.KeyPrefix(types.EventKey)) + + pageRes, err := query.Paginate(eventStore, req.Pagination, func(key []byte, value []byte) error { + var event types.Event + if err := k.cdc.Unmarshal(value, &event); err != nil { + return err + } + + events = append(events, event) + return nil + }) + + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryAllEventResponse{Event: events, Pagination: pageRes}, nil +} + +func (k Keeper) Event(c context.Context, req *types.QueryGetEventRequest) (*types.QueryGetEventResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(c) + event, found := k.GetEvent(ctx, req.Id) + if !found { + return nil, sdkerrors.ErrKeyNotFound + } + + return &types.QueryGetEventResponse{Event: event}, nil +} diff --git a/x/story/keeper/grpc_query_event_test.go b/x/story/keeper/grpc_query_event_test.go new file mode 100644 index 0000000..7913b89 --- /dev/null +++ b/x/story/keeper/grpc_query_event_test.go @@ -0,0 +1,117 @@ +package keeper_test + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + keepertest "github.com/web-tree/story/testutil/keeper" + "github.com/web-tree/story/testutil/nullify" + "github.com/web-tree/story/x/story/types" +) + +func TestEventQuerySingle(t *testing.T) { + keeper, ctx := keepertest.StoryKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + msgs := createNEvent(keeper, ctx, 2) + for _, tc := range []struct { + desc string + request *types.QueryGetEventRequest + response *types.QueryGetEventResponse + err error + }{ + { + desc: "First", + request: &types.QueryGetEventRequest{Id: msgs[0].Id}, + response: &types.QueryGetEventResponse{Event: msgs[0]}, + }, + { + desc: "Second", + request: &types.QueryGetEventRequest{Id: msgs[1].Id}, + response: &types.QueryGetEventResponse{Event: msgs[1]}, + }, + { + desc: "KeyNotFound", + request: &types.QueryGetEventRequest{Id: uint64(len(msgs))}, + err: sdkerrors.ErrKeyNotFound, + }, + { + desc: "InvalidRequest", + err: status.Error(codes.InvalidArgument, "invalid request"), + }, + } { + t.Run(tc.desc, func(t *testing.T) { + response, err := keeper.Event(wctx, tc.request) + if tc.err != nil { + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + require.Equal(t, + nullify.Fill(tc.response), + nullify.Fill(response), + ) + } + }) + } +} + +func TestEventQueryPaginated(t *testing.T) { + keeper, ctx := keepertest.StoryKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + msgs := createNEvent(keeper, ctx, 5) + + request := func(next []byte, offset, limit uint64, total bool) *types.QueryAllEventRequest { + return &types.QueryAllEventRequest{ + Pagination: &query.PageRequest{ + Key: next, + Offset: offset, + Limit: limit, + CountTotal: total, + }, + } + } + t.Run("ByOffset", func(t *testing.T) { + step := 2 + for i := 0; i < len(msgs); i += step { + resp, err := keeper.EventAll(wctx, request(nil, uint64(i), uint64(step), false)) + require.NoError(t, err) + require.LessOrEqual(t, len(resp.Event), step) + require.Subset(t, + nullify.Fill(msgs), + nullify.Fill(resp.Event), + ) + } + }) + t.Run("ByKey", func(t *testing.T) { + step := 2 + var next []byte + for i := 0; i < len(msgs); i += step { + resp, err := keeper.EventAll(wctx, request(next, 0, uint64(step), false)) + require.NoError(t, err) + require.LessOrEqual(t, len(resp.Event), step) + require.Subset(t, + nullify.Fill(msgs), + nullify.Fill(resp.Event), + ) + next = resp.Pagination.NextKey + } + }) + t.Run("Total", func(t *testing.T) { + resp, err := keeper.EventAll(wctx, request(nil, 0, 0, true)) + require.NoError(t, err) + require.Equal(t, len(msgs), int(resp.Pagination.Total)) + require.ElementsMatch(t, + nullify.Fill(msgs), + nullify.Fill(resp.Event), + ) + }) + t.Run("InvalidRequest", func(t *testing.T) { + _, err := keeper.EventAll(wctx, nil) + require.ErrorIs(t, err, status.Error(codes.InvalidArgument, "invalid request")) + }) +} diff --git a/x/story/keeper/msg_server_event.go b/x/story/keeper/msg_server_event.go new file mode 100644 index 0000000..91d52c7 --- /dev/null +++ b/x/story/keeper/msg_server_event.go @@ -0,0 +1,84 @@ +package keeper + +import ( + "context" + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/web-tree/story/x/story/types" +) + +func (k msgServer) CreateEvent(goCtx context.Context, msg *types.MsgCreateEvent) (*types.MsgCreateEventResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + var event = types.Event{ + Creator: msg.Creator, + GiverId: msg.GiverId, + TakerId: msg.TakerId, + GiverSign: msg.GiverSign, + TakerSign: msg.TakerSign, + UnionId: msg.UnionId, + TypeId: msg.TypeId, + Body: msg.Body, + } + + id := k.AppendEvent( + ctx, + event, + ) + + return &types.MsgCreateEventResponse{ + Id: id, + }, nil +} + +func (k msgServer) UpdateEvent(goCtx context.Context, msg *types.MsgUpdateEvent) (*types.MsgUpdateEventResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + var event = types.Event{ + Creator: msg.Creator, + Id: msg.Id, + GiverId: msg.GiverId, + TakerId: msg.TakerId, + GiverSign: msg.GiverSign, + TakerSign: msg.TakerSign, + UnionId: msg.UnionId, + TypeId: msg.TypeId, + Body: msg.Body, + } + + // Checks that the element exists + val, found := k.GetEvent(ctx, msg.Id) + if !found { + return nil, sdkerrors.Wrap(sdkerrors.ErrKeyNotFound, fmt.Sprintf("key %d doesn't exist", msg.Id)) + } + + // Checks if the msg creator is the same as the current owner + if msg.Creator != val.Creator { + return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "incorrect owner") + } + + k.SetEvent(ctx, event) + + return &types.MsgUpdateEventResponse{}, nil +} + +func (k msgServer) DeleteEvent(goCtx context.Context, msg *types.MsgDeleteEvent) (*types.MsgDeleteEventResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + // Checks that the element exists + val, found := k.GetEvent(ctx, msg.Id) + if !found { + return nil, sdkerrors.Wrap(sdkerrors.ErrKeyNotFound, fmt.Sprintf("key %d doesn't exist", msg.Id)) + } + + // Checks if the msg creator is the same as the current owner + if msg.Creator != val.Creator { + return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "incorrect owner") + } + + k.RemoveEvent(ctx, msg.Id) + + return &types.MsgDeleteEventResponse{}, nil +} diff --git a/x/story/keeper/msg_server_event_test.go b/x/story/keeper/msg_server_event_test.go new file mode 100644 index 0000000..7e9b7ad --- /dev/null +++ b/x/story/keeper/msg_server_event_test.go @@ -0,0 +1,96 @@ +package keeper_test + +import ( + "testing" + + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/stretchr/testify/require" + + "github.com/web-tree/story/x/story/types" +) + +func TestEventMsgServerCreate(t *testing.T) { + srv, ctx := setupMsgServer(t) + creator := "A" + for i := 0; i < 5; i++ { + resp, err := srv.CreateEvent(ctx, &types.MsgCreateEvent{Creator: creator}) + require.NoError(t, err) + require.Equal(t, i, int(resp.Id)) + } +} + +func TestEventMsgServerUpdate(t *testing.T) { + creator := "A" + + for _, tc := range []struct { + desc string + request *types.MsgUpdateEvent + err error + }{ + { + desc: "Completed", + request: &types.MsgUpdateEvent{Creator: creator}, + }, + { + desc: "Unauthorized", + request: &types.MsgUpdateEvent{Creator: "B"}, + err: sdkerrors.ErrUnauthorized, + }, + { + desc: "Unauthorized", + request: &types.MsgUpdateEvent{Creator: creator, Id: 10}, + err: sdkerrors.ErrKeyNotFound, + }, + } { + t.Run(tc.desc, func(t *testing.T) { + srv, ctx := setupMsgServer(t) + _, err := srv.CreateEvent(ctx, &types.MsgCreateEvent{Creator: creator}) + require.NoError(t, err) + + _, err = srv.UpdateEvent(ctx, tc.request) + if tc.err != nil { + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestEventMsgServerDelete(t *testing.T) { + creator := "A" + + for _, tc := range []struct { + desc string + request *types.MsgDeleteEvent + err error + }{ + { + desc: "Completed", + request: &types.MsgDeleteEvent{Creator: creator}, + }, + { + desc: "Unauthorized", + request: &types.MsgDeleteEvent{Creator: "B"}, + err: sdkerrors.ErrUnauthorized, + }, + { + desc: "KeyNotFound", + request: &types.MsgDeleteEvent{Creator: creator, Id: 10}, + err: sdkerrors.ErrKeyNotFound, + }, + } { + t.Run(tc.desc, func(t *testing.T) { + srv, ctx := setupMsgServer(t) + + _, err := srv.CreateEvent(ctx, &types.MsgCreateEvent{Creator: creator}) + require.NoError(t, err) + _, err = srv.DeleteEvent(ctx, tc.request) + if tc.err != nil { + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + } + }) + } +} diff --git a/x/story/module.go b/x/story/module.go index 3fabd27..fd08636 100644 --- a/x/story/module.go +++ b/x/story/module.go @@ -1,9 +1,9 @@ package story import ( + "context" "encoding/json" "fmt" - // this line is used by starport scaffolding # 1 "github.com/gorilla/mux" "github.com/grpc-ecosystem/grpc-gateway/runtime" @@ -79,7 +79,7 @@ func (AppModuleBasic) RegisterRESTRoutes(clientCtx client.Context, rtr *mux.Rout // RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module. func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) { - // this line is used by starport scaffolding # 2 + types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)) } // GetTxCmd returns the capability module's root tx command. diff --git a/x/story/module_simulation.go b/x/story/module_simulation.go index 8c362a4..24051c9 100644 --- a/x/story/module_simulation.go +++ b/x/story/module_simulation.go @@ -24,7 +24,19 @@ var ( ) const ( -// this line is used by starport scaffolding # simapp/module/const + opWeightMsgCreateEvent = "op_weight_msg_event" + // TODO: Determine the simulation weight value + defaultWeightMsgCreateEvent int = 100 + + opWeightMsgUpdateEvent = "op_weight_msg_event" + // TODO: Determine the simulation weight value + defaultWeightMsgUpdateEvent int = 100 + + opWeightMsgDeleteEvent = "op_weight_msg_event" + // TODO: Determine the simulation weight value + defaultWeightMsgDeleteEvent int = 100 + + // this line is used by starport scaffolding # simapp/module/const ) // GenerateGenesisState creates a randomized GenState of the module @@ -36,6 +48,17 @@ func (AppModule) GenerateGenesisState(simState *module.SimulationState) { storyGenesis := types.GenesisState{ Params: types.DefaultParams(), PortId: types.PortID, + EventList: []types.Event{ + { + Id: 0, + Creator: sample.AccAddress(), + }, + { + Id: 1, + Creator: sample.AccAddress(), + }, + }, + EventCount: 2, // this line is used by starport scaffolding # simapp/module/genesisState } simState.GenState[types.ModuleName] = simState.Cdc.MustMarshalJSON(&storyGenesis) @@ -59,6 +82,39 @@ func (am AppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) {} func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation { operations := make([]simtypes.WeightedOperation, 0) + var weightMsgCreateEvent int + simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgCreateEvent, &weightMsgCreateEvent, nil, + func(_ *rand.Rand) { + weightMsgCreateEvent = defaultWeightMsgCreateEvent + }, + ) + operations = append(operations, simulation.NewWeightedOperation( + weightMsgCreateEvent, + storysimulation.SimulateMsgCreateEvent(am.accountKeeper, am.bankKeeper, am.keeper), + )) + + var weightMsgUpdateEvent int + simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgUpdateEvent, &weightMsgUpdateEvent, nil, + func(_ *rand.Rand) { + weightMsgUpdateEvent = defaultWeightMsgUpdateEvent + }, + ) + operations = append(operations, simulation.NewWeightedOperation( + weightMsgUpdateEvent, + storysimulation.SimulateMsgUpdateEvent(am.accountKeeper, am.bankKeeper, am.keeper), + )) + + var weightMsgDeleteEvent int + simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgDeleteEvent, &weightMsgDeleteEvent, nil, + func(_ *rand.Rand) { + weightMsgDeleteEvent = defaultWeightMsgDeleteEvent + }, + ) + operations = append(operations, simulation.NewWeightedOperation( + weightMsgDeleteEvent, + storysimulation.SimulateMsgDeleteEvent(am.accountKeeper, am.bankKeeper, am.keeper), + )) + // this line is used by starport scaffolding # simapp/module/operation return operations diff --git a/x/story/simulation/event.go b/x/story/simulation/event.go new file mode 100644 index 0000000..2183b2d --- /dev/null +++ b/x/story/simulation/event.go @@ -0,0 +1,134 @@ +package simulation + +import ( + "math/rand" + + "github.com/cosmos/cosmos-sdk/baseapp" + simappparams "github.com/cosmos/cosmos-sdk/simapp/params" + sdk "github.com/cosmos/cosmos-sdk/types" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + "github.com/cosmos/cosmos-sdk/x/simulation" + "github.com/web-tree/story/x/story/keeper" + "github.com/web-tree/story/x/story/types" +) + +func SimulateMsgCreateEvent( + ak types.AccountKeeper, + bk types.BankKeeper, + k keeper.Keeper, +) simtypes.Operation { + return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + simAccount, _ := simtypes.RandomAcc(r, accs) + + msg := &types.MsgCreateEvent{ + Creator: simAccount.Address.String(), + } + + txCtx := simulation.OperationInput{ + R: r, + App: app, + TxGen: simappparams.MakeTestEncodingConfig().TxConfig, + Cdc: nil, + Msg: msg, + MsgType: msg.Type(), + Context: ctx, + SimAccount: simAccount, + ModuleName: types.ModuleName, + CoinsSpentInMsg: sdk.NewCoins(), + AccountKeeper: ak, + Bankkeeper: bk, + } + return simulation.GenAndDeliverTxWithRandFees(txCtx) + } +} + +func SimulateMsgUpdateEvent( + ak types.AccountKeeper, + bk types.BankKeeper, + k keeper.Keeper, +) simtypes.Operation { + return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + var ( + simAccount = simtypes.Account{} + event = types.Event{} + msg = &types.MsgUpdateEvent{} + allEvent = k.GetAllEvent(ctx) + found = false + ) + for _, obj := range allEvent { + simAccount, found = FindAccount(accs, obj.Creator) + if found { + event = obj + break + } + } + if !found { + return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "event creator not found"), nil, nil + } + msg.Creator = simAccount.Address.String() + msg.Id = event.Id + + txCtx := simulation.OperationInput{ + R: r, + App: app, + TxGen: simappparams.MakeTestEncodingConfig().TxConfig, + Cdc: nil, + Msg: msg, + MsgType: msg.Type(), + Context: ctx, + SimAccount: simAccount, + ModuleName: types.ModuleName, + CoinsSpentInMsg: sdk.NewCoins(), + AccountKeeper: ak, + Bankkeeper: bk, + } + return simulation.GenAndDeliverTxWithRandFees(txCtx) + } +} + +func SimulateMsgDeleteEvent( + ak types.AccountKeeper, + bk types.BankKeeper, + k keeper.Keeper, +) simtypes.Operation { + return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + var ( + simAccount = simtypes.Account{} + event = types.Event{} + msg = &types.MsgUpdateEvent{} + allEvent = k.GetAllEvent(ctx) + found = false + ) + for _, obj := range allEvent { + simAccount, found = FindAccount(accs, obj.Creator) + if found { + event = obj + break + } + } + if !found { + return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "event creator not found"), nil, nil + } + msg.Creator = simAccount.Address.String() + msg.Id = event.Id + + txCtx := simulation.OperationInput{ + R: r, + App: app, + TxGen: simappparams.MakeTestEncodingConfig().TxConfig, + Cdc: nil, + Msg: msg, + MsgType: msg.Type(), + Context: ctx, + SimAccount: simAccount, + ModuleName: types.ModuleName, + CoinsSpentInMsg: sdk.NewCoins(), + AccountKeeper: ak, + Bankkeeper: bk, + } + return simulation.GenAndDeliverTxWithRandFees(txCtx) + } +} diff --git a/x/story/types/codec.go b/x/story/types/codec.go index 844157a..ed34402 100644 --- a/x/story/types/codec.go +++ b/x/story/types/codec.go @@ -3,15 +3,23 @@ package types import ( "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - // this line is used by starport scaffolding # 1 + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/msgservice" ) func RegisterCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgCreateEvent{}, "story/CreateEvent", nil) + cdc.RegisterConcrete(&MsgUpdateEvent{}, "story/UpdateEvent", nil) + cdc.RegisterConcrete(&MsgDeleteEvent{}, "story/DeleteEvent", nil) // this line is used by starport scaffolding # 2 } func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgCreateEvent{}, + &MsgUpdateEvent{}, + &MsgDeleteEvent{}, + ) // this line is used by starport scaffolding # 3 msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) diff --git a/x/story/types/event.pb.go b/x/story/types/event.pb.go new file mode 100644 index 0000000..8a43c60 --- /dev/null +++ b/x/story/types/event.pb.go @@ -0,0 +1,712 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: story/event.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Event struct { + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + GiverId string `protobuf:"bytes,2,opt,name=giverId,proto3" json:"giverId,omitempty"` + TakerId string `protobuf:"bytes,3,opt,name=takerId,proto3" json:"takerId,omitempty"` + GiverSign string `protobuf:"bytes,4,opt,name=giverSign,proto3" json:"giverSign,omitempty"` + TakerSign string `protobuf:"bytes,5,opt,name=takerSign,proto3" json:"takerSign,omitempty"` + UnionId string `protobuf:"bytes,6,opt,name=unionId,proto3" json:"unionId,omitempty"` + TypeId string `protobuf:"bytes,7,opt,name=typeId,proto3" json:"typeId,omitempty"` + Body string `protobuf:"bytes,8,opt,name=body,proto3" json:"body,omitempty"` + Creator string `protobuf:"bytes,9,opt,name=creator,proto3" json:"creator,omitempty"` +} + +func (m *Event) Reset() { *m = Event{} } +func (m *Event) String() string { return proto.CompactTextString(m) } +func (*Event) ProtoMessage() {} +func (*Event) Descriptor() ([]byte, []int) { + return fileDescriptor_f90d8b6c8118420e, []int{0} +} +func (m *Event) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Event.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Event) XXX_Merge(src proto.Message) { + xxx_messageInfo_Event.Merge(m, src) +} +func (m *Event) XXX_Size() int { + return m.Size() +} +func (m *Event) XXX_DiscardUnknown() { + xxx_messageInfo_Event.DiscardUnknown(m) +} + +var xxx_messageInfo_Event proto.InternalMessageInfo + +func (m *Event) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +func (m *Event) GetGiverId() string { + if m != nil { + return m.GiverId + } + return "" +} + +func (m *Event) GetTakerId() string { + if m != nil { + return m.TakerId + } + return "" +} + +func (m *Event) GetGiverSign() string { + if m != nil { + return m.GiverSign + } + return "" +} + +func (m *Event) GetTakerSign() string { + if m != nil { + return m.TakerSign + } + return "" +} + +func (m *Event) GetUnionId() string { + if m != nil { + return m.UnionId + } + return "" +} + +func (m *Event) GetTypeId() string { + if m != nil { + return m.TypeId + } + return "" +} + +func (m *Event) GetBody() string { + if m != nil { + return m.Body + } + return "" +} + +func (m *Event) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func init() { + proto.RegisterType((*Event)(nil), "webtree.story.story.Event") +} + +func init() { proto.RegisterFile("story/event.proto", fileDescriptor_f90d8b6c8118420e) } + +var fileDescriptor_f90d8b6c8118420e = []byte{ + // 256 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x90, 0xb1, 0x4e, 0xc3, 0x30, + 0x18, 0x84, 0xe3, 0x90, 0xa6, 0xc4, 0x03, 0x12, 0x46, 0x42, 0x1e, 0x90, 0x55, 0xb1, 0xd0, 0x85, + 0x64, 0xe0, 0x09, 0x40, 0x62, 0xc8, 0x5a, 0x36, 0xb6, 0xba, 0xfe, 0x15, 0x2c, 0x84, 0x5d, 0xb9, + 0x6e, 0x4b, 0xde, 0x82, 0xc7, 0x62, 0xec, 0xc8, 0x88, 0x92, 0x81, 0xd7, 0x40, 0xfe, 0x6d, 0xe8, + 0x62, 0xfb, 0xee, 0x3b, 0x9d, 0xa5, 0xa3, 0xe7, 0x1b, 0x6f, 0x5d, 0xdf, 0xc0, 0x0e, 0x8c, 0xaf, + 0xd7, 0xce, 0x7a, 0xcb, 0x2e, 0xf6, 0x20, 0xbd, 0x03, 0xa8, 0x11, 0xc5, 0xf3, 0xfa, 0x87, 0xd0, + 0xc9, 0x63, 0x08, 0xb1, 0x33, 0x9a, 0x6b, 0xc5, 0xc9, 0x8c, 0xcc, 0x8b, 0x45, 0xae, 0x15, 0xe3, + 0x74, 0xda, 0xe9, 0x1d, 0xb8, 0x56, 0xf1, 0x7c, 0x46, 0xe6, 0xd5, 0xe2, 0x4f, 0x06, 0xe2, 0x97, + 0xaf, 0x48, 0x4e, 0x22, 0x49, 0x92, 0x5d, 0xd1, 0x0a, 0x43, 0x4f, 0xba, 0x33, 0xbc, 0x40, 0x76, + 0x34, 0x02, 0xc5, 0x20, 0xd2, 0x49, 0xa4, 0xff, 0x46, 0x68, 0xdd, 0x1a, 0x6d, 0x4d, 0xab, 0x78, + 0x19, 0x5b, 0x93, 0x64, 0x97, 0xb4, 0xf4, 0xfd, 0x1a, 0x5a, 0xc5, 0xa7, 0x08, 0x92, 0x62, 0x8c, + 0x16, 0xd2, 0xaa, 0x9e, 0x9f, 0xa2, 0x8b, 0xef, 0xd0, 0xb2, 0x72, 0xb0, 0xf4, 0xd6, 0xf1, 0x2a, + 0xb6, 0x24, 0xf9, 0x70, 0xff, 0x39, 0x08, 0x72, 0x18, 0x04, 0xf9, 0x1e, 0x04, 0xf9, 0x18, 0x45, + 0x76, 0x18, 0x45, 0xf6, 0x35, 0x8a, 0xec, 0xf9, 0xa6, 0xd3, 0xfe, 0x65, 0x2b, 0xeb, 0x95, 0x7d, + 0x6b, 0xf6, 0x20, 0x6f, 0xc3, 0x48, 0x4d, 0xdc, 0xef, 0x3d, 0xdd, 0xe1, 0xc7, 0x8d, 0x2c, 0x71, + 0xc8, 0xbb, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x16, 0x6d, 0xa4, 0xac, 0x5d, 0x01, 0x00, 0x00, +} + +func (m *Event) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Event) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0x4a + } + if len(m.Body) > 0 { + i -= len(m.Body) + copy(dAtA[i:], m.Body) + i = encodeVarintEvent(dAtA, i, uint64(len(m.Body))) + i-- + dAtA[i] = 0x42 + } + if len(m.TypeId) > 0 { + i -= len(m.TypeId) + copy(dAtA[i:], m.TypeId) + i = encodeVarintEvent(dAtA, i, uint64(len(m.TypeId))) + i-- + dAtA[i] = 0x3a + } + if len(m.UnionId) > 0 { + i -= len(m.UnionId) + copy(dAtA[i:], m.UnionId) + i = encodeVarintEvent(dAtA, i, uint64(len(m.UnionId))) + i-- + dAtA[i] = 0x32 + } + if len(m.TakerSign) > 0 { + i -= len(m.TakerSign) + copy(dAtA[i:], m.TakerSign) + i = encodeVarintEvent(dAtA, i, uint64(len(m.TakerSign))) + i-- + dAtA[i] = 0x2a + } + if len(m.GiverSign) > 0 { + i -= len(m.GiverSign) + copy(dAtA[i:], m.GiverSign) + i = encodeVarintEvent(dAtA, i, uint64(len(m.GiverSign))) + i-- + dAtA[i] = 0x22 + } + if len(m.TakerId) > 0 { + i -= len(m.TakerId) + copy(dAtA[i:], m.TakerId) + i = encodeVarintEvent(dAtA, i, uint64(len(m.TakerId))) + i-- + dAtA[i] = 0x1a + } + if len(m.GiverId) > 0 { + i -= len(m.GiverId) + copy(dAtA[i:], m.GiverId) + i = encodeVarintEvent(dAtA, i, uint64(len(m.GiverId))) + i-- + dAtA[i] = 0x12 + } + if m.Id != 0 { + i = encodeVarintEvent(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintEvent(dAtA []byte, offset int, v uint64) int { + offset -= sovEvent(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Event) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Id != 0 { + n += 1 + sovEvent(uint64(m.Id)) + } + l = len(m.GiverId) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.TakerId) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.GiverSign) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.TakerSign) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.UnionId) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.TypeId) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.Body) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovEvent(uint64(l)) + } + return n +} + +func sovEvent(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozEvent(x uint64) (n int) { + return sovEvent(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Event) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Event: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GiverId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GiverId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TakerId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TakerId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GiverSign", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GiverSign = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TakerSign", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TakerSign = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnionId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UnionId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TypeId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TypeId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Body = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvent + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvent + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvent + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvent(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvent + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEvent(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvent + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvent + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvent + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthEvent + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupEvent + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthEvent + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthEvent = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEvent = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupEvent = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/story/types/genesis.go b/x/story/types/genesis.go index d874e17..eac7cf7 100644 --- a/x/story/types/genesis.go +++ b/x/story/types/genesis.go @@ -1,8 +1,8 @@ package types import ( + "fmt" host "github.com/cosmos/ibc-go/v2/modules/core/24-host" - // this line is used by starport scaffolding # genesis/types/import ) // DefaultIndex is the default capability global index @@ -11,7 +11,8 @@ const DefaultIndex uint64 = 1 // DefaultGenesis returns the default Capability genesis state func DefaultGenesis() *GenesisState { return &GenesisState{ - PortId: PortID, + PortId: PortID, + EventList: []Event{}, // this line is used by starport scaffolding # genesis/types/default Params: DefaultParams(), } @@ -23,6 +24,18 @@ func (gs GenesisState) Validate() error { if err := host.PortIdentifierValidator(gs.PortId); err != nil { return err } + // Check for duplicated ID in event + eventIdMap := make(map[uint64]bool) + eventCount := gs.GetEventCount() + for _, elem := range gs.EventList { + if _, ok := eventIdMap[elem.Id]; ok { + return fmt.Errorf("duplicated id for event") + } + if elem.Id >= eventCount { + return fmt.Errorf("event id should be lower or equal than the last id") + } + eventIdMap[elem.Id] = true + } // this line is used by starport scaffolding # genesis/types/validate return gs.Params.Validate() diff --git a/x/story/types/genesis.pb.go b/x/story/types/genesis.pb.go index 3edceac..2e5b9a1 100644 --- a/x/story/types/genesis.pb.go +++ b/x/story/types/genesis.pb.go @@ -25,8 +25,10 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // GenesisState defines the story module's genesis state. type GenesisState struct { - Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` - PortId string `protobuf:"bytes,2,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"` + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + PortId string `protobuf:"bytes,2,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"` + EventList []Event `protobuf:"bytes,3,rep,name=eventList,proto3" json:"eventList"` + EventCount uint64 `protobuf:"varint,4,opt,name=eventCount,proto3" json:"eventCount,omitempty"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -76,6 +78,20 @@ func (m *GenesisState) GetPortId() string { return "" } +func (m *GenesisState) GetEventList() []Event { + if m != nil { + return m.EventList + } + return nil +} + +func (m *GenesisState) GetEventCount() uint64 { + if m != nil { + return m.EventCount + } + return 0 +} + func init() { proto.RegisterType((*GenesisState)(nil), "webtree.story.story.GenesisState") } @@ -83,21 +99,24 @@ func init() { func init() { proto.RegisterFile("story/genesis.proto", fileDescriptor_6284e1d261950306) } var fileDescriptor_6284e1d261950306 = []byte{ - // 210 bytes of a gzipped FileDescriptorProto + // 270 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2e, 0x2e, 0xc9, 0x2f, 0xaa, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x2e, 0x4f, 0x4d, 0x2a, 0x29, 0x4a, 0x4d, 0xd5, 0x03, 0x4b, 0x42, 0x48, 0x29, 0x91, 0xf4, 0xfc, 0xf4, 0x7c, 0xb0, 0xbc, 0x3e, 0x88, 0x05, 0x51, 0x2a, 0x25, 0x04, 0xd1, 0x5f, 0x90, 0x58, - 0x94, 0x98, 0x0b, 0xd5, 0xae, 0x94, 0xc4, 0xc5, 0xe3, 0x0e, 0x31, 0x2f, 0xb8, 0x24, 0xb1, 0x24, - 0x55, 0xc8, 0x92, 0x8b, 0x0d, 0x22, 0x2f, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0x24, 0xad, 0x87, - 0xc5, 0x7c, 0xbd, 0x00, 0xb0, 0x12, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xa0, 0x1a, 0x84, - 0xc4, 0xb9, 0xd8, 0x0b, 0xf2, 0x8b, 0x4a, 0xe2, 0x33, 0x53, 0x24, 0x98, 0x14, 0x18, 0x35, 0x38, - 0x83, 0xd8, 0x40, 0x5c, 0xcf, 0x14, 0x27, 0xc7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, - 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, - 0x63, 0x88, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x2f, 0x4f, - 0x4d, 0xd2, 0x05, 0x59, 0xa4, 0x0f, 0x71, 0x65, 0x05, 0x94, 0x2e, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, - 0x62, 0x03, 0xbb, 0xd6, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x7f, 0xfc, 0x7e, 0x67, 0x03, 0x01, - 0x00, 0x00, + 0x94, 0x98, 0x0b, 0xd5, 0x2e, 0x25, 0x08, 0x11, 0x4b, 0x2d, 0x4b, 0xcd, 0x2b, 0x81, 0x08, 0x29, + 0x1d, 0x62, 0xe4, 0xe2, 0x71, 0x87, 0xd8, 0x11, 0x5c, 0x92, 0x58, 0x92, 0x2a, 0x64, 0xc9, 0xc5, + 0x06, 0xd1, 0x23, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0x24, 0xad, 0x87, 0xc5, 0x4e, 0xbd, 0x00, + 0xb0, 0x12, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xa0, 0x1a, 0x84, 0xc4, 0xb9, 0xd8, 0x0b, + 0xf2, 0x8b, 0x4a, 0xe2, 0x33, 0x53, 0x24, 0x98, 0x14, 0x18, 0x35, 0x38, 0x83, 0xd8, 0x40, 0x5c, + 0xcf, 0x14, 0x21, 0x3b, 0x2e, 0x4e, 0xb0, 0x9d, 0x3e, 0x99, 0xc5, 0x25, 0x12, 0xcc, 0x0a, 0xcc, + 0x1a, 0xdc, 0x46, 0x52, 0x58, 0x8d, 0x75, 0x05, 0xa9, 0x82, 0x9a, 0x8a, 0xd0, 0x22, 0x24, 0xc7, + 0xc5, 0x05, 0xe6, 0x38, 0xe7, 0x97, 0xe6, 0x95, 0x48, 0xb0, 0x28, 0x30, 0x6a, 0xb0, 0x04, 0x21, + 0x89, 0x38, 0x39, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, + 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x7a, 0x7a, + 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x79, 0x6a, 0x92, 0x2e, 0xc8, 0x46, + 0x7d, 0x48, 0x28, 0x54, 0x40, 0xe9, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0x70, 0x70, 0x18, + 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xae, 0x9d, 0x03, 0xe4, 0x77, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -120,6 +139,25 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.EventCount != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.EventCount)) + i-- + dAtA[i] = 0x20 + } + if len(m.EventList) > 0 { + for iNdEx := len(m.EventList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.EventList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } if len(m.PortId) > 0 { i -= len(m.PortId) copy(dAtA[i:], m.PortId) @@ -163,6 +201,15 @@ func (m *GenesisState) Size() (n int) { if l > 0 { n += 1 + l + sovGenesis(uint64(l)) } + if len(m.EventList) > 0 { + for _, e := range m.EventList { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if m.EventCount != 0 { + n += 1 + sovGenesis(uint64(m.EventCount)) + } return n } @@ -266,6 +313,59 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { } m.PortId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EventList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EventList = append(m.EventList, Event{}) + if err := m.EventList[len(m.EventList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EventCount", wireType) + } + m.EventCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EventCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/story/types/genesis_test.go b/x/story/types/genesis_test.go index e4aceed..b4bfa4b 100644 --- a/x/story/types/genesis_test.go +++ b/x/story/types/genesis_test.go @@ -22,10 +22,45 @@ func TestGenesisState_Validate(t *testing.T) { desc: "valid genesis state", genState: &types.GenesisState{ PortId: types.PortID, + EventList: []types.Event{ + { + Id: 0, + }, + { + Id: 1, + }, + }, + EventCount: 2, // this line is used by starport scaffolding # types/genesis/validField }, valid: true, }, + { + desc: "duplicated event", + genState: &types.GenesisState{ + EventList: []types.Event{ + { + Id: 0, + }, + { + Id: 0, + }, + }, + }, + valid: false, + }, + { + desc: "invalid event count", + genState: &types.GenesisState{ + EventList: []types.Event{ + { + Id: 1, + }, + }, + EventCount: 0, + }, + valid: false, + }, // this line is used by starport scaffolding # types/genesis/testcase } { t.Run(tc.desc, func(t *testing.T) { diff --git a/x/story/types/keys.go b/x/story/types/keys.go index d0477e0..23929be 100644 --- a/x/story/types/keys.go +++ b/x/story/types/keys.go @@ -31,3 +31,8 @@ var ( func KeyPrefix(p string) []byte { return []byte(p) } + +const ( + EventKey = "Event-value-" + EventCountKey = "Event-count-" +) diff --git a/x/story/types/messages_event.go b/x/story/types/messages_event.go new file mode 100644 index 0000000..038e26e --- /dev/null +++ b/x/story/types/messages_event.go @@ -0,0 +1,138 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +const ( + TypeMsgCreateEvent = "create_event" + TypeMsgUpdateEvent = "update_event" + TypeMsgDeleteEvent = "delete_event" +) + +var _ sdk.Msg = &MsgCreateEvent{} + +func NewMsgCreateEvent(creator string, giverId string, takerId string, giverSign string, takerSign string, unionId string, typeId string, body string) *MsgCreateEvent { + return &MsgCreateEvent{ + Creator: creator, + GiverId: giverId, + TakerId: takerId, + GiverSign: giverSign, + TakerSign: takerSign, + UnionId: unionId, + TypeId: typeId, + Body: body, + } +} + +func (msg *MsgCreateEvent) Route() string { + return RouterKey +} + +func (msg *MsgCreateEvent) Type() string { + return TypeMsgCreateEvent +} + +func (msg *MsgCreateEvent) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgCreateEvent) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgCreateEvent) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + return nil +} + +var _ sdk.Msg = &MsgUpdateEvent{} + +func NewMsgUpdateEvent(creator string, id uint64, giverId string, takerId string, giverSign string, takerSign string, unionId string, typeId string, body string) *MsgUpdateEvent { + return &MsgUpdateEvent{ + Id: id, + Creator: creator, + GiverId: giverId, + TakerId: takerId, + GiverSign: giverSign, + TakerSign: takerSign, + UnionId: unionId, + TypeId: typeId, + Body: body, + } +} + +func (msg *MsgUpdateEvent) Route() string { + return RouterKey +} + +func (msg *MsgUpdateEvent) Type() string { + return TypeMsgUpdateEvent +} + +func (msg *MsgUpdateEvent) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgUpdateEvent) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgUpdateEvent) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + return nil +} + +var _ sdk.Msg = &MsgDeleteEvent{} + +func NewMsgDeleteEvent(creator string, id uint64) *MsgDeleteEvent { + return &MsgDeleteEvent{ + Id: id, + Creator: creator, + } +} +func (msg *MsgDeleteEvent) Route() string { + return RouterKey +} + +func (msg *MsgDeleteEvent) Type() string { + return TypeMsgDeleteEvent +} + +func (msg *MsgDeleteEvent) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgDeleteEvent) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgDeleteEvent) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + return nil +} diff --git a/x/story/types/messages_event_test.go b/x/story/types/messages_event_test.go new file mode 100644 index 0000000..9822d7c --- /dev/null +++ b/x/story/types/messages_event_test.go @@ -0,0 +1,102 @@ +package types + +import ( + "testing" + + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/stretchr/testify/require" + "github.com/web-tree/story/testutil/sample" +) + +func TestMsgCreateEvent_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgCreateEvent + err error + }{ + { + name: "invalid address", + msg: MsgCreateEvent{ + Creator: "invalid_address", + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "valid address", + msg: MsgCreateEvent{ + Creator: sample.AccAddress(), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} + +func TestMsgUpdateEvent_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgUpdateEvent + err error + }{ + { + name: "invalid address", + msg: MsgUpdateEvent{ + Creator: "invalid_address", + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "valid address", + msg: MsgUpdateEvent{ + Creator: sample.AccAddress(), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} + +func TestMsgDeleteEvent_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgDeleteEvent + err error + }{ + { + name: "invalid address", + msg: MsgDeleteEvent{ + Creator: "invalid_address", + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "valid address", + msg: MsgDeleteEvent{ + Creator: sample.AccAddress(), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} diff --git a/x/story/types/query.pb.go b/x/story/types/query.pb.go index 8fced9f..ee8dcdd 100644 --- a/x/story/types/query.pb.go +++ b/x/story/types/query.pb.go @@ -6,7 +6,7 @@ package types import ( context "context" fmt "fmt" - _ "github.com/cosmos/cosmos-sdk/types/query" + query "github.com/cosmos/cosmos-sdk/types/query" _ "github.com/gogo/protobuf/gogoproto" grpc1 "github.com/gogo/protobuf/grpc" proto "github.com/gogo/protobuf/proto" @@ -113,34 +113,234 @@ func (m *QueryParamsResponse) GetParams() Params { return Params{} } +type QueryGetEventRequest struct { + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *QueryGetEventRequest) Reset() { *m = QueryGetEventRequest{} } +func (m *QueryGetEventRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetEventRequest) ProtoMessage() {} +func (*QueryGetEventRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0fe5f29e243fdde2, []int{2} +} +func (m *QueryGetEventRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetEventRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetEventRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryGetEventRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetEventRequest.Merge(m, src) +} +func (m *QueryGetEventRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetEventRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetEventRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetEventRequest proto.InternalMessageInfo + +func (m *QueryGetEventRequest) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +type QueryGetEventResponse struct { + Event Event `protobuf:"bytes,1,opt,name=Event,proto3" json:"Event"` +} + +func (m *QueryGetEventResponse) Reset() { *m = QueryGetEventResponse{} } +func (m *QueryGetEventResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetEventResponse) ProtoMessage() {} +func (*QueryGetEventResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0fe5f29e243fdde2, []int{3} +} +func (m *QueryGetEventResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetEventResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryGetEventResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetEventResponse.Merge(m, src) +} +func (m *QueryGetEventResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetEventResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetEventResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetEventResponse proto.InternalMessageInfo + +func (m *QueryGetEventResponse) GetEvent() Event { + if m != nil { + return m.Event + } + return Event{} +} + +type QueryAllEventRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllEventRequest) Reset() { *m = QueryAllEventRequest{} } +func (m *QueryAllEventRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllEventRequest) ProtoMessage() {} +func (*QueryAllEventRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0fe5f29e243fdde2, []int{4} +} +func (m *QueryAllEventRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllEventRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllEventRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryAllEventRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllEventRequest.Merge(m, src) +} +func (m *QueryAllEventRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllEventRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllEventRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllEventRequest proto.InternalMessageInfo + +func (m *QueryAllEventRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryAllEventResponse struct { + Event []Event `protobuf:"bytes,1,rep,name=Event,proto3" json:"Event"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllEventResponse) Reset() { *m = QueryAllEventResponse{} } +func (m *QueryAllEventResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllEventResponse) ProtoMessage() {} +func (*QueryAllEventResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0fe5f29e243fdde2, []int{5} +} +func (m *QueryAllEventResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllEventResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryAllEventResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllEventResponse.Merge(m, src) +} +func (m *QueryAllEventResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllEventResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllEventResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllEventResponse proto.InternalMessageInfo + +func (m *QueryAllEventResponse) GetEvent() []Event { + if m != nil { + return m.Event + } + return nil +} + +func (m *QueryAllEventResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + func init() { proto.RegisterType((*QueryParamsRequest)(nil), "webtree.story.story.QueryParamsRequest") proto.RegisterType((*QueryParamsResponse)(nil), "webtree.story.story.QueryParamsResponse") + proto.RegisterType((*QueryGetEventRequest)(nil), "webtree.story.story.QueryGetEventRequest") + proto.RegisterType((*QueryGetEventResponse)(nil), "webtree.story.story.QueryGetEventResponse") + proto.RegisterType((*QueryAllEventRequest)(nil), "webtree.story.story.QueryAllEventRequest") + proto.RegisterType((*QueryAllEventResponse)(nil), "webtree.story.story.QueryAllEventResponse") } func init() { proto.RegisterFile("story/query.proto", fileDescriptor_0fe5f29e243fdde2) } var fileDescriptor_0fe5f29e243fdde2 = []byte{ - // 299 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x90, 0xb1, 0x4e, 0xf3, 0x30, - 0x14, 0x85, 0xe3, 0x5f, 0x3f, 0x19, 0xcc, 0x84, 0xdb, 0x01, 0xa5, 0x60, 0x50, 0x18, 0x5a, 0x21, - 0x11, 0xab, 0x65, 0x62, 0xa4, 0x4f, 0x50, 0x3a, 0xb2, 0x39, 0x95, 0x65, 0x22, 0x91, 0x5c, 0x37, - 0x76, 0x80, 0x6c, 0x88, 0x91, 0x09, 0x89, 0x97, 0xea, 0x58, 0x89, 0x85, 0x09, 0xa1, 0x84, 0x07, - 0x41, 0xb1, 0x3d, 0x14, 0x51, 0x89, 0x25, 0xb1, 0xee, 0x3d, 0xdf, 0xf1, 0x39, 0xc6, 0x7b, 0xda, - 0x40, 0x59, 0xb3, 0x65, 0x25, 0xca, 0x3a, 0x51, 0x25, 0x18, 0x20, 0xbd, 0x7b, 0x91, 0x9a, 0x52, - 0x88, 0xc4, 0xae, 0xdc, 0x37, 0xea, 0x4b, 0x90, 0x60, 0xf7, 0xac, 0x3b, 0x39, 0x69, 0x74, 0x20, - 0x01, 0xe4, 0xad, 0x60, 0x5c, 0x65, 0x8c, 0x17, 0x05, 0x18, 0x6e, 0x32, 0x28, 0xb4, 0xdf, 0x9e, - 0x2e, 0x40, 0xe7, 0xa0, 0x59, 0xca, 0xb5, 0x70, 0x37, 0xb0, 0xbb, 0x71, 0x2a, 0x0c, 0x1f, 0x33, - 0xc5, 0x65, 0x56, 0x58, 0xb1, 0xd7, 0x12, 0x97, 0x43, 0xf1, 0x92, 0xe7, 0x9e, 0x8f, 0xfb, 0x98, - 0x5c, 0x75, 0xd4, 0xcc, 0x0e, 0xe7, 0x62, 0x59, 0x09, 0x6d, 0xe2, 0x19, 0xee, 0xfd, 0x98, 0x6a, - 0x05, 0x85, 0x16, 0xe4, 0x02, 0x87, 0x0e, 0xde, 0x47, 0xc7, 0x68, 0xb4, 0x3b, 0x19, 0x24, 0x5b, - 0x6a, 0x24, 0x0e, 0x9a, 0xfe, 0x5f, 0x7d, 0x1c, 0x05, 0x73, 0x0f, 0x4c, 0x9e, 0x11, 0xde, 0xb1, - 0x96, 0xe4, 0x11, 0xe1, 0xd0, 0x49, 0xc8, 0x70, 0x2b, 0xff, 0x3b, 0x4f, 0x34, 0xfa, 0x5b, 0xe8, - 0x22, 0xc6, 0x27, 0x4f, 0x6f, 0x5f, 0xaf, 0xff, 0x0e, 0xc9, 0x80, 0x79, 0x82, 0xb9, 0xd2, 0x9b, - 0xd5, 0xa7, 0x97, 0xab, 0x86, 0xa2, 0x75, 0x43, 0xd1, 0x67, 0x43, 0xd1, 0x4b, 0x4b, 0x83, 0x75, - 0x4b, 0x83, 0xf7, 0x96, 0x06, 0xd7, 0x43, 0x99, 0x99, 0x9b, 0x2a, 0x4d, 0x16, 0x90, 0x77, 0x06, - 0x67, 0x1b, 0x0e, 0x0f, 0xfe, 0x6f, 0x6a, 0x25, 0x74, 0x1a, 0xda, 0xe7, 0x3b, 0xff, 0x0e, 0x00, - 0x00, 0xff, 0xff, 0x8e, 0xd8, 0x23, 0x7e, 0xdc, 0x01, 0x00, 0x00, + // 481 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0xcf, 0x6b, 0xd4, 0x40, + 0x14, 0xc7, 0x33, 0x69, 0xbb, 0xc8, 0x08, 0x82, 0xd3, 0x15, 0x24, 0xd5, 0x58, 0x46, 0xe8, 0xae, + 0x05, 0x67, 0x68, 0x05, 0xc1, 0xe3, 0x16, 0xb4, 0x47, 0xd7, 0x1c, 0x3d, 0x08, 0x93, 0xee, 0x10, + 0x03, 0xd9, 0x4c, 0x9a, 0x99, 0xad, 0x2e, 0x22, 0x88, 0x07, 0xf1, 0x28, 0x78, 0xf1, 0xe4, 0xdf, + 0xd3, 0x63, 0xc1, 0x8b, 0x27, 0x91, 0x5d, 0xff, 0x10, 0xc9, 0xcc, 0x93, 0x6e, 0xb2, 0xbf, 0xec, + 0x65, 0x37, 0xcc, 0x7c, 0xdf, 0xf7, 0xfb, 0xc9, 0x7b, 0x2f, 0xf8, 0xa6, 0x36, 0xaa, 0x1c, 0xf3, + 0xd3, 0x91, 0x2c, 0xc7, 0xac, 0x28, 0x95, 0x51, 0x64, 0xfb, 0x8d, 0x8c, 0x4d, 0x29, 0x25, 0xb3, + 0x57, 0xee, 0x37, 0x68, 0x27, 0x2a, 0x51, 0xf6, 0x9e, 0x57, 0x4f, 0x4e, 0x1a, 0xdc, 0x49, 0x94, + 0x4a, 0x32, 0xc9, 0x45, 0x91, 0x72, 0x91, 0xe7, 0xca, 0x08, 0x93, 0xaa, 0x5c, 0xc3, 0xed, 0xfe, + 0x89, 0xd2, 0x43, 0xa5, 0x79, 0x2c, 0xb4, 0x74, 0x09, 0xfc, 0xec, 0x20, 0x96, 0x46, 0x1c, 0xf0, + 0x42, 0x24, 0x69, 0x6e, 0xc5, 0xa0, 0x25, 0x8e, 0xa3, 0x10, 0xa5, 0x18, 0xfe, 0xab, 0x07, 0x36, + 0x79, 0x26, 0x73, 0xe3, 0x8e, 0x68, 0x1b, 0x93, 0x17, 0x95, 0x51, 0xdf, 0xea, 0x22, 0x79, 0x3a, + 0x92, 0xda, 0xd0, 0x3e, 0xde, 0xae, 0x9d, 0xea, 0x42, 0xe5, 0x5a, 0x92, 0x27, 0xb8, 0xe5, 0xfc, + 0x6e, 0xa3, 0x5d, 0xd4, 0xbd, 0x7e, 0xb8, 0xc3, 0x16, 0xbc, 0x19, 0x73, 0x45, 0x47, 0x9b, 0xe7, + 0xbf, 0xee, 0x79, 0x11, 0x14, 0xd0, 0x3d, 0xdc, 0xb6, 0x8e, 0xc7, 0xd2, 0x3c, 0xad, 0xe2, 0x21, + 0x89, 0xdc, 0xc0, 0x7e, 0x3a, 0xb0, 0x76, 0x9b, 0x91, 0x9f, 0x0e, 0xe8, 0x73, 0x7c, 0xab, 0xa1, + 0x83, 0xec, 0xc7, 0x78, 0xcb, 0x1e, 0x40, 0x74, 0xb0, 0x30, 0xda, 0x2a, 0x20, 0xd9, 0xc9, 0xe9, + 0x2b, 0x08, 0xee, 0x65, 0x59, 0x2d, 0xf8, 0x19, 0xc6, 0x97, 0x3d, 0x03, 0xd3, 0x3d, 0xe6, 0x1a, + 0xcc, 0xaa, 0x06, 0x33, 0x37, 0x42, 0x68, 0x30, 0xeb, 0x8b, 0x44, 0x42, 0x6d, 0x34, 0x53, 0x49, + 0xbf, 0x21, 0x20, 0xbe, 0x0c, 0x98, 0x27, 0xde, 0xb8, 0x02, 0x31, 0x39, 0xae, 0x91, 0xf9, 0x96, + 0xac, 0xb3, 0x96, 0xcc, 0x85, 0xce, 0xa2, 0x1d, 0x7e, 0xdf, 0xc0, 0x5b, 0x16, 0x8d, 0x7c, 0x40, + 0xb8, 0xe5, 0xc6, 0x42, 0x3a, 0x0b, 0x31, 0xe6, 0x77, 0x20, 0xe8, 0xae, 0x17, 0xba, 0x4c, 0x7a, + 0xff, 0xe3, 0x8f, 0x3f, 0x5f, 0xfd, 0xbb, 0x64, 0x87, 0x43, 0x05, 0x77, 0x7b, 0x36, 0xbb, 0x81, + 0xe4, 0x33, 0x82, 0x76, 0x90, 0x07, 0xcb, 0x8d, 0x1b, 0xdb, 0x11, 0xec, 0xff, 0x8f, 0x14, 0x28, + 0xba, 0x96, 0x82, 0x92, 0xdd, 0x8a, 0xe2, 0xe1, 0x1c, 0x86, 0x5d, 0x7a, 0xfe, 0x2e, 0x1d, 0xbc, + 0x27, 0x9f, 0x10, 0xbe, 0x66, 0x6b, 0x7b, 0x59, 0xb6, 0x8a, 0xa6, 0xb1, 0x32, 0xab, 0x68, 0x9a, + 0xc3, 0xaf, 0xf7, 0x64, 0x09, 0xcd, 0x51, 0xef, 0x7c, 0x12, 0xa2, 0x8b, 0x49, 0x88, 0x7e, 0x4f, + 0x42, 0xf4, 0x65, 0x1a, 0x7a, 0x17, 0xd3, 0xd0, 0xfb, 0x39, 0x0d, 0xbd, 0x97, 0x9d, 0x24, 0x35, + 0xaf, 0x47, 0x31, 0x3b, 0x51, 0xc3, 0xa6, 0xc1, 0x5b, 0xf8, 0x37, 0xe3, 0x42, 0xea, 0xb8, 0x65, + 0x3f, 0xe3, 0x47, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x01, 0xe6, 0x0c, 0xfb, 0x77, 0x04, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -157,6 +357,10 @@ const _ = grpc.SupportPackageIsVersion4 type QueryClient interface { // Parameters queries the parameters of the module. Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) + // Queries a Event by id. + Event(ctx context.Context, in *QueryGetEventRequest, opts ...grpc.CallOption) (*QueryGetEventResponse, error) + // Queries a list of Event items. + EventAll(ctx context.Context, in *QueryAllEventRequest, opts ...grpc.CallOption) (*QueryAllEventResponse, error) } type queryClient struct { @@ -176,10 +380,32 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts . return out, nil } +func (c *queryClient) Event(ctx context.Context, in *QueryGetEventRequest, opts ...grpc.CallOption) (*QueryGetEventResponse, error) { + out := new(QueryGetEventResponse) + err := c.cc.Invoke(ctx, "/webtree.story.story.Query/Event", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) EventAll(ctx context.Context, in *QueryAllEventRequest, opts ...grpc.CallOption) (*QueryAllEventResponse, error) { + out := new(QueryAllEventResponse) + err := c.cc.Invoke(ctx, "/webtree.story.story.Query/EventAll", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Parameters queries the parameters of the module. Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) + // Queries a Event by id. + Event(context.Context, *QueryGetEventRequest) (*QueryGetEventResponse, error) + // Queries a list of Event items. + EventAll(context.Context, *QueryAllEventRequest) (*QueryAllEventResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -189,6 +415,12 @@ type UnimplementedQueryServer struct { func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } +func (*UnimplementedQueryServer) Event(ctx context.Context, req *QueryGetEventRequest) (*QueryGetEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Event not implemented") +} +func (*UnimplementedQueryServer) EventAll(ctx context.Context, req *QueryAllEventRequest) (*QueryAllEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EventAll not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -212,6 +444,42 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf return interceptor(ctx, in, info, handler) } +func _Query_Event_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Event(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/webtree.story.story.Query/Event", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Event(ctx, req.(*QueryGetEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_EventAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).EventAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/webtree.story.story.Query/EventAll", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).EventAll(ctx, req.(*QueryAllEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "webtree.story.story.Query", HandlerType: (*QueryServer)(nil), @@ -220,6 +488,14 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "Params", Handler: _Query_Params_Handler, }, + { + MethodName: "Event", + Handler: _Query_Event_Handler, + }, + { + MethodName: "EventAll", + Handler: _Query_EventAll_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "story/query.proto", @@ -281,6 +557,151 @@ func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryGetEventRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryGetEventRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetEventRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Id != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryGetEventResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryGetEventResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetEventResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Event.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryAllEventRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryAllEventRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllEventRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllEventResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryAllEventResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllEventResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Event) > 0 { + for iNdEx := len(m.Event) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Event[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { offset -= sovQuery(v) base := offset @@ -312,7 +733,62 @@ func (m *QueryParamsResponse) Size() (n int) { return n } -func sovQuery(x uint64) (n int) { +func (m *QueryGetEventRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Id != 0 { + n += 1 + sovQuery(uint64(m.Id)) + } + return n +} + +func (m *QueryGetEventResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Event.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryAllEventRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllEventResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Event) > 0 { + for _, e := range m.Event { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozQuery(x uint64) (n int) { @@ -451,6 +927,364 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryGetEventRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryGetEventRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetEventRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetEventResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryGetEventResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetEventResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllEventRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAllEventRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllEventRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllEventResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAllEventResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllEventResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Event = append(m.Event, Event{}) + if err := m.Event[len(m.Event)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/story/types/query.pb.gw.go b/x/story/types/query.pb.gw.go index 766ee80..e471269 100644 --- a/x/story/types/query.pb.gw.go +++ b/x/story/types/query.pb.gw.go @@ -51,6 +51,96 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal } +func request_Query_Event_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryGetEventRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + + protoReq.Id, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + + msg, err := client.Event(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Event_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryGetEventRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + + protoReq.Id, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + + msg, err := server.Event(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_Query_EventAll_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_EventAll_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllEventRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_EventAll_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.EventAll(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_EventAll_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllEventRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_EventAll_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.EventAll(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -80,6 +170,52 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_Event_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Event_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Event_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_EventAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_EventAll_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_EventAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -141,13 +277,61 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_Event_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Event_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Event_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_EventAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_EventAll_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_EventAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } var ( pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"webtree", "story", "params"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_Event_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"web-tree", "story", "event", "id"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_EventAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"web-tree", "story", "event"}, "", runtime.AssumeColonVerbOpt(true))) ) var ( forward_Query_Params_0 = runtime.ForwardResponseMessage + + forward_Query_Event_0 = runtime.ForwardResponseMessage + + forward_Query_EventAll_0 = runtime.ForwardResponseMessage ) diff --git a/x/story/types/tx.pb.go b/x/story/types/tx.pb.go index d888d4d..3f18ec6 100644 --- a/x/story/types/tx.pb.go +++ b/x/story/types/tx.pb.go @@ -9,7 +9,11 @@ import ( grpc1 "github.com/gogo/protobuf/grpc" proto "github.com/gogo/protobuf/proto" grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" math "math" + math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. @@ -23,18 +27,421 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +type MsgCreateEvent struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + GiverId string `protobuf:"bytes,2,opt,name=giverId,proto3" json:"giverId,omitempty"` + TakerId string `protobuf:"bytes,3,opt,name=takerId,proto3" json:"takerId,omitempty"` + GiverSign string `protobuf:"bytes,4,opt,name=giverSign,proto3" json:"giverSign,omitempty"` + TakerSign string `protobuf:"bytes,5,opt,name=takerSign,proto3" json:"takerSign,omitempty"` + UnionId string `protobuf:"bytes,6,opt,name=unionId,proto3" json:"unionId,omitempty"` + TypeId string `protobuf:"bytes,7,opt,name=typeId,proto3" json:"typeId,omitempty"` + Body string `protobuf:"bytes,8,opt,name=body,proto3" json:"body,omitempty"` +} + +func (m *MsgCreateEvent) Reset() { *m = MsgCreateEvent{} } +func (m *MsgCreateEvent) String() string { return proto.CompactTextString(m) } +func (*MsgCreateEvent) ProtoMessage() {} +func (*MsgCreateEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_c9206e9f0466d673, []int{0} +} +func (m *MsgCreateEvent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreateEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreateEvent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgCreateEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreateEvent.Merge(m, src) +} +func (m *MsgCreateEvent) XXX_Size() int { + return m.Size() +} +func (m *MsgCreateEvent) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreateEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreateEvent proto.InternalMessageInfo + +func (m *MsgCreateEvent) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *MsgCreateEvent) GetGiverId() string { + if m != nil { + return m.GiverId + } + return "" +} + +func (m *MsgCreateEvent) GetTakerId() string { + if m != nil { + return m.TakerId + } + return "" +} + +func (m *MsgCreateEvent) GetGiverSign() string { + if m != nil { + return m.GiverSign + } + return "" +} + +func (m *MsgCreateEvent) GetTakerSign() string { + if m != nil { + return m.TakerSign + } + return "" +} + +func (m *MsgCreateEvent) GetUnionId() string { + if m != nil { + return m.UnionId + } + return "" +} + +func (m *MsgCreateEvent) GetTypeId() string { + if m != nil { + return m.TypeId + } + return "" +} + +func (m *MsgCreateEvent) GetBody() string { + if m != nil { + return m.Body + } + return "" +} + +type MsgCreateEventResponse struct { + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *MsgCreateEventResponse) Reset() { *m = MsgCreateEventResponse{} } +func (m *MsgCreateEventResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCreateEventResponse) ProtoMessage() {} +func (*MsgCreateEventResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_c9206e9f0466d673, []int{1} +} +func (m *MsgCreateEventResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreateEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreateEventResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgCreateEventResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreateEventResponse.Merge(m, src) +} +func (m *MsgCreateEventResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgCreateEventResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreateEventResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreateEventResponse proto.InternalMessageInfo + +func (m *MsgCreateEventResponse) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +type MsgUpdateEvent struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` + GiverId string `protobuf:"bytes,3,opt,name=giverId,proto3" json:"giverId,omitempty"` + TakerId string `protobuf:"bytes,4,opt,name=takerId,proto3" json:"takerId,omitempty"` + GiverSign string `protobuf:"bytes,5,opt,name=giverSign,proto3" json:"giverSign,omitempty"` + TakerSign string `protobuf:"bytes,6,opt,name=takerSign,proto3" json:"takerSign,omitempty"` + UnionId string `protobuf:"bytes,7,opt,name=unionId,proto3" json:"unionId,omitempty"` + TypeId string `protobuf:"bytes,8,opt,name=typeId,proto3" json:"typeId,omitempty"` + Body string `protobuf:"bytes,9,opt,name=body,proto3" json:"body,omitempty"` +} + +func (m *MsgUpdateEvent) Reset() { *m = MsgUpdateEvent{} } +func (m *MsgUpdateEvent) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateEvent) ProtoMessage() {} +func (*MsgUpdateEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_c9206e9f0466d673, []int{2} +} +func (m *MsgUpdateEvent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateEvent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateEvent.Merge(m, src) +} +func (m *MsgUpdateEvent) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateEvent) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateEvent proto.InternalMessageInfo + +func (m *MsgUpdateEvent) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *MsgUpdateEvent) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +func (m *MsgUpdateEvent) GetGiverId() string { + if m != nil { + return m.GiverId + } + return "" +} + +func (m *MsgUpdateEvent) GetTakerId() string { + if m != nil { + return m.TakerId + } + return "" +} + +func (m *MsgUpdateEvent) GetGiverSign() string { + if m != nil { + return m.GiverSign + } + return "" +} + +func (m *MsgUpdateEvent) GetTakerSign() string { + if m != nil { + return m.TakerSign + } + return "" +} + +func (m *MsgUpdateEvent) GetUnionId() string { + if m != nil { + return m.UnionId + } + return "" +} + +func (m *MsgUpdateEvent) GetTypeId() string { + if m != nil { + return m.TypeId + } + return "" +} + +func (m *MsgUpdateEvent) GetBody() string { + if m != nil { + return m.Body + } + return "" +} + +type MsgUpdateEventResponse struct { +} + +func (m *MsgUpdateEventResponse) Reset() { *m = MsgUpdateEventResponse{} } +func (m *MsgUpdateEventResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateEventResponse) ProtoMessage() {} +func (*MsgUpdateEventResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_c9206e9f0466d673, []int{3} +} +func (m *MsgUpdateEventResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateEventResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateEventResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateEventResponse.Merge(m, src) +} +func (m *MsgUpdateEventResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateEventResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateEventResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateEventResponse proto.InternalMessageInfo + +type MsgDeleteEvent struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *MsgDeleteEvent) Reset() { *m = MsgDeleteEvent{} } +func (m *MsgDeleteEvent) String() string { return proto.CompactTextString(m) } +func (*MsgDeleteEvent) ProtoMessage() {} +func (*MsgDeleteEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_c9206e9f0466d673, []int{4} +} +func (m *MsgDeleteEvent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDeleteEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDeleteEvent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgDeleteEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDeleteEvent.Merge(m, src) +} +func (m *MsgDeleteEvent) XXX_Size() int { + return m.Size() +} +func (m *MsgDeleteEvent) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDeleteEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgDeleteEvent proto.InternalMessageInfo + +func (m *MsgDeleteEvent) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *MsgDeleteEvent) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +type MsgDeleteEventResponse struct { +} + +func (m *MsgDeleteEventResponse) Reset() { *m = MsgDeleteEventResponse{} } +func (m *MsgDeleteEventResponse) String() string { return proto.CompactTextString(m) } +func (*MsgDeleteEventResponse) ProtoMessage() {} +func (*MsgDeleteEventResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_c9206e9f0466d673, []int{5} +} +func (m *MsgDeleteEventResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDeleteEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDeleteEventResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgDeleteEventResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDeleteEventResponse.Merge(m, src) +} +func (m *MsgDeleteEventResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgDeleteEventResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDeleteEventResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgDeleteEventResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgCreateEvent)(nil), "webtree.story.story.MsgCreateEvent") + proto.RegisterType((*MsgCreateEventResponse)(nil), "webtree.story.story.MsgCreateEventResponse") + proto.RegisterType((*MsgUpdateEvent)(nil), "webtree.story.story.MsgUpdateEvent") + proto.RegisterType((*MsgUpdateEventResponse)(nil), "webtree.story.story.MsgUpdateEventResponse") + proto.RegisterType((*MsgDeleteEvent)(nil), "webtree.story.story.MsgDeleteEvent") + proto.RegisterType((*MsgDeleteEventResponse)(nil), "webtree.story.story.MsgDeleteEventResponse") +} + func init() { proto.RegisterFile("story/tx.proto", fileDescriptor_c9206e9f0466d673) } var fileDescriptor_c9206e9f0466d673 = []byte{ - // 123 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2b, 0x2e, 0xc9, 0x2f, - 0xaa, 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x2e, 0x4f, 0x4d, 0x2a, - 0x29, 0x4a, 0x4d, 0xd5, 0x03, 0x8b, 0x43, 0x48, 0x23, 0x56, 0x2e, 0x66, 0xdf, 0xe2, 0x74, 0x27, - 0xc7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, - 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, - 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x2f, 0x4f, 0x4d, 0xd2, 0x05, 0x99, 0xa0, 0x0f, 0x31, - 0xb9, 0x02, 0x4a, 0x97, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x6d, 0x31, 0x06, 0x04, 0x00, - 0x00, 0xff, 0xff, 0xe6, 0xf6, 0x37, 0xe9, 0x77, 0x00, 0x00, 0x00, + // 406 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0xcf, 0x6a, 0xfa, 0x40, + 0x10, 0xc7, 0x4d, 0x8c, 0x51, 0x57, 0x10, 0x7e, 0xfb, 0x03, 0x59, 0xa4, 0x84, 0x92, 0x1e, 0x2a, + 0x94, 0x46, 0x68, 0x6f, 0xbd, 0xf5, 0xdf, 0xc1, 0x83, 0x17, 0x4b, 0x2f, 0xbd, 0x88, 0x31, 0x43, + 0x1a, 0xda, 0x66, 0x43, 0xb2, 0xfe, 0x7b, 0x8b, 0x3e, 0x46, 0x1f, 0xa5, 0x47, 0x8f, 0x3d, 0x8a, + 0xbe, 0x40, 0x1f, 0xa1, 0xec, 0x6e, 0x62, 0x57, 0x48, 0xc4, 0x5e, 0x34, 0x33, 0xdf, 0xef, 0xce, + 0x30, 0x9f, 0xd9, 0x45, 0xcd, 0x84, 0xd1, 0x78, 0xd1, 0x65, 0x73, 0x27, 0x8a, 0x29, 0xa3, 0xf8, + 0xff, 0x0c, 0x5c, 0x16, 0x03, 0x38, 0x22, 0x2f, 0x7f, 0xdb, 0xff, 0xa4, 0x09, 0xa6, 0x10, 0x32, + 0xe9, 0xb3, 0x57, 0x1a, 0x6a, 0xf6, 0x13, 0xff, 0x36, 0x86, 0x11, 0x83, 0x7b, 0x2e, 0x60, 0x82, + 0xaa, 0x63, 0x1e, 0xd2, 0x98, 0x68, 0xc7, 0x5a, 0xa7, 0x3e, 0xc8, 0x42, 0xae, 0xf8, 0xc1, 0x14, + 0xe2, 0x9e, 0x47, 0x74, 0xa9, 0xa4, 0x21, 0x57, 0xd8, 0xe8, 0x45, 0x28, 0x65, 0xa9, 0xa4, 0x21, + 0x3e, 0x42, 0x75, 0x61, 0x7a, 0x08, 0xfc, 0x90, 0x18, 0x42, 0xfb, 0x4d, 0x70, 0x55, 0x18, 0x85, + 0x5a, 0x91, 0xea, 0x36, 0xc1, 0xab, 0x4e, 0xc2, 0x80, 0x86, 0x3d, 0x8f, 0x98, 0xb2, 0x6a, 0x1a, + 0xe2, 0x16, 0x32, 0xd9, 0x22, 0x82, 0x9e, 0x47, 0xaa, 0x42, 0x48, 0x23, 0x8c, 0x91, 0xe1, 0x52, + 0x6f, 0x41, 0x6a, 0x22, 0x2b, 0xbe, 0xed, 0x0e, 0x6a, 0xed, 0x4e, 0x38, 0x80, 0x24, 0xa2, 0x61, + 0x02, 0xb8, 0x89, 0xf4, 0xc0, 0x13, 0x43, 0x1a, 0x03, 0x3d, 0xf0, 0xec, 0x6f, 0x09, 0xe3, 0x31, + 0xf2, 0x0e, 0x80, 0x21, 0x0f, 0xeb, 0xd9, 0x61, 0x15, 0x4e, 0xb9, 0x10, 0x8e, 0xb1, 0x07, 0x4e, + 0x65, 0x2f, 0x1c, 0x73, 0x0f, 0x9c, 0x6a, 0x11, 0x9c, 0x5a, 0x2e, 0x9c, 0xba, 0x02, 0x87, 0x08, + 0x38, 0xca, 0xc4, 0x19, 0x1c, 0xfb, 0x4a, 0xb0, 0xb8, 0x83, 0x57, 0xf8, 0x33, 0x8b, 0xb4, 0xaa, + 0x72, 0x36, 0xab, 0x7a, 0xf1, 0xa1, 0xa3, 0x72, 0x3f, 0xf1, 0xf1, 0x10, 0x35, 0xd4, 0x3b, 0x77, + 0xe2, 0xe4, 0xdc, 0x57, 0x67, 0x77, 0x6d, 0xed, 0xb3, 0x03, 0x4c, 0xdb, 0xdd, 0x0e, 0x51, 0x43, + 0xdd, 0x63, 0x61, 0x03, 0xc5, 0x54, 0xdc, 0x20, 0x87, 0x0f, 0x6f, 0xa0, 0xc2, 0x29, 0x6c, 0xa0, + 0x98, 0x8a, 0x1b, 0xe4, 0xa0, 0xba, 0xb9, 0xfe, 0x5c, 0x5b, 0xda, 0x72, 0x6d, 0x69, 0xab, 0xb5, + 0xa5, 0xbd, 0x6f, 0xac, 0xd2, 0x72, 0x63, 0x95, 0xbe, 0x36, 0x56, 0xe9, 0xe9, 0xd4, 0x0f, 0xd8, + 0xf3, 0xc4, 0x75, 0xc6, 0xf4, 0xad, 0x3b, 0x03, 0xf7, 0x9c, 0x57, 0xec, 0xca, 0xb7, 0x3d, 0x4f, + 0xff, 0xf9, 0xca, 0x13, 0xd7, 0x14, 0x8f, 0xfc, 0xf2, 0x27, 0x00, 0x00, 0xff, 0xff, 0xda, 0x03, + 0x7f, 0xc3, 0x1e, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -49,6 +456,9 @@ const _ = grpc.SupportPackageIsVersion4 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type MsgClient interface { + CreateEvent(ctx context.Context, in *MsgCreateEvent, opts ...grpc.CallOption) (*MsgCreateEventResponse, error) + UpdateEvent(ctx context.Context, in *MsgUpdateEvent, opts ...grpc.CallOption) (*MsgUpdateEventResponse, error) + DeleteEvent(ctx context.Context, in *MsgDeleteEvent, opts ...grpc.CallOption) (*MsgDeleteEventResponse, error) } type msgClient struct { @@ -59,22 +469,1535 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient { return &msgClient{cc} } +func (c *msgClient) CreateEvent(ctx context.Context, in *MsgCreateEvent, opts ...grpc.CallOption) (*MsgCreateEventResponse, error) { + out := new(MsgCreateEventResponse) + err := c.cc.Invoke(ctx, "/webtree.story.story.Msg/CreateEvent", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateEvent(ctx context.Context, in *MsgUpdateEvent, opts ...grpc.CallOption) (*MsgUpdateEventResponse, error) { + out := new(MsgUpdateEventResponse) + err := c.cc.Invoke(ctx, "/webtree.story.story.Msg/UpdateEvent", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) DeleteEvent(ctx context.Context, in *MsgDeleteEvent, opts ...grpc.CallOption) (*MsgDeleteEventResponse, error) { + out := new(MsgDeleteEventResponse) + err := c.cc.Invoke(ctx, "/webtree.story.story.Msg/DeleteEvent", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { + CreateEvent(context.Context, *MsgCreateEvent) (*MsgCreateEventResponse, error) + UpdateEvent(context.Context, *MsgUpdateEvent) (*MsgUpdateEventResponse, error) + DeleteEvent(context.Context, *MsgDeleteEvent) (*MsgDeleteEventResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. type UnimplementedMsgServer struct { } +func (*UnimplementedMsgServer) CreateEvent(ctx context.Context, req *MsgCreateEvent) (*MsgCreateEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateEvent not implemented") +} +func (*UnimplementedMsgServer) UpdateEvent(ctx context.Context, req *MsgUpdateEvent) (*MsgUpdateEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateEvent not implemented") +} +func (*UnimplementedMsgServer) DeleteEvent(ctx context.Context, req *MsgDeleteEvent) (*MsgDeleteEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteEvent not implemented") +} + func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) } +func _Msg_CreateEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreateEvent) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CreateEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/webtree.story.story.Msg/CreateEvent", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreateEvent(ctx, req.(*MsgCreateEvent)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateEvent) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/webtree.story.story.Msg/UpdateEvent", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateEvent(ctx, req.(*MsgUpdateEvent)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_DeleteEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDeleteEvent) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).DeleteEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/webtree.story.story.Msg/DeleteEvent", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DeleteEvent(ctx, req.(*MsgDeleteEvent)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "webtree.story.story.Msg", HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{}, - Streams: []grpc.StreamDesc{}, - Metadata: "story/tx.proto", + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateEvent", + Handler: _Msg_CreateEvent_Handler, + }, + { + MethodName: "UpdateEvent", + Handler: _Msg_UpdateEvent_Handler, + }, + { + MethodName: "DeleteEvent", + Handler: _Msg_DeleteEvent_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "story/tx.proto", +} + +func (m *MsgCreateEvent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgCreateEvent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreateEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Body) > 0 { + i -= len(m.Body) + copy(dAtA[i:], m.Body) + i = encodeVarintTx(dAtA, i, uint64(len(m.Body))) + i-- + dAtA[i] = 0x42 + } + if len(m.TypeId) > 0 { + i -= len(m.TypeId) + copy(dAtA[i:], m.TypeId) + i = encodeVarintTx(dAtA, i, uint64(len(m.TypeId))) + i-- + dAtA[i] = 0x3a + } + if len(m.UnionId) > 0 { + i -= len(m.UnionId) + copy(dAtA[i:], m.UnionId) + i = encodeVarintTx(dAtA, i, uint64(len(m.UnionId))) + i-- + dAtA[i] = 0x32 + } + if len(m.TakerSign) > 0 { + i -= len(m.TakerSign) + copy(dAtA[i:], m.TakerSign) + i = encodeVarintTx(dAtA, i, uint64(len(m.TakerSign))) + i-- + dAtA[i] = 0x2a + } + if len(m.GiverSign) > 0 { + i -= len(m.GiverSign) + copy(dAtA[i:], m.GiverSign) + i = encodeVarintTx(dAtA, i, uint64(len(m.GiverSign))) + i-- + dAtA[i] = 0x22 + } + if len(m.TakerId) > 0 { + i -= len(m.TakerId) + copy(dAtA[i:], m.TakerId) + i = encodeVarintTx(dAtA, i, uint64(len(m.TakerId))) + i-- + dAtA[i] = 0x1a + } + if len(m.GiverId) > 0 { + i -= len(m.GiverId) + copy(dAtA[i:], m.GiverId) + i = encodeVarintTx(dAtA, i, uint64(len(m.GiverId))) + i-- + dAtA[i] = 0x12 + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgCreateEventResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgCreateEventResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreateEventResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Id != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateEvent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateEvent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Body) > 0 { + i -= len(m.Body) + copy(dAtA[i:], m.Body) + i = encodeVarintTx(dAtA, i, uint64(len(m.Body))) + i-- + dAtA[i] = 0x4a + } + if len(m.TypeId) > 0 { + i -= len(m.TypeId) + copy(dAtA[i:], m.TypeId) + i = encodeVarintTx(dAtA, i, uint64(len(m.TypeId))) + i-- + dAtA[i] = 0x42 + } + if len(m.UnionId) > 0 { + i -= len(m.UnionId) + copy(dAtA[i:], m.UnionId) + i = encodeVarintTx(dAtA, i, uint64(len(m.UnionId))) + i-- + dAtA[i] = 0x3a + } + if len(m.TakerSign) > 0 { + i -= len(m.TakerSign) + copy(dAtA[i:], m.TakerSign) + i = encodeVarintTx(dAtA, i, uint64(len(m.TakerSign))) + i-- + dAtA[i] = 0x32 + } + if len(m.GiverSign) > 0 { + i -= len(m.GiverSign) + copy(dAtA[i:], m.GiverSign) + i = encodeVarintTx(dAtA, i, uint64(len(m.GiverSign))) + i-- + dAtA[i] = 0x2a + } + if len(m.TakerId) > 0 { + i -= len(m.TakerId) + copy(dAtA[i:], m.TakerId) + i = encodeVarintTx(dAtA, i, uint64(len(m.TakerId))) + i-- + dAtA[i] = 0x22 + } + if len(m.GiverId) > 0 { + i -= len(m.GiverId) + copy(dAtA[i:], m.GiverId) + i = encodeVarintTx(dAtA, i, uint64(len(m.GiverId))) + i-- + dAtA[i] = 0x1a + } + if m.Id != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x10 + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateEventResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateEventResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateEventResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgDeleteEvent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgDeleteEvent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDeleteEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Id != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x10 + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgDeleteEventResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgDeleteEventResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDeleteEventResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgCreateEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GiverId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.TakerId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GiverSign) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.TakerSign) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.UnionId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.TypeId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Body) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCreateEventResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Id != 0 { + n += 1 + sovTx(uint64(m.Id)) + } + return n +} + +func (m *MsgUpdateEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Id != 0 { + n += 1 + sovTx(uint64(m.Id)) + } + l = len(m.GiverId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.TakerId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GiverSign) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.TakerSign) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.UnionId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.TypeId) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Body) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgUpdateEventResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDeleteEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Id != 0 { + n += 1 + sovTx(uint64(m.Id)) + } + return n +} + +func (m *MsgDeleteEventResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgCreateEvent) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCreateEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GiverId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GiverId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TakerId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TakerId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GiverSign", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GiverSign = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TakerSign", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TakerSign = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnionId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UnionId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TypeId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TypeId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Body = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgCreateEventResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCreateEventResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateEventResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil } +func (m *MsgUpdateEvent) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GiverId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GiverId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TakerId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TakerId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GiverSign", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GiverSign = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TakerSign", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TakerSign = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnionId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UnionId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TypeId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TypeId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Body = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateEventResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateEventResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateEventResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDeleteEvent) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgDeleteEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDeleteEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDeleteEventResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgDeleteEventResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDeleteEventResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +)