mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

MM-26057 - Add CreateCommand plugin API (#14916)

Просмотр исходного кода 
Automatic Merge
Этот коммит содержится в:
Christopher Poile
2020-07-31 11:40:15 -04:00
коммит произвёл GitHub
родитель 61cc7a8680
Коммит c5c6a5ce53
11 изменённых файлов: 763 добавлений и 18 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

5
app/command.go
Просмотреть файл

@@ -603,6 +603,10 @@ func (a *App) CreateCommand(cmd *model.Command) (*model.Command, *model.AppError
return nil, model.NewAppError("CreateCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.createCommand(cmd)
}
func (a *App) createCommand(cmd *model.Command) (*model.Command, *model.AppError) {
cmd.Trigger = strings.ToLower(cmd.Trigger)
teamCmds, err := a.Srv().Store.Command().GetByTeam(cmd.TeamId)
@@ -667,6 +671,7 @@ func (a *App) UpdateCommand(oldCmd, updatedCmd *model.Command) (*model.Command,
updatedCmd.UpdateAt = model.GetMillis()
updatedCmd.DeleteAt = oldCmd.DeleteAt
updatedCmd.CreatorId = oldCmd.CreatorId
updatedCmd.PluginId = oldCmd.PluginId
updatedCmd.TeamId = oldCmd.TeamId
command, err := a.Srv().Store.Command().Update(updatedCmd)

107
app/plugin_api.go
Просмотреть файл

@@ -929,3 +929,110 @@ func (api *PluginAPI) PluginHTTP(request *http.Request) *http.Response {
api.app.ServeInterPluginRequest(responseTransfer, request, api.id, destinationPluginId)
return responseTransfer.GenerateResponse()
}
func (api *PluginAPI) CreateCommand(cmd *model.Command) (*model.Command, error) {
cmd.CreatorId = ""
cmd.PluginId = api.id
cmd, appErr := api.app.createCommand(cmd)
if appErr != nil {
return cmd, appErr
}
return cmd, nil
}
func (api *PluginAPI) ListCommands(teamID string) ([]*model.Command, error) {
ret := make([]*model.Command, 0)
cmds, err := api.ListPluginCommands(teamID)
if err != nil {
return nil, err
}
ret = append(ret, cmds...)
cmds, err = api.ListBuiltInCommands()
if err != nil {
return nil, err
}
ret = append(ret, cmds...)
cmds, err = api.ListCustomCommands(teamID)
if err != nil {
return nil, err
}
ret = append(ret, cmds...)
return ret, nil
}
func (api *PluginAPI) ListCustomCommands(teamID string) ([]*model.Command, error) {
// Plugins are allowed to bypass the a.Config().ServiceSettings.EnableCommands setting.
return api.app.Srv().Store.Command().GetByTeam(teamID)
}
func (api *PluginAPI) ListPluginCommands(teamID string) ([]*model.Command, error) {
commands := make([]*model.Command, 0)
seen := make(map[string]bool)
for _, cmd := range api.app.PluginCommandsForTeam(teamID) {
if !seen[cmd.Trigger] {
seen[cmd.Trigger] = true
commands = append(commands, cmd)
}
}
return commands, nil
}
func (api *PluginAPI) ListBuiltInCommands() ([]*model.Command, error) {
commands := make([]*model.Command, 0)
seen := make(map[string]bool)
for _, value := range commandProviders {
if cmd := value.GetCommand(api.app, utils.T); cmd != nil {
cpy := *cmd
if cpy.AutoComplete && !seen[cpy.Trigger] {
cpy.Sanitize()
seen[cpy.Trigger] = true
commands = append(commands, &cpy)
}
}
}
return commands, nil
}
func (api *PluginAPI) GetCommand(commandID string) (*model.Command, error) {
return api.app.Srv().Store.Command().Get(commandID)
}
func (api *PluginAPI) UpdateCommand(commandID string, updatedCmd *model.Command) (*model.Command, error) {
oldCmd, err := api.GetCommand(commandID)
if err != nil {
return nil, err
}
updatedCmd.Trigger = strings.ToLower(updatedCmd.Trigger)
updatedCmd.Id = oldCmd.Id
updatedCmd.Token = oldCmd.Token
updatedCmd.CreateAt = oldCmd.CreateAt
updatedCmd.UpdateAt = model.GetMillis()
updatedCmd.DeleteAt = oldCmd.DeleteAt
updatedCmd.PluginId = api.id
if updatedCmd.TeamId == "" {
updatedCmd.TeamId = oldCmd.TeamId
}
return api.app.Srv().Store.Command().Update(updatedCmd)
}
func (api *PluginAPI) DeleteCommand(commandID string) error {
err := api.app.Srv().Store.Command().Delete(commandID, model.GetMillis())
if err != nil {
return err
}
return nil
}

85
app/plugin_api_test.go
Просмотреть файл

@@ -1730,3 +1730,88 @@ func TestPluginAPISearchPostsInTeamByUser(t *testing.T) {
})
}
}
func TestPluginAPICreateCommandAndListCommands(t *testing.T) {
th := Setup(t).InitBasic()
defer th.TearDown()
api := th.SetupPluginAPI()
foundCommand := func(listXCommand func(teamId string) ([]*model.Command, error)) bool {
cmds, appErr := listXCommand(th.BasicTeam.Id)
require.Nil(t, appErr)
for _, cmd := range cmds {
if cmd.Trigger == "testcmd" {
return true
}
}
return false
}
require.False(t, foundCommand(api.ListCommands))
cmd := &model.Command{
TeamId: th.BasicTeam.Id,
Trigger: "testcmd",
Method: "G",
URL: "http://test.com/testcmd",
}
cmd, appErr := api.CreateCommand(cmd)
require.Nil(t, appErr)
newCmd, appErr := api.GetCommand(cmd.Id)
require.Nil(t, appErr)
require.Equal(t, "pluginid", newCmd.PluginId)
require.Equal(t, "", newCmd.CreatorId)
require.True(t, foundCommand(api.ListCommands))
require.True(t, foundCommand(api.ListCustomCommands))
require.False(t, foundCommand(api.ListPluginCommands))
}
func TestPluginAPIUpdateCommand(t *testing.T) {
th := Setup(t).InitBasic()
defer th.TearDown()
api := th.SetupPluginAPI()
cmd := &model.Command{
TeamId: th.BasicTeam.Id,
Trigger: "testcmd",
Method: "G",
URL: "http://test.com/testcmd",
}
cmd, appErr := api.CreateCommand(cmd)
require.Nil(t, appErr)
newCmd, appErr := api.GetCommand(cmd.Id)
require.Nil(t, appErr)
require.Equal(t, "pluginid", newCmd.PluginId)
require.Equal(t, "", newCmd.CreatorId)
newCmd.Trigger = "NewTrigger"
newCmd.PluginId = "CannotChangeMe"
newCmd2, appErr := api.UpdateCommand(newCmd.Id, newCmd)
require.Nil(t, appErr)
require.Equal(t, "pluginid", newCmd2.PluginId)
require.Equal(t, "newtrigger", newCmd2.Trigger)
team1 := th.CreateTeam()
newCmd2.PluginId = "CannotChangeMe"
newCmd2.Trigger = "anotherNewTrigger"
newCmd2.TeamId = team1.Id
newCmd3, appErr := api.UpdateCommand(newCmd2.Id, newCmd2)
require.Nil(t, appErr)
require.Equal(t, "pluginid", newCmd3.PluginId)
require.Equal(t, "anothernewtrigger", newCmd3.Trigger)
require.Equal(t, team1.Id, newCmd3.TeamId)
newCmd3.Trigger = "anotherNewTriggerAgain"
newCmd3.TeamId = ""
newCmd4, appErr := api.UpdateCommand(newCmd2.Id, newCmd2)
require.Nil(t, appErr)
require.Equal(t, "anothernewtriggeragain", newCmd4.Trigger)
require.Equal(t, team1.Id, newCmd4.TeamId)
}

4
i18n/en.json
Просмотреть файл

@@ -5594,6 +5594,10 @@
"id": "model.command.is_valid.method.app_error",
"translation": "Invalid Method."
},
{
"id": "model.command.is_valid.plugin_id.app_error",
"translation": "Invalid plugin id."
},
{
"id": "model.command.is_valid.team_id.app_error",
"translation": "Invalid team ID."

49
model/command.go
Просмотреть файл

@@ -18,23 +18,26 @@ const (
)
type Command struct {
Id string `json:"id"`
Token string `json:"token"`
CreateAt int64 `json:"create_at"`
UpdateAt int64 `json:"update_at"`
DeleteAt int64 `json:"delete_at"`
CreatorId string `json:"creator_id"`
TeamId string `json:"team_id"`
Trigger string `json:"trigger"`
Method string `json:"method"`
Username string `json:"username"`
IconURL string `json:"icon_url"`
AutoComplete bool `json:"auto_complete"`
AutoCompleteDesc string `json:"auto_complete_desc"`
AutoCompleteHint string `json:"auto_complete_hint"`
DisplayName string `json:"display_name"`
Description string `json:"description"`
URL string `json:"url"`
Id string `json:"id"`
Token string `json:"token"`
CreateAt int64 `json:"create_at"`
UpdateAt int64 `json:"update_at"`
DeleteAt int64 `json:"delete_at"`
CreatorId string `json:"creator_id"`
TeamId string `json:"team_id"`
Trigger string `json:"trigger"`
Method string `json:"method"`
Username string `json:"username"`
IconURL string `json:"icon_url"`
AutoComplete bool `json:"auto_complete"`
AutoCompleteDesc string `json:"auto_complete_desc"`
AutoCompleteHint string `json:"auto_complete_hint"`
DisplayName string `json:"display_name"`
Description string `json:"description"`
URL string `json:"url"`
// PluginId records the id of the plugin that created this Command. If it is blank, the Command
// was not created by a plugin.
PluginId string `json:"plugin_id"`
AutocompleteData *AutocompleteData `db:"-" json:"autocomplete_data,omitempty"`
// AutocompleteIconData is a base64 encoded svg
AutocompleteIconData string `db:"-" json:"autocomplete_icon_data,omitempty"`
@@ -80,10 +83,20 @@ func (o *Command) IsValid() *AppError {
return NewAppError("Command.IsValid", "model.command.is_valid.update_at.app_error", nil, "", http.StatusBadRequest)
}
if !IsValidId(o.CreatorId) {
// If the CreatorId is blank, this should be a command created by a plugin.
if o.CreatorId == "" && !IsValidPluginId(o.PluginId) {
return NewAppError("Command.IsValid", "model.command.is_valid.plugin_id.app_error", nil, "", http.StatusBadRequest)
}
// If the PluginId is blank, this should be a command associated with a userId.
if o.PluginId == "" && !IsValidId(o.CreatorId) {
return NewAppError("Command.IsValid", "model.command.is_valid.user_id.app_error", nil, "", http.StatusBadRequest)
}
if o.CreatorId != "" && o.PluginId != "" {
return NewAppError("Command.IsValid", "model.command.is_valid.plugin_id.app_error", nil, "command cannot have both a CreatorId and a PluginId", http.StatusBadRequest)
}
if !IsValidId(o.TeamId) {
return NewAppError("Command.IsValid", "model.command.is_valid.team_id.app_error", nil, "", http.StatusBadRequest)
}

59
plugin/api.go
Просмотреть файл

@@ -972,6 +972,65 @@ type API interface {
// @tag User
// Minimum server version: 5.26
PublishUserTyping(userId, channelId, parentId string) *model.AppError
// CreateCommand creates a server-owned slash command that is not handled by the plugin
// itself, and which will persist past the life of the plugin. The command will have its
// CreatorId set to "" and its PluginId set to the id of the plugin that created it.
//
// @tag SlashCommand
// Minimum server version: 5.28
CreateCommand(cmd *model.Command) (*model.Command, error)
// ListCommands returns the list of all slash commands for teamID. E.g., custom commands
// (those created through the integrations menu, the REST api, or the plugin api CreateCommand),
// plugin commands (those created with plugin api RegisterCommand), and builtin commands
// (those added internally through RegisterCommandProvider).
//
// @tag SlashCommand
// Minimum server version: 5.28
ListCommands(teamID string) ([]*model.Command, error)
// ListCustomCommands returns the list of slash commands for teamID that where created
// through the integrations menu, the REST api, or the plugin api CreateCommand.
//
// @tag SlashCommand
// Minimum server version: 5.28
ListCustomCommands(teamID string) ([]*model.Command, error)
// ListPluginCommands returns the list of slash commands for teamID that were created
// with the plugin api RegisterCommand.
//
// @tag SlashCommand
// Minimum server version: 5.28
ListPluginCommands(teamID string) ([]*model.Command, error)
// ListBuiltInCommands returns the list of slash commands that are builtin commands
// (those added internally through RegisterCommandProvider).
//
// @tag SlashCommand
// Minimum server version: 5.28
ListBuiltInCommands() ([]*model.Command, error)
// GetCommand returns the command definition based on a command id string.
//
// @tag SlashCommand
// Minimum server version: 5.28
GetCommand(commandID string) (*model.Command, error)
// UpdateCommand updates a single command (commandID) with the information provided in the
// updatedCmd model.Command struct. The following fields in the command cannot be updated:
// Id, Token, CreateAt, DeleteAt, and PluginId. If updatedCmd.TeamId is blank, it
// will be set to commandID's TeamId.
//
// @tag SlashCommand
// Minimum server version: 5.28
UpdateCommand(commandID string, updatedCmd *model.Command) (*model.Command, error)
// DeleteCommand deletes a slash command (commandID).
//
// @tag SlashCommand
// Minimum server version: 5.28
DeleteCommand(commandID string) error
}
var handshake = plugin.HandshakeConfig{

56
plugin/api_timer_layer_generated.go
Просмотреть файл

@@ -1036,3 +1036,59 @@ func (api *apiTimerLayer) PublishUserTyping(userId, channelId, parentId string)
api.recordTime(startTime, "PublishUserTyping", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) CreateCommand(cmd *model.Command) (*model.Command, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.CreateCommand(cmd)
api.recordTime(startTime, "CreateCommand", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) ListCommands(teamID string) ([]*model.Command, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.ListCommands(teamID)
api.recordTime(startTime, "ListCommands", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) ListCustomCommands(teamID string) ([]*model.Command, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.ListCustomCommands(teamID)
api.recordTime(startTime, "ListCustomCommands", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) ListPluginCommands(teamID string) ([]*model.Command, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.ListPluginCommands(teamID)
api.recordTime(startTime, "ListPluginCommands", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) ListBuiltInCommands() ([]*model.Command, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.ListBuiltInCommands()
api.recordTime(startTime, "ListBuiltInCommands", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetCommand(commandID string) (*model.Command, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetCommand(commandID)
api.recordTime(startTime, "GetCommand", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdateCommand(commandID string, updatedCmd *model.Command) (*model.Command, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdateCommand(commandID, updatedCmd)
api.recordTime(startTime, "UpdateCommand", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeleteCommand(commandID string) error {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeleteCommand(commandID)
api.recordTime(startTime, "DeleteCommand", _returnsA == nil)
return _returnsA
}

239
plugin/client_rpc_generated.go
Просмотреть файл

@@ -4512,3 +4512,242 @@ func (s *apiRPCServer) PublishUserTyping(args *Z_PublishUserTypingArgs, returns
}
return nil
}
type Z_CreateCommandArgs struct {
A *model.Command
}
type Z_CreateCommandReturns struct {
A *model.Command
B error
}
func (g *apiRPCClient) CreateCommand(cmd *model.Command) (*model.Command, error) {
_args := &Z_CreateCommandArgs{cmd}
_returns := &Z_CreateCommandReturns{}
if err := g.client.Call("Plugin.CreateCommand", _args, _returns); err != nil {
log.Printf("RPC call to CreateCommand API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) CreateCommand(args *Z_CreateCommandArgs, returns *Z_CreateCommandReturns) error {
if hook, ok := s.impl.(interface {
CreateCommand(cmd *model.Command) (*model.Command, error)
}); ok {
returns.A, returns.B = hook.CreateCommand(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API CreateCommand called but not implemented."))
}
return nil
}
type Z_ListCommandsArgs struct {
A string
}
type Z_ListCommandsReturns struct {
A []*model.Command
B error
}
func (g *apiRPCClient) ListCommands(teamID string) ([]*model.Command, error) {
_args := &Z_ListCommandsArgs{teamID}
_returns := &Z_ListCommandsReturns{}
if err := g.client.Call("Plugin.ListCommands", _args, _returns); err != nil {
log.Printf("RPC call to ListCommands API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) ListCommands(args *Z_ListCommandsArgs, returns *Z_ListCommandsReturns) error {
if hook, ok := s.impl.(interface {
ListCommands(teamID string) ([]*model.Command, error)
}); ok {
returns.A, returns.B = hook.ListCommands(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API ListCommands called but not implemented."))
}
return nil
}
type Z_ListCustomCommandsArgs struct {
A string
}
type Z_ListCustomCommandsReturns struct {
A []*model.Command
B error
}
func (g *apiRPCClient) ListCustomCommands(teamID string) ([]*model.Command, error) {
_args := &Z_ListCustomCommandsArgs{teamID}
_returns := &Z_ListCustomCommandsReturns{}
if err := g.client.Call("Plugin.ListCustomCommands", _args, _returns); err != nil {
log.Printf("RPC call to ListCustomCommands API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) ListCustomCommands(args *Z_ListCustomCommandsArgs, returns *Z_ListCustomCommandsReturns) error {
if hook, ok := s.impl.(interface {
ListCustomCommands(teamID string) ([]*model.Command, error)
}); ok {
returns.A, returns.B = hook.ListCustomCommands(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API ListCustomCommands called but not implemented."))
}
return nil
}
type Z_ListPluginCommandsArgs struct {
A string
}
type Z_ListPluginCommandsReturns struct {
A []*model.Command
B error
}
func (g *apiRPCClient) ListPluginCommands(teamID string) ([]*model.Command, error) {
_args := &Z_ListPluginCommandsArgs{teamID}
_returns := &Z_ListPluginCommandsReturns{}
if err := g.client.Call("Plugin.ListPluginCommands", _args, _returns); err != nil {
log.Printf("RPC call to ListPluginCommands API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) ListPluginCommands(args *Z_ListPluginCommandsArgs, returns *Z_ListPluginCommandsReturns) error {
if hook, ok := s.impl.(interface {
ListPluginCommands(teamID string) ([]*model.Command, error)
}); ok {
returns.A, returns.B = hook.ListPluginCommands(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API ListPluginCommands called but not implemented."))
}
return nil
}
type Z_ListBuiltInCommandsArgs struct {
}
type Z_ListBuiltInCommandsReturns struct {
A []*model.Command
B error
}
func (g *apiRPCClient) ListBuiltInCommands() ([]*model.Command, error) {
_args := &Z_ListBuiltInCommandsArgs{}
_returns := &Z_ListBuiltInCommandsReturns{}
if err := g.client.Call("Plugin.ListBuiltInCommands", _args, _returns); err != nil {
log.Printf("RPC call to ListBuiltInCommands API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) ListBuiltInCommands(args *Z_ListBuiltInCommandsArgs, returns *Z_ListBuiltInCommandsReturns) error {
if hook, ok := s.impl.(interface {
ListBuiltInCommands() ([]*model.Command, error)
}); ok {
returns.A, returns.B = hook.ListBuiltInCommands()
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API ListBuiltInCommands called but not implemented."))
}
return nil
}
type Z_GetCommandArgs struct {
A string
}
type Z_GetCommandReturns struct {
A *model.Command
B error
}
func (g *apiRPCClient) GetCommand(commandID string) (*model.Command, error) {
_args := &Z_GetCommandArgs{commandID}
_returns := &Z_GetCommandReturns{}
if err := g.client.Call("Plugin.GetCommand", _args, _returns); err != nil {
log.Printf("RPC call to GetCommand API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) GetCommand(args *Z_GetCommandArgs, returns *Z_GetCommandReturns) error {
if hook, ok := s.impl.(interface {
GetCommand(commandID string) (*model.Command, error)
}); ok {
returns.A, returns.B = hook.GetCommand(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API GetCommand called but not implemented."))
}
return nil
}
type Z_UpdateCommandArgs struct {
A string
B *model.Command
}
type Z_UpdateCommandReturns struct {
A *model.Command
B error
}
func (g *apiRPCClient) UpdateCommand(commandID string, updatedCmd *model.Command) (*model.Command, error) {
_args := &Z_UpdateCommandArgs{commandID, updatedCmd}
_returns := &Z_UpdateCommandReturns{}
if err := g.client.Call("Plugin.UpdateCommand", _args, _returns); err != nil {
log.Printf("RPC call to UpdateCommand API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) UpdateCommand(args *Z_UpdateCommandArgs, returns *Z_UpdateCommandReturns) error {
if hook, ok := s.impl.(interface {
UpdateCommand(commandID string, updatedCmd *model.Command) (*model.Command, error)
}); ok {
returns.A, returns.B = hook.UpdateCommand(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API UpdateCommand called but not implemented."))
}
return nil
}
type Z_DeleteCommandArgs struct {
A string
}
type Z_DeleteCommandReturns struct {
A error
}
func (g *apiRPCClient) DeleteCommand(commandID string) error {
_args := &Z_DeleteCommandArgs{commandID}
_returns := &Z_DeleteCommandReturns{}
if err := g.client.Call("Plugin.DeleteCommand", _args, _returns); err != nil {
log.Printf("RPC call to DeleteCommand API failed: %s", err.Error())
}
return _returns.A
}
func (s *apiRPCServer) DeleteCommand(args *Z_DeleteCommandArgs, returns *Z_DeleteCommandReturns) error {
if hook, ok := s.impl.(interface {
DeleteCommand(commandID string) error
}); ok {
returns.A = hook.DeleteCommand(args.A)
returns.A = encodableError(returns.A)
} else {
return encodableError(fmt.Errorf("API DeleteCommand called but not implemented."))
}
return nil
}

175
plugin/plugintest/api.go
Просмотреть файл

@@ -168,6 +168,29 @@ func (_m *API) CreateChannel(channel *model.Channel) (*model.Channel, *model.App
return r0, r1
}
// CreateCommand provides a mock function with given fields: cmd
func (_m *API) CreateCommand(cmd *model.Command) (*model.Command, error) {
ret := _m.Called(cmd)
var r0 *model.Command
if rf, ok := ret.Get(0).(func(*model.Command) *model.Command); ok {
r0 = rf(cmd)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Command)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(*model.Command) error); ok {
r1 = rf(cmd)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// CreatePost provides a mock function with given fields: post
func (_m *API) CreatePost(post *model.Post) (*model.Post, *model.AppError) {
ret := _m.Called(post)
@@ -366,6 +389,20 @@ func (_m *API) DeleteChannelMember(channelId string, userId string) *model.AppEr
return r0
}
// DeleteCommand provides a mock function with given fields: commandID
func (_m *API) DeleteCommand(commandID string) error {
ret := _m.Called(commandID)
var r0 error
if rf, ok := ret.Get(0).(func(string) error); ok {
r0 = rf(commandID)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeleteEphemeralPost provides a mock function with given fields: userId, postId
func (_m *API) DeleteEphemeralPost(userId string, postId string) {
_m.Called(userId, postId)
@@ -827,6 +864,29 @@ func (_m *API) GetChannelsForTeamForUser(teamId string, userId string, includeDe
return r0, r1
}
// GetCommand provides a mock function with given fields: commandID
func (_m *API) GetCommand(commandID string) (*model.Command, error) {
ret := _m.Called(commandID)
var r0 *model.Command
if rf, ok := ret.Get(0).(func(string) *model.Command); ok {
r0 = rf(commandID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Command)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(commandID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetConfig provides a mock function with given fields:
func (_m *API) GetConfig() *model.Config {
ret := _m.Called()
@@ -2347,6 +2407,98 @@ func (_m *API) KVSetWithOptions(key string, value []byte, options model.PluginKV
return r0, r1
}
// ListBuiltInCommands provides a mock function with given fields:
func (_m *API) ListBuiltInCommands() ([]*model.Command, error) {
ret := _m.Called()
var r0 []*model.Command
if rf, ok := ret.Get(0).(func() []*model.Command); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Command)
}
}
var r1 error
if rf, ok := ret.Get(1).(func() error); ok {
r1 = rf()
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// ListCommands provides a mock function with given fields: teamID
func (_m *API) ListCommands(teamID string) ([]*model.Command, error) {
ret := _m.Called(teamID)
var r0 []*model.Command
if rf, ok := ret.Get(0).(func(string) []*model.Command); ok {
r0 = rf(teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Command)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// ListCustomCommands provides a mock function with given fields: teamID
func (_m *API) ListCustomCommands(teamID string) ([]*model.Command, error) {
ret := _m.Called(teamID)
var r0 []*model.Command
if rf, ok := ret.Get(0).(func(string) []*model.Command); ok {
r0 = rf(teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Command)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// ListPluginCommands provides a mock function with given fields: teamID
func (_m *API) ListPluginCommands(teamID string) ([]*model.Command, error) {
ret := _m.Called(teamID)
var r0 []*model.Command
if rf, ok := ret.Get(0).(func(string) []*model.Command); ok {
r0 = rf(teamID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.Command)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(teamID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// LoadPluginConfiguration provides a mock function with given fields: dest
func (_m *API) LoadPluginConfiguration(dest interface{}) error {
ret := _m.Called(dest)
@@ -2925,6 +3077,29 @@ func (_m *API) UpdateChannelMemberRoles(channelId string, userId string, newRole
return r0, r1
}
// UpdateCommand provides a mock function with given fields: commandID, updatedCmd
func (_m *API) UpdateCommand(commandID string, updatedCmd *model.Command) (*model.Command, error) {
ret := _m.Called(commandID, updatedCmd)
var r0 *model.Command
if rf, ok := ret.Get(0).(func(string, *model.Command) *model.Command); ok {
r0 = rf(commandID, updatedCmd)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.Command)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(string, *model.Command) error); ok {
r1 = rf(commandID, updatedCmd)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateEphemeralPost provides a mock function with given fields: userId, post
func (_m *API) UpdateEphemeralPost(userId string, post *model.Post) *model.Post {
ret := _m.Called(userId, post)

1
store/sqlstore/command_store.go
Просмотреть файл

@@ -40,6 +40,7 @@ func newSqlCommandStore(sqlStore SqlStore) store.CommandStore {
tableo.ColMap("AutoCompleteHint").SetMaxSize(1024)
tableo.ColMap("DisplayName").SetMaxSize(64)
tableo.ColMap("Description").SetMaxSize(128)
tableo.ColMap("PluginId").SetMaxSize(190)
}
return s

1
store/sqlstore/upgrade.go
Просмотреть файл

@@ -828,6 +828,7 @@ func upgradeDatabaseToVersion526(sqlStore SqlStore) {
func upgradeDatabaseToVersion527(sqlStore SqlStore) {
// TODO: uncomment when the time arrive to upgrade the DB for 5.27
// if shouldPerformUpgrade(sqlStore, VERSION_5_26_0, VERSION_5_27_0) {
sqlStore.CreateColumnIfNotExistsNoDefault("Commands", "PluginId", "VARCHAR(190)", "VARCHAR(190)")
// saveSchemaVersion(sqlStore, VERSION_5_27_0)
// }