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

MM-31339: Send only one direct message reply within one calendar day. (#17181)

Просмотр исходного кода 
* don't send auto response if already responded today

* update query to get posts from channel for given user and Updatetime requires value in milli seconds

* regenerate mocks and layers

* update function to return true/false on existence of auto responded post in channel and add tests

* add store tests

* bubble up error and propagate upstream

* fix error handling logic

* use require instead of assert

Co-authored-by: Ibrahim Serdar Acikgoz <serdaracikgoz86@gmail.com>

* rename variable for better redability and logging fixes

* update comment explaining function

* use new function to generate test ids

* add comments to clarify NewTestId copies

* add translations for error id

* fix translation

Co-authored-by: Ibrahim Serdar Acikgoz <serdaracikgoz86@gmail.com>
Co-authored-by: Mattermod <mattermod@users.noreply.github.com>
Co-authored-by: Saturnino Abril <saturnino.abril@gmail.com>
Этот коммит содержится в:
darkLord19
2021-04-22 10:03:45 +05:30
коммит произвёл GitHub
родитель f14b0097dd
Коммит f6505e1ee6
15 изменённых файлов: 740 добавлений и 514 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@@ -4,9 +4,22 @@
package app
import (
"net/http"
"time"
"github.com/mattermost/mattermost-server/v5/model"
)
// check if there is any auto_response type post in channel by the user in a calender day
func (a *App) checkIfRespondedToday(createdAt int64, channelId, userId string) (bool, error) {
y, m, d := time.Unix(createdAt, 0).Date()
since := model.GetMillisForTime(time.Date(y, m, d, 0, 0, 0, 0, time.UTC))
return a.Srv().Store.Post().HasAutoResponsePostByUserSince(
model.GetPostsSinceOptions{ChannelId: channelId, Time: since},
userId,
)
}
func (a *App) SendAutoResponseIfNecessary(channel *model.Channel, sender *model.User, post *model.Post) (bool, *model.AppError) {
if channel.Type != model.CHANNEL_DIRECT {
return false, nil
@@ -22,9 +35,17 @@ func (a *App) SendAutoResponseIfNecessary(channel *model.Channel, sender *model.
receiverId = sender.Id
}
receiver, err := a.GetUser(receiverId)
receiver, aErr := a.GetUser(receiverId)
if aErr != nil {
return false, aErr
}
autoResponded, err := a.checkIfRespondedToday(post.CreateAt, post.ChannelId, receiverId)
if err != nil {
return false, err
return false, model.NewAppError("SendAutoResponseIfNecessary", "app.user.send_auto_response.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if autoResponded {
return false, nil
}
return a.SendAutoResponse(channel, receiver, post)

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

@@ -197,6 +197,43 @@ func TestSendAutoResponseIfNecessary(t *testing.T) {
assert.Nil(t, err)
assert.False(t, sent)
})
t.Run("should send auto response in dm channel if not already sent today", func(t *testing.T) {
th := Setup(t).InitBasic()
defer th.TearDown()
receiver := th.CreateUser()
patch := &model.UserPatch{
NotifyProps: map[string]string{
"auto_responder_active": "true",
"auto_responder_message": "Hello, I'm unavailable today.",
},
}
receiver, err := th.App.PatchUser(receiver.Id, patch, true)
require.Nil(t, err)
channel := th.CreateDmChannel(receiver)
savedPost, err := th.App.CreatePost(&model.Post{
ChannelId: channel.Id,
Message: NewTestId(),
UserId: th.BasicUser.Id},
th.BasicChannel,
false, true)
assert.Nil(t, err)
sent, err := th.App.SendAutoResponseIfNecessary(channel, th.BasicUser, savedPost)
require.Nil(t, err)
assert.True(t, sent)
sent, err = th.App.SendAutoResponseIfNecessary(channel, th.BasicUser, savedPost)
require.Nil(t, err)
assert.False(t, sent)
})
}
func TestSendAutoResponseSuccess(t *testing.T) {

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

@@ -708,3 +708,16 @@ func (th *TestHelper) AddPermissionToRole(permission string, roleName string) {
utils.EnableDebugLogForTest()
}
// This function is copy of storetest/NewTestId
// NewTestId is used for testing as a replacement for model.NewId(). It is a [A-Z0-9] string 26
// characters long. It replaces every odd character with a digit.
func NewTestId() string {
newId := []byte(model.NewId())
for i := 1; i < len(newId); i = i + 2 {
newId[i] = 48 + newId[i-1]%10
}
return string(newId)
}

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

@@ -6418,6 +6418,10 @@
"id": "app.user.search.app_error",
"translation": "Unable to find any user matching the search parameters."
},
{
"id": "app.user.send_auto_response.app_error",
"translation": "Unable to send auto response from user."
},
{
"id": "app.user.send_emails.app_error",
"translation": "No emails were successfully sent"

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

@@ -42,9 +42,9 @@ func (api *apiTimerLayer) RegisterCommand(command *model.Command) error {
return _returnsA
}
func (api *apiTimerLayer) UnregisterCommand(teamId, trigger string) error {
func (api *apiTimerLayer) UnregisterCommand(teamID, trigger string) error {
startTime := timePkg.Now()
_returnsA := api.apiImpl.UnregisterCommand(teamId, trigger)
_returnsA := api.apiImpl.UnregisterCommand(teamID, trigger)
api.recordTime(startTime, "UnregisterCommand", _returnsA == nil)
return _returnsA
}
@@ -56,9 +56,9 @@ func (api *apiTimerLayer) ExecuteSlashCommand(commandArgs *model.CommandArgs) (*
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetSession(sessionId string) (*model.Session, *model.AppError) {
func (api *apiTimerLayer) GetSession(sessionID string) (*model.Session, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetSession(sessionId)
_returnsA, _returnsB := api.apiImpl.GetSession(sessionID)
api.recordTime(startTime, "GetSession", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -147,9 +147,9 @@ func (api *apiTimerLayer) CreateUser(user *model.User) (*model.User, *model.AppE
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeleteUser(userId string) *model.AppError {
func (api *apiTimerLayer) DeleteUser(userID string) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeleteUser(userId)
_returnsA := api.apiImpl.DeleteUser(userID)
api.recordTime(startTime, "DeleteUser", _returnsA == nil)
return _returnsA
}
@@ -161,9 +161,9 @@ func (api *apiTimerLayer) GetUsers(options *model.UserGetOptions) ([]*model.User
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetUser(userId string) (*model.User, *model.AppError) {
func (api *apiTimerLayer) GetUser(userID string) (*model.User, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetUser(userId)
_returnsA, _returnsB := api.apiImpl.GetUser(userID)
api.recordTime(startTime, "GetUser", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -189,51 +189,51 @@ func (api *apiTimerLayer) GetUsersByUsernames(usernames []string) ([]*model.User
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetUsersInTeam(teamId string, page int, perPage int) ([]*model.User, *model.AppError) {
func (api *apiTimerLayer) GetUsersInTeam(teamID string, page int, perPage int) ([]*model.User, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetUsersInTeam(teamId, page, perPage)
_returnsA, _returnsB := api.apiImpl.GetUsersInTeam(teamID, page, perPage)
api.recordTime(startTime, "GetUsersInTeam", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetPreferencesForUser(userId string) ([]model.Preference, *model.AppError) {
func (api *apiTimerLayer) GetPreferencesForUser(userID string) ([]model.Preference, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPreferencesForUser(userId)
_returnsA, _returnsB := api.apiImpl.GetPreferencesForUser(userID)
api.recordTime(startTime, "GetPreferencesForUser", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdatePreferencesForUser(userId string, preferences []model.Preference) *model.AppError {
func (api *apiTimerLayer) UpdatePreferencesForUser(userID string, preferences []model.Preference) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.UpdatePreferencesForUser(userId, preferences)
_returnsA := api.apiImpl.UpdatePreferencesForUser(userID, preferences)
api.recordTime(startTime, "UpdatePreferencesForUser", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) DeletePreferencesForUser(userId string, preferences []model.Preference) *model.AppError {
func (api *apiTimerLayer) DeletePreferencesForUser(userID string, preferences []model.Preference) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeletePreferencesForUser(userId, preferences)
_returnsA := api.apiImpl.DeletePreferencesForUser(userID, preferences)
api.recordTime(startTime, "DeletePreferencesForUser", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) GetTeamIcon(teamId string) ([]byte, *model.AppError) {
func (api *apiTimerLayer) GetTeamIcon(teamID string) ([]byte, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeamIcon(teamId)
_returnsA, _returnsB := api.apiImpl.GetTeamIcon(teamID)
api.recordTime(startTime, "GetTeamIcon", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) SetTeamIcon(teamId string, data []byte) *model.AppError {
func (api *apiTimerLayer) SetTeamIcon(teamID string, data []byte) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.SetTeamIcon(teamId, data)
_returnsA := api.apiImpl.SetTeamIcon(teamID, data)
api.recordTime(startTime, "SetTeamIcon", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) RemoveTeamIcon(teamId string) *model.AppError {
func (api *apiTimerLayer) RemoveTeamIcon(teamID string) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.RemoveTeamIcon(teamId)
_returnsA := api.apiImpl.RemoveTeamIcon(teamID)
api.recordTime(startTime, "RemoveTeamIcon", _returnsA == nil)
return _returnsA
}
@@ -245,9 +245,9 @@ func (api *apiTimerLayer) UpdateUser(user *model.User) (*model.User, *model.AppE
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetUserStatus(userId string) (*model.Status, *model.AppError) {
func (api *apiTimerLayer) GetUserStatus(userID string) (*model.Status, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetUserStatus(userId)
_returnsA, _returnsB := api.apiImpl.GetUserStatus(userID)
api.recordTime(startTime, "GetUserStatus", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -259,30 +259,30 @@ func (api *apiTimerLayer) GetUserStatusesByIds(userIds []string) ([]*model.Statu
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdateUserStatus(userId, status string) (*model.Status, *model.AppError) {
func (api *apiTimerLayer) UpdateUserStatus(userID, status string) (*model.Status, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdateUserStatus(userId, status)
_returnsA, _returnsB := api.apiImpl.UpdateUserStatus(userID, status)
api.recordTime(startTime, "UpdateUserStatus", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdateUserActive(userId string, active bool) *model.AppError {
func (api *apiTimerLayer) UpdateUserActive(userID string, active bool) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.UpdateUserActive(userId, active)
_returnsA := api.apiImpl.UpdateUserActive(userID, active)
api.recordTime(startTime, "UpdateUserActive", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) GetUsersInChannel(channelId, sortBy string, page, perPage int) ([]*model.User, *model.AppError) {
func (api *apiTimerLayer) GetUsersInChannel(channelID, sortBy string, page, perPage int) ([]*model.User, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetUsersInChannel(channelId, sortBy, page, perPage)
_returnsA, _returnsB := api.apiImpl.GetUsersInChannel(channelID, sortBy, page, perPage)
api.recordTime(startTime, "GetUsersInChannel", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetLDAPUserAttributes(userId string, attributes []string) (map[string]string, *model.AppError) {
func (api *apiTimerLayer) GetLDAPUserAttributes(userID string, attributes []string) (map[string]string, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetLDAPUserAttributes(userId, attributes)
_returnsA, _returnsB := api.apiImpl.GetLDAPUserAttributes(userID, attributes)
api.recordTime(startTime, "GetLDAPUserAttributes", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -294,9 +294,9 @@ func (api *apiTimerLayer) CreateTeam(team *model.Team) (*model.Team, *model.AppE
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeleteTeam(teamId string) *model.AppError {
func (api *apiTimerLayer) DeleteTeam(teamID string) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeleteTeam(teamId)
_returnsA := api.apiImpl.DeleteTeam(teamID)
api.recordTime(startTime, "DeleteTeam", _returnsA == nil)
return _returnsA
}
@@ -308,9 +308,9 @@ func (api *apiTimerLayer) GetTeams() ([]*model.Team, *model.AppError) {
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetTeam(teamId string) (*model.Team, *model.AppError) {
func (api *apiTimerLayer) GetTeam(teamID string) (*model.Team, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeam(teamId)
_returnsA, _returnsB := api.apiImpl.GetTeam(teamID)
api.recordTime(startTime, "GetTeam", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -322,9 +322,9 @@ func (api *apiTimerLayer) GetTeamByName(name string) (*model.Team, *model.AppErr
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetTeamsUnreadForUser(userId string) ([]*model.TeamUnread, *model.AppError) {
func (api *apiTimerLayer) GetTeamsUnreadForUser(userID string) ([]*model.TeamUnread, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeamsUnreadForUser(userId)
_returnsA, _returnsB := api.apiImpl.GetTeamsUnreadForUser(userID)
api.recordTime(startTime, "GetTeamsUnreadForUser", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -343,65 +343,65 @@ func (api *apiTimerLayer) SearchTeams(term string) ([]*model.Team, *model.AppErr
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetTeamsForUser(userId string) ([]*model.Team, *model.AppError) {
func (api *apiTimerLayer) GetTeamsForUser(userID string) ([]*model.Team, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeamsForUser(userId)
_returnsA, _returnsB := api.apiImpl.GetTeamsForUser(userID)
api.recordTime(startTime, "GetTeamsForUser", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) CreateTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
func (api *apiTimerLayer) CreateTeamMember(teamID, userID string) (*model.TeamMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.CreateTeamMember(teamId, userId)
_returnsA, _returnsB := api.apiImpl.CreateTeamMember(teamID, userID)
api.recordTime(startTime, "CreateTeamMember", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) CreateTeamMembers(teamId string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) {
func (api *apiTimerLayer) CreateTeamMembers(teamID string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.CreateTeamMembers(teamId, userIds, requestorId)
_returnsA, _returnsB := api.apiImpl.CreateTeamMembers(teamID, userIds, requestorId)
api.recordTime(startTime, "CreateTeamMembers", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) CreateTeamMembersGracefully(teamId string, userIds []string, requestorId string) ([]*model.TeamMemberWithError, *model.AppError) {
func (api *apiTimerLayer) CreateTeamMembersGracefully(teamID string, userIds []string, requestorId string) ([]*model.TeamMemberWithError, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.CreateTeamMembersGracefully(teamId, userIds, requestorId)
_returnsA, _returnsB := api.apiImpl.CreateTeamMembersGracefully(teamID, userIds, requestorId)
api.recordTime(startTime, "CreateTeamMembersGracefully", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeleteTeamMember(teamId, userId, requestorId string) *model.AppError {
func (api *apiTimerLayer) DeleteTeamMember(teamID, userID, requestorId string) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeleteTeamMember(teamId, userId, requestorId)
_returnsA := api.apiImpl.DeleteTeamMember(teamID, userID, requestorId)
api.recordTime(startTime, "DeleteTeamMember", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) GetTeamMembers(teamId string, page, perPage int) ([]*model.TeamMember, *model.AppError) {
func (api *apiTimerLayer) GetTeamMembers(teamID string, page, perPage int) ([]*model.TeamMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeamMembers(teamId, page, perPage)
_returnsA, _returnsB := api.apiImpl.GetTeamMembers(teamID, page, perPage)
api.recordTime(startTime, "GetTeamMembers", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
func (api *apiTimerLayer) GetTeamMember(teamID, userID string) (*model.TeamMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeamMember(teamId, userId)
_returnsA, _returnsB := api.apiImpl.GetTeamMember(teamID, userID)
api.recordTime(startTime, "GetTeamMember", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetTeamMembersForUser(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
func (api *apiTimerLayer) GetTeamMembersForUser(userID string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeamMembersForUser(userId, page, perPage)
_returnsA, _returnsB := api.apiImpl.GetTeamMembersForUser(userID, page, perPage)
api.recordTime(startTime, "GetTeamMembersForUser", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdateTeamMemberRoles(teamId, userId, newRoles string) (*model.TeamMember, *model.AppError) {
func (api *apiTimerLayer) UpdateTeamMemberRoles(teamID, userID, newRoles string) (*model.TeamMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdateTeamMemberRoles(teamId, userId, newRoles)
_returnsA, _returnsB := api.apiImpl.UpdateTeamMemberRoles(teamID, userID, newRoles)
api.recordTime(startTime, "UpdateTeamMemberRoles", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -420,9 +420,9 @@ func (api *apiTimerLayer) DeleteChannel(channelId string) *model.AppError {
return _returnsA
}
func (api *apiTimerLayer) GetPublicChannelsForTeam(teamId string, page, perPage int) ([]*model.Channel, *model.AppError) {
func (api *apiTimerLayer) GetPublicChannelsForTeam(teamID string, page, perPage int) ([]*model.Channel, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPublicChannelsForTeam(teamId, page, perPage)
_returnsA, _returnsB := api.apiImpl.GetPublicChannelsForTeam(teamID, page, perPage)
api.recordTime(startTime, "GetPublicChannelsForTeam", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -434,9 +434,9 @@ func (api *apiTimerLayer) GetChannel(channelId string) (*model.Channel, *model.A
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetChannelByName(teamId, name string, includeDeleted bool) (*model.Channel, *model.AppError) {
func (api *apiTimerLayer) GetChannelByName(teamID, name string, includeDeleted bool) (*model.Channel, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetChannelByName(teamId, name, includeDeleted)
_returnsA, _returnsB := api.apiImpl.GetChannelByName(teamID, name, includeDeleted)
api.recordTime(startTime, "GetChannelByName", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -448,9 +448,9 @@ func (api *apiTimerLayer) GetChannelByNameForTeamName(teamName, channelName stri
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetChannelsForTeamForUser(teamId, userId string, includeDeleted bool) ([]*model.Channel, *model.AppError) {
func (api *apiTimerLayer) GetChannelsForTeamForUser(teamID, userID string, includeDeleted bool) ([]*model.Channel, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetChannelsForTeamForUser(teamId, userId, includeDeleted)
_returnsA, _returnsB := api.apiImpl.GetChannelsForTeamForUser(teamID, userID, includeDeleted)
api.recordTime(startTime, "GetChannelsForTeamForUser", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -483,9 +483,9 @@ func (api *apiTimerLayer) UpdateChannel(channel *model.Channel) (*model.Channel,
return _returnsA, _returnsB
}
func (api *apiTimerLayer) SearchChannels(teamId string, term string) ([]*model.Channel, *model.AppError) {
func (api *apiTimerLayer) SearchChannels(teamID string, term string) ([]*model.Channel, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.SearchChannels(teamId, term)
_returnsA, _returnsB := api.apiImpl.SearchChannels(teamID, term)
api.recordTime(startTime, "SearchChannels", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -497,37 +497,37 @@ func (api *apiTimerLayer) SearchUsers(search *model.UserSearch) ([]*model.User,
return _returnsA, _returnsB
}
func (api *apiTimerLayer) SearchPostsInTeam(teamId string, paramsList []*model.SearchParams) ([]*model.Post, *model.AppError) {
func (api *apiTimerLayer) SearchPostsInTeam(teamID string, paramsList []*model.SearchParams) ([]*model.Post, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.SearchPostsInTeam(teamId, paramsList)
_returnsA, _returnsB := api.apiImpl.SearchPostsInTeam(teamID, paramsList)
api.recordTime(startTime, "SearchPostsInTeam", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) SearchPostsInTeamForUser(teamId string, userId string, searchParams model.SearchParameter) (*model.PostSearchResults, *model.AppError) {
func (api *apiTimerLayer) SearchPostsInTeamForUser(teamID string, userID string, searchParams model.SearchParameter) (*model.PostSearchResults, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.SearchPostsInTeamForUser(teamId, userId, searchParams)
_returnsA, _returnsB := api.apiImpl.SearchPostsInTeamForUser(teamID, userID, searchParams)
api.recordTime(startTime, "SearchPostsInTeamForUser", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
func (api *apiTimerLayer) AddChannelMember(channelId, userID string) (*model.ChannelMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.AddChannelMember(channelId, userId)
_returnsA, _returnsB := api.apiImpl.AddChannelMember(channelId, userID)
api.recordTime(startTime, "AddChannelMember", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) AddUserToChannel(channelId, userId, asUserId string) (*model.ChannelMember, *model.AppError) {
func (api *apiTimerLayer) AddUserToChannel(channelId, userID, asUserId string) (*model.ChannelMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.AddUserToChannel(channelId, userId, asUserId)
_returnsA, _returnsB := api.apiImpl.AddUserToChannel(channelId, userID, asUserId)
api.recordTime(startTime, "AddUserToChannel", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
func (api *apiTimerLayer) GetChannelMember(channelId, userID string) (*model.ChannelMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetChannelMember(channelId, userId)
_returnsA, _returnsB := api.apiImpl.GetChannelMember(channelId, userID)
api.recordTime(startTime, "GetChannelMember", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -546,23 +546,23 @@ func (api *apiTimerLayer) GetChannelMembersByIds(channelId string, userIds []str
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetChannelMembersForUser(teamId, userId string, page, perPage int) ([]*model.ChannelMember, *model.AppError) {
func (api *apiTimerLayer) GetChannelMembersForUser(teamID, userID string, page, perPage int) ([]*model.ChannelMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetChannelMembersForUser(teamId, userId, page, perPage)
_returnsA, _returnsB := api.apiImpl.GetChannelMembersForUser(teamID, userID, page, perPage)
api.recordTime(startTime, "GetChannelMembersForUser", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError) {
func (api *apiTimerLayer) UpdateChannelMemberRoles(channelId, userID, newRoles string) (*model.ChannelMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdateChannelMemberRoles(channelId, userId, newRoles)
_returnsA, _returnsB := api.apiImpl.UpdateChannelMemberRoles(channelId, userID, newRoles)
api.recordTime(startTime, "UpdateChannelMemberRoles", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
func (api *apiTimerLayer) UpdateChannelMemberNotifications(channelId, userID string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdateChannelMemberNotifications(channelId, userId, notifications)
_returnsA, _returnsB := api.apiImpl.UpdateChannelMemberNotifications(channelId, userID, notifications)
api.recordTime(startTime, "UpdateChannelMemberNotifications", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -595,16 +595,16 @@ func (api *apiTimerLayer) GetGroupsBySource(groupSource model.GroupSource) ([]*m
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetGroupsForUser(userId string) ([]*model.Group, *model.AppError) {
func (api *apiTimerLayer) GetGroupsForUser(userID string) ([]*model.Group, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetGroupsForUser(userId)
_returnsA, _returnsB := api.apiImpl.GetGroupsForUser(userID)
api.recordTime(startTime, "GetGroupsForUser", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeleteChannelMember(channelId, userId string) *model.AppError {
func (api *apiTimerLayer) DeleteChannelMember(channelId, userID string) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeleteChannelMember(channelId, userId)
_returnsA := api.apiImpl.DeleteChannelMember(channelId, userID)
api.recordTime(startTime, "DeleteChannelMember", _returnsA == nil)
return _returnsA
}
@@ -637,23 +637,23 @@ func (api *apiTimerLayer) GetReactions(postId string) ([]*model.Reaction, *model
return _returnsA, _returnsB
}
func (api *apiTimerLayer) SendEphemeralPost(userId string, post *model.Post) *model.Post {
func (api *apiTimerLayer) SendEphemeralPost(userID string, post *model.Post) *model.Post {
startTime := timePkg.Now()
_returnsA := api.apiImpl.SendEphemeralPost(userId, post)
_returnsA := api.apiImpl.SendEphemeralPost(userID, post)
api.recordTime(startTime, "SendEphemeralPost", true)
return _returnsA
}
func (api *apiTimerLayer) UpdateEphemeralPost(userId string, post *model.Post) *model.Post {
func (api *apiTimerLayer) UpdateEphemeralPost(userID string, post *model.Post) *model.Post {
startTime := timePkg.Now()
_returnsA := api.apiImpl.UpdateEphemeralPost(userId, post)
_returnsA := api.apiImpl.UpdateEphemeralPost(userID, post)
api.recordTime(startTime, "UpdateEphemeralPost", true)
return _returnsA
}
func (api *apiTimerLayer) DeleteEphemeralPost(userId, postId string) {
func (api *apiTimerLayer) DeleteEphemeralPost(userID, postId string) {
startTime := timePkg.Now()
api.apiImpl.DeleteEphemeralPost(userId, postId)
api.apiImpl.DeleteEphemeralPost(userID, postId)
api.recordTime(startTime, "DeleteEphemeralPost", true)
}
@@ -706,9 +706,9 @@ func (api *apiTimerLayer) GetPostsForChannel(channelId string, page, perPage int
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetTeamStats(teamId string) (*model.TeamStats, *model.AppError) {
func (api *apiTimerLayer) GetTeamStats(teamID string) (*model.TeamStats, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetTeamStats(teamId)
_returnsA, _returnsB := api.apiImpl.GetTeamStats(teamID)
api.recordTime(startTime, "GetTeamStats", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -720,16 +720,16 @@ func (api *apiTimerLayer) UpdatePost(post *model.Post) (*model.Post, *model.AppE
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetProfileImage(userId string) ([]byte, *model.AppError) {
func (api *apiTimerLayer) GetProfileImage(userID string) ([]byte, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetProfileImage(userId)
_returnsA, _returnsB := api.apiImpl.GetProfileImage(userID)
api.recordTime(startTime, "GetProfileImage", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) SetProfileImage(userId string, data []byte) *model.AppError {
func (api *apiTimerLayer) SetProfileImage(userID string, data []byte) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.SetProfileImage(userId, data)
_returnsA := api.apiImpl.SetProfileImage(userID, data)
api.recordTime(startTime, "SetProfileImage", _returnsA == nil)
return _returnsA
}
@@ -755,9 +755,9 @@ func (api *apiTimerLayer) GetEmoji(emojiId string) (*model.Emoji, *model.AppErro
return _returnsA, _returnsB
}
func (api *apiTimerLayer) CopyFileInfos(userId string, fileIds []string) ([]string, *model.AppError) {
func (api *apiTimerLayer) CopyFileInfos(userID string, fileIds []string) ([]string, *model.AppError) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.CopyFileInfos(userId, fileIds)
_returnsA, _returnsB := api.apiImpl.CopyFileInfos(userID, fileIds)
api.recordTime(startTime, "CopyFileInfos", _returnsB == nil)
return _returnsA, _returnsB
}
@@ -929,23 +929,23 @@ func (api *apiTimerLayer) PublishWebSocketEvent(event string, payload map[string
api.recordTime(startTime, "PublishWebSocketEvent", true)
}
func (api *apiTimerLayer) HasPermissionTo(userId string, permission *model.Permission) bool {
func (api *apiTimerLayer) HasPermissionTo(userID string, permission *model.Permission) bool {
startTime := timePkg.Now()
_returnsA := api.apiImpl.HasPermissionTo(userId, permission)
_returnsA := api.apiImpl.HasPermissionTo(userID, permission)
api.recordTime(startTime, "HasPermissionTo", true)
return _returnsA
}
func (api *apiTimerLayer) HasPermissionToTeam(userId, teamId string, permission *model.Permission) bool {
func (api *apiTimerLayer) HasPermissionToTeam(userID, teamID string, permission *model.Permission) bool {
startTime := timePkg.Now()
_returnsA := api.apiImpl.HasPermissionToTeam(userId, teamId, permission)
_returnsA := api.apiImpl.HasPermissionToTeam(userID, teamID, permission)
api.recordTime(startTime, "HasPermissionToTeam", true)
return _returnsA
}
func (api *apiTimerLayer) HasPermissionToChannel(userId, channelId string, permission *model.Permission) bool {
func (api *apiTimerLayer) HasPermissionToChannel(userID, channelId string, permission *model.Permission) bool {
startTime := timePkg.Now()
_returnsA := api.apiImpl.HasPermissionToChannel(userId, channelId, permission)
_returnsA := api.apiImpl.HasPermissionToChannel(userID, channelId, permission)
api.recordTime(startTime, "HasPermissionToChannel", true)
return _returnsA
}
@@ -1051,9 +1051,9 @@ func (api *apiTimerLayer) PluginHTTP(request *http.Request) *http.Response {
return _returnsA
}
func (api *apiTimerLayer) PublishUserTyping(userId, channelId, parentId string) *model.AppError {
func (api *apiTimerLayer) PublishUserTyping(userID, channelId, parentId string) *model.AppError {
startTime := timePkg.Now()
_returnsA := api.apiImpl.PublishUserTyping(userId, channelId, parentId)
_returnsA := api.apiImpl.PublishUserTyping(userID, channelId, parentId)
api.recordTime(startTime, "PublishUserTyping", _returnsA == nil)
return _returnsA
}

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

@@ -570,8 +570,8 @@ type Z_UnregisterCommandReturns struct {
A error
}
func (g *apiRPCClient) UnregisterCommand(teamId, trigger string) error {
_args := &Z_UnregisterCommandArgs{teamId, trigger}
func (g *apiRPCClient) UnregisterCommand(teamID, trigger string) error {
_args := &Z_UnregisterCommandArgs{teamID, trigger}
_returns := &Z_UnregisterCommandReturns{}
if err := g.client.Call("Plugin.UnregisterCommand", _args, _returns); err != nil {
log.Printf("RPC call to UnregisterCommand API failed: %s", err.Error())
@@ -581,7 +581,7 @@ func (g *apiRPCClient) UnregisterCommand(teamId, trigger string) error {
func (s *apiRPCServer) UnregisterCommand(args *Z_UnregisterCommandArgs, returns *Z_UnregisterCommandReturns) error {
if hook, ok := s.impl.(interface {
UnregisterCommand(teamId, trigger string) error
UnregisterCommand(teamID, trigger string) error
}); ok {
returns.A = hook.UnregisterCommand(args.A, args.B)
returns.A = encodableError(returns.A)
@@ -630,8 +630,8 @@ type Z_GetSessionReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetSession(sessionId string) (*model.Session, *model.AppError) {
_args := &Z_GetSessionArgs{sessionId}
func (g *apiRPCClient) GetSession(sessionID string) (*model.Session, *model.AppError) {
_args := &Z_GetSessionArgs{sessionID}
_returns := &Z_GetSessionReturns{}
if err := g.client.Call("Plugin.GetSession", _args, _returns); err != nil {
log.Printf("RPC call to GetSession API failed: %s", err.Error())
@@ -641,7 +641,7 @@ func (g *apiRPCClient) GetSession(sessionId string) (*model.Session, *model.AppE
func (s *apiRPCServer) GetSession(args *Z_GetSessionArgs, returns *Z_GetSessionReturns) error {
if hook, ok := s.impl.(interface {
GetSession(sessionId string) (*model.Session, *model.AppError)
GetSession(sessionID string) (*model.Session, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetSession(args.A)
} else {
@@ -989,8 +989,8 @@ type Z_DeleteUserReturns struct {
A *model.AppError
}
func (g *apiRPCClient) DeleteUser(userId string) *model.AppError {
_args := &Z_DeleteUserArgs{userId}
func (g *apiRPCClient) DeleteUser(userID string) *model.AppError {
_args := &Z_DeleteUserArgs{userID}
_returns := &Z_DeleteUserReturns{}
if err := g.client.Call("Plugin.DeleteUser", _args, _returns); err != nil {
log.Printf("RPC call to DeleteUser API failed: %s", err.Error())
@@ -1000,7 +1000,7 @@ func (g *apiRPCClient) DeleteUser(userId string) *model.AppError {
func (s *apiRPCServer) DeleteUser(args *Z_DeleteUserArgs, returns *Z_DeleteUserReturns) error {
if hook, ok := s.impl.(interface {
DeleteUser(userId string) *model.AppError
DeleteUser(userID string) *model.AppError
}); ok {
returns.A = hook.DeleteUser(args.A)
} else {
@@ -1047,8 +1047,8 @@ type Z_GetUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetUser(userId string) (*model.User, *model.AppError) {
_args := &Z_GetUserArgs{userId}
func (g *apiRPCClient) GetUser(userID string) (*model.User, *model.AppError) {
_args := &Z_GetUserArgs{userID}
_returns := &Z_GetUserReturns{}
if err := g.client.Call("Plugin.GetUser", _args, _returns); err != nil {
log.Printf("RPC call to GetUser API failed: %s", err.Error())
@@ -1058,7 +1058,7 @@ func (g *apiRPCClient) GetUser(userId string) (*model.User, *model.AppError) {
func (s *apiRPCServer) GetUser(args *Z_GetUserArgs, returns *Z_GetUserReturns) error {
if hook, ok := s.impl.(interface {
GetUser(userId string) (*model.User, *model.AppError)
GetUser(userID string) (*model.User, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetUser(args.A)
} else {
@@ -1165,8 +1165,8 @@ type Z_GetUsersInTeamReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetUsersInTeam(teamId string, page int, perPage int) ([]*model.User, *model.AppError) {
_args := &Z_GetUsersInTeamArgs{teamId, page, perPage}
func (g *apiRPCClient) GetUsersInTeam(teamID string, page int, perPage int) ([]*model.User, *model.AppError) {
_args := &Z_GetUsersInTeamArgs{teamID, page, perPage}
_returns := &Z_GetUsersInTeamReturns{}
if err := g.client.Call("Plugin.GetUsersInTeam", _args, _returns); err != nil {
log.Printf("RPC call to GetUsersInTeam API failed: %s", err.Error())
@@ -1176,7 +1176,7 @@ func (g *apiRPCClient) GetUsersInTeam(teamId string, page int, perPage int) ([]*
func (s *apiRPCServer) GetUsersInTeam(args *Z_GetUsersInTeamArgs, returns *Z_GetUsersInTeamReturns) error {
if hook, ok := s.impl.(interface {
GetUsersInTeam(teamId string, page int, perPage int) ([]*model.User, *model.AppError)
GetUsersInTeam(teamID string, page int, perPage int) ([]*model.User, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetUsersInTeam(args.A, args.B, args.C)
} else {
@@ -1194,8 +1194,8 @@ type Z_GetPreferencesForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetPreferencesForUser(userId string) ([]model.Preference, *model.AppError) {
_args := &Z_GetPreferencesForUserArgs{userId}
func (g *apiRPCClient) GetPreferencesForUser(userID string) ([]model.Preference, *model.AppError) {
_args := &Z_GetPreferencesForUserArgs{userID}
_returns := &Z_GetPreferencesForUserReturns{}
if err := g.client.Call("Plugin.GetPreferencesForUser", _args, _returns); err != nil {
log.Printf("RPC call to GetPreferencesForUser API failed: %s", err.Error())
@@ -1205,7 +1205,7 @@ func (g *apiRPCClient) GetPreferencesForUser(userId string) ([]model.Preference,
func (s *apiRPCServer) GetPreferencesForUser(args *Z_GetPreferencesForUserArgs, returns *Z_GetPreferencesForUserReturns) error {
if hook, ok := s.impl.(interface {
GetPreferencesForUser(userId string) ([]model.Preference, *model.AppError)
GetPreferencesForUser(userID string) ([]model.Preference, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetPreferencesForUser(args.A)
} else {
@@ -1223,8 +1223,8 @@ type Z_UpdatePreferencesForUserReturns struct {
A *model.AppError
}
func (g *apiRPCClient) UpdatePreferencesForUser(userId string, preferences []model.Preference) *model.AppError {
_args := &Z_UpdatePreferencesForUserArgs{userId, preferences}
func (g *apiRPCClient) UpdatePreferencesForUser(userID string, preferences []model.Preference) *model.AppError {
_args := &Z_UpdatePreferencesForUserArgs{userID, preferences}
_returns := &Z_UpdatePreferencesForUserReturns{}
if err := g.client.Call("Plugin.UpdatePreferencesForUser", _args, _returns); err != nil {
log.Printf("RPC call to UpdatePreferencesForUser API failed: %s", err.Error())
@@ -1234,7 +1234,7 @@ func (g *apiRPCClient) UpdatePreferencesForUser(userId string, preferences []mod
func (s *apiRPCServer) UpdatePreferencesForUser(args *Z_UpdatePreferencesForUserArgs, returns *Z_UpdatePreferencesForUserReturns) error {
if hook, ok := s.impl.(interface {
UpdatePreferencesForUser(userId string, preferences []model.Preference) *model.AppError
UpdatePreferencesForUser(userID string, preferences []model.Preference) *model.AppError
}); ok {
returns.A = hook.UpdatePreferencesForUser(args.A, args.B)
} else {
@@ -1252,8 +1252,8 @@ type Z_DeletePreferencesForUserReturns struct {
A *model.AppError
}
func (g *apiRPCClient) DeletePreferencesForUser(userId string, preferences []model.Preference) *model.AppError {
_args := &Z_DeletePreferencesForUserArgs{userId, preferences}
func (g *apiRPCClient) DeletePreferencesForUser(userID string, preferences []model.Preference) *model.AppError {
_args := &Z_DeletePreferencesForUserArgs{userID, preferences}
_returns := &Z_DeletePreferencesForUserReturns{}
if err := g.client.Call("Plugin.DeletePreferencesForUser", _args, _returns); err != nil {
log.Printf("RPC call to DeletePreferencesForUser API failed: %s", err.Error())
@@ -1263,7 +1263,7 @@ func (g *apiRPCClient) DeletePreferencesForUser(userId string, preferences []mod
func (s *apiRPCServer) DeletePreferencesForUser(args *Z_DeletePreferencesForUserArgs, returns *Z_DeletePreferencesForUserReturns) error {
if hook, ok := s.impl.(interface {
DeletePreferencesForUser(userId string, preferences []model.Preference) *model.AppError
DeletePreferencesForUser(userID string, preferences []model.Preference) *model.AppError
}); ok {
returns.A = hook.DeletePreferencesForUser(args.A, args.B)
} else {
@@ -1281,8 +1281,8 @@ type Z_GetTeamIconReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeamIcon(teamId string) ([]byte, *model.AppError) {
_args := &Z_GetTeamIconArgs{teamId}
func (g *apiRPCClient) GetTeamIcon(teamID string) ([]byte, *model.AppError) {
_args := &Z_GetTeamIconArgs{teamID}
_returns := &Z_GetTeamIconReturns{}
if err := g.client.Call("Plugin.GetTeamIcon", _args, _returns); err != nil {
log.Printf("RPC call to GetTeamIcon API failed: %s", err.Error())
@@ -1292,7 +1292,7 @@ func (g *apiRPCClient) GetTeamIcon(teamId string) ([]byte, *model.AppError) {
func (s *apiRPCServer) GetTeamIcon(args *Z_GetTeamIconArgs, returns *Z_GetTeamIconReturns) error {
if hook, ok := s.impl.(interface {
GetTeamIcon(teamId string) ([]byte, *model.AppError)
GetTeamIcon(teamID string) ([]byte, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeamIcon(args.A)
} else {
@@ -1310,8 +1310,8 @@ type Z_SetTeamIconReturns struct {
A *model.AppError
}
func (g *apiRPCClient) SetTeamIcon(teamId string, data []byte) *model.AppError {
_args := &Z_SetTeamIconArgs{teamId, data}
func (g *apiRPCClient) SetTeamIcon(teamID string, data []byte) *model.AppError {
_args := &Z_SetTeamIconArgs{teamID, data}
_returns := &Z_SetTeamIconReturns{}
if err := g.client.Call("Plugin.SetTeamIcon", _args, _returns); err != nil {
log.Printf("RPC call to SetTeamIcon API failed: %s", err.Error())
@@ -1321,7 +1321,7 @@ func (g *apiRPCClient) SetTeamIcon(teamId string, data []byte) *model.AppError {
func (s *apiRPCServer) SetTeamIcon(args *Z_SetTeamIconArgs, returns *Z_SetTeamIconReturns) error {
if hook, ok := s.impl.(interface {
SetTeamIcon(teamId string, data []byte) *model.AppError
SetTeamIcon(teamID string, data []byte) *model.AppError
}); ok {
returns.A = hook.SetTeamIcon(args.A, args.B)
} else {
@@ -1338,8 +1338,8 @@ type Z_RemoveTeamIconReturns struct {
A *model.AppError
}
func (g *apiRPCClient) RemoveTeamIcon(teamId string) *model.AppError {
_args := &Z_RemoveTeamIconArgs{teamId}
func (g *apiRPCClient) RemoveTeamIcon(teamID string) *model.AppError {
_args := &Z_RemoveTeamIconArgs{teamID}
_returns := &Z_RemoveTeamIconReturns{}
if err := g.client.Call("Plugin.RemoveTeamIcon", _args, _returns); err != nil {
log.Printf("RPC call to RemoveTeamIcon API failed: %s", err.Error())
@@ -1349,7 +1349,7 @@ func (g *apiRPCClient) RemoveTeamIcon(teamId string) *model.AppError {
func (s *apiRPCServer) RemoveTeamIcon(args *Z_RemoveTeamIconArgs, returns *Z_RemoveTeamIconReturns) error {
if hook, ok := s.impl.(interface {
RemoveTeamIcon(teamId string) *model.AppError
RemoveTeamIcon(teamID string) *model.AppError
}); ok {
returns.A = hook.RemoveTeamIcon(args.A)
} else {
@@ -1396,8 +1396,8 @@ type Z_GetUserStatusReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetUserStatus(userId string) (*model.Status, *model.AppError) {
_args := &Z_GetUserStatusArgs{userId}
func (g *apiRPCClient) GetUserStatus(userID string) (*model.Status, *model.AppError) {
_args := &Z_GetUserStatusArgs{userID}
_returns := &Z_GetUserStatusReturns{}
if err := g.client.Call("Plugin.GetUserStatus", _args, _returns); err != nil {
log.Printf("RPC call to GetUserStatus API failed: %s", err.Error())
@@ -1407,7 +1407,7 @@ func (g *apiRPCClient) GetUserStatus(userId string) (*model.Status, *model.AppEr
func (s *apiRPCServer) GetUserStatus(args *Z_GetUserStatusArgs, returns *Z_GetUserStatusReturns) error {
if hook, ok := s.impl.(interface {
GetUserStatus(userId string) (*model.Status, *model.AppError)
GetUserStatus(userID string) (*model.Status, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetUserStatus(args.A)
} else {
@@ -1455,8 +1455,8 @@ type Z_UpdateUserStatusReturns struct {
B *model.AppError
}
func (g *apiRPCClient) UpdateUserStatus(userId, status string) (*model.Status, *model.AppError) {
_args := &Z_UpdateUserStatusArgs{userId, status}
func (g *apiRPCClient) UpdateUserStatus(userID, status string) (*model.Status, *model.AppError) {
_args := &Z_UpdateUserStatusArgs{userID, status}
_returns := &Z_UpdateUserStatusReturns{}
if err := g.client.Call("Plugin.UpdateUserStatus", _args, _returns); err != nil {
log.Printf("RPC call to UpdateUserStatus API failed: %s", err.Error())
@@ -1466,7 +1466,7 @@ func (g *apiRPCClient) UpdateUserStatus(userId, status string) (*model.Status, *
func (s *apiRPCServer) UpdateUserStatus(args *Z_UpdateUserStatusArgs, returns *Z_UpdateUserStatusReturns) error {
if hook, ok := s.impl.(interface {
UpdateUserStatus(userId, status string) (*model.Status, *model.AppError)
UpdateUserStatus(userID, status string) (*model.Status, *model.AppError)
}); ok {
returns.A, returns.B = hook.UpdateUserStatus(args.A, args.B)
} else {
@@ -1484,8 +1484,8 @@ type Z_UpdateUserActiveReturns struct {
A *model.AppError
}
func (g *apiRPCClient) UpdateUserActive(userId string, active bool) *model.AppError {
_args := &Z_UpdateUserActiveArgs{userId, active}
func (g *apiRPCClient) UpdateUserActive(userID string, active bool) *model.AppError {
_args := &Z_UpdateUserActiveArgs{userID, active}
_returns := &Z_UpdateUserActiveReturns{}
if err := g.client.Call("Plugin.UpdateUserActive", _args, _returns); err != nil {
log.Printf("RPC call to UpdateUserActive API failed: %s", err.Error())
@@ -1495,7 +1495,7 @@ func (g *apiRPCClient) UpdateUserActive(userId string, active bool) *model.AppEr
func (s *apiRPCServer) UpdateUserActive(args *Z_UpdateUserActiveArgs, returns *Z_UpdateUserActiveReturns) error {
if hook, ok := s.impl.(interface {
UpdateUserActive(userId string, active bool) *model.AppError
UpdateUserActive(userID string, active bool) *model.AppError
}); ok {
returns.A = hook.UpdateUserActive(args.A, args.B)
} else {
@@ -1516,8 +1516,8 @@ type Z_GetUsersInChannelReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetUsersInChannel(channelId, sortBy string, page, perPage int) ([]*model.User, *model.AppError) {
_args := &Z_GetUsersInChannelArgs{channelId, sortBy, page, perPage}
func (g *apiRPCClient) GetUsersInChannel(channelID, sortBy string, page, perPage int) ([]*model.User, *model.AppError) {
_args := &Z_GetUsersInChannelArgs{channelID, sortBy, page, perPage}
_returns := &Z_GetUsersInChannelReturns{}
if err := g.client.Call("Plugin.GetUsersInChannel", _args, _returns); err != nil {
log.Printf("RPC call to GetUsersInChannel API failed: %s", err.Error())
@@ -1527,7 +1527,7 @@ func (g *apiRPCClient) GetUsersInChannel(channelId, sortBy string, page, perPage
func (s *apiRPCServer) GetUsersInChannel(args *Z_GetUsersInChannelArgs, returns *Z_GetUsersInChannelReturns) error {
if hook, ok := s.impl.(interface {
GetUsersInChannel(channelId, sortBy string, page, perPage int) ([]*model.User, *model.AppError)
GetUsersInChannel(channelID, sortBy string, page, perPage int) ([]*model.User, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetUsersInChannel(args.A, args.B, args.C, args.D)
} else {
@@ -1546,8 +1546,8 @@ type Z_GetLDAPUserAttributesReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetLDAPUserAttributes(userId string, attributes []string) (map[string]string, *model.AppError) {
_args := &Z_GetLDAPUserAttributesArgs{userId, attributes}
func (g *apiRPCClient) GetLDAPUserAttributes(userID string, attributes []string) (map[string]string, *model.AppError) {
_args := &Z_GetLDAPUserAttributesArgs{userID, attributes}
_returns := &Z_GetLDAPUserAttributesReturns{}
if err := g.client.Call("Plugin.GetLDAPUserAttributes", _args, _returns); err != nil {
log.Printf("RPC call to GetLDAPUserAttributes API failed: %s", err.Error())
@@ -1557,7 +1557,7 @@ func (g *apiRPCClient) GetLDAPUserAttributes(userId string, attributes []string)
func (s *apiRPCServer) GetLDAPUserAttributes(args *Z_GetLDAPUserAttributesArgs, returns *Z_GetLDAPUserAttributesReturns) error {
if hook, ok := s.impl.(interface {
GetLDAPUserAttributes(userId string, attributes []string) (map[string]string, *model.AppError)
GetLDAPUserAttributes(userID string, attributes []string) (map[string]string, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetLDAPUserAttributes(args.A, args.B)
} else {
@@ -1603,8 +1603,8 @@ type Z_DeleteTeamReturns struct {
A *model.AppError
}
func (g *apiRPCClient) DeleteTeam(teamId string) *model.AppError {
_args := &Z_DeleteTeamArgs{teamId}
func (g *apiRPCClient) DeleteTeam(teamID string) *model.AppError {
_args := &Z_DeleteTeamArgs{teamID}
_returns := &Z_DeleteTeamReturns{}
if err := g.client.Call("Plugin.DeleteTeam", _args, _returns); err != nil {
log.Printf("RPC call to DeleteTeam API failed: %s", err.Error())
@@ -1614,7 +1614,7 @@ func (g *apiRPCClient) DeleteTeam(teamId string) *model.AppError {
func (s *apiRPCServer) DeleteTeam(args *Z_DeleteTeamArgs, returns *Z_DeleteTeamReturns) error {
if hook, ok := s.impl.(interface {
DeleteTeam(teamId string) *model.AppError
DeleteTeam(teamID string) *model.AppError
}); ok {
returns.A = hook.DeleteTeam(args.A)
} else {
@@ -1660,8 +1660,8 @@ type Z_GetTeamReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeam(teamId string) (*model.Team, *model.AppError) {
_args := &Z_GetTeamArgs{teamId}
func (g *apiRPCClient) GetTeam(teamID string) (*model.Team, *model.AppError) {
_args := &Z_GetTeamArgs{teamID}
_returns := &Z_GetTeamReturns{}
if err := g.client.Call("Plugin.GetTeam", _args, _returns); err != nil {
log.Printf("RPC call to GetTeam API failed: %s", err.Error())
@@ -1671,7 +1671,7 @@ func (g *apiRPCClient) GetTeam(teamId string) (*model.Team, *model.AppError) {
func (s *apiRPCServer) GetTeam(args *Z_GetTeamArgs, returns *Z_GetTeamReturns) error {
if hook, ok := s.impl.(interface {
GetTeam(teamId string) (*model.Team, *model.AppError)
GetTeam(teamID string) (*model.Team, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeam(args.A)
} else {
@@ -1718,8 +1718,8 @@ type Z_GetTeamsUnreadForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeamsUnreadForUser(userId string) ([]*model.TeamUnread, *model.AppError) {
_args := &Z_GetTeamsUnreadForUserArgs{userId}
func (g *apiRPCClient) GetTeamsUnreadForUser(userID string) ([]*model.TeamUnread, *model.AppError) {
_args := &Z_GetTeamsUnreadForUserArgs{userID}
_returns := &Z_GetTeamsUnreadForUserReturns{}
if err := g.client.Call("Plugin.GetTeamsUnreadForUser", _args, _returns); err != nil {
log.Printf("RPC call to GetTeamsUnreadForUser API failed: %s", err.Error())
@@ -1729,7 +1729,7 @@ func (g *apiRPCClient) GetTeamsUnreadForUser(userId string) ([]*model.TeamUnread
func (s *apiRPCServer) GetTeamsUnreadForUser(args *Z_GetTeamsUnreadForUserArgs, returns *Z_GetTeamsUnreadForUserReturns) error {
if hook, ok := s.impl.(interface {
GetTeamsUnreadForUser(userId string) ([]*model.TeamUnread, *model.AppError)
GetTeamsUnreadForUser(userID string) ([]*model.TeamUnread, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeamsUnreadForUser(args.A)
} else {
@@ -1805,8 +1805,8 @@ type Z_GetTeamsForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeamsForUser(userId string) ([]*model.Team, *model.AppError) {
_args := &Z_GetTeamsForUserArgs{userId}
func (g *apiRPCClient) GetTeamsForUser(userID string) ([]*model.Team, *model.AppError) {
_args := &Z_GetTeamsForUserArgs{userID}
_returns := &Z_GetTeamsForUserReturns{}
if err := g.client.Call("Plugin.GetTeamsForUser", _args, _returns); err != nil {
log.Printf("RPC call to GetTeamsForUser API failed: %s", err.Error())
@@ -1816,7 +1816,7 @@ func (g *apiRPCClient) GetTeamsForUser(userId string) ([]*model.Team, *model.App
func (s *apiRPCServer) GetTeamsForUser(args *Z_GetTeamsForUserArgs, returns *Z_GetTeamsForUserReturns) error {
if hook, ok := s.impl.(interface {
GetTeamsForUser(userId string) ([]*model.Team, *model.AppError)
GetTeamsForUser(userID string) ([]*model.Team, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeamsForUser(args.A)
} else {
@@ -1835,8 +1835,8 @@ type Z_CreateTeamMemberReturns struct {
B *model.AppError
}
func (g *apiRPCClient) CreateTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
_args := &Z_CreateTeamMemberArgs{teamId, userId}
func (g *apiRPCClient) CreateTeamMember(teamID, userID string) (*model.TeamMember, *model.AppError) {
_args := &Z_CreateTeamMemberArgs{teamID, userID}
_returns := &Z_CreateTeamMemberReturns{}
if err := g.client.Call("Plugin.CreateTeamMember", _args, _returns); err != nil {
log.Printf("RPC call to CreateTeamMember API failed: %s", err.Error())
@@ -1846,7 +1846,7 @@ func (g *apiRPCClient) CreateTeamMember(teamId, userId string) (*model.TeamMembe
func (s *apiRPCServer) CreateTeamMember(args *Z_CreateTeamMemberArgs, returns *Z_CreateTeamMemberReturns) error {
if hook, ok := s.impl.(interface {
CreateTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError)
CreateTeamMember(teamID, userID string) (*model.TeamMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.CreateTeamMember(args.A, args.B)
} else {
@@ -1866,8 +1866,8 @@ type Z_CreateTeamMembersReturns struct {
B *model.AppError
}
func (g *apiRPCClient) CreateTeamMembers(teamId string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) {
_args := &Z_CreateTeamMembersArgs{teamId, userIds, requestorId}
func (g *apiRPCClient) CreateTeamMembers(teamID string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) {
_args := &Z_CreateTeamMembersArgs{teamID, userIds, requestorId}
_returns := &Z_CreateTeamMembersReturns{}
if err := g.client.Call("Plugin.CreateTeamMembers", _args, _returns); err != nil {
log.Printf("RPC call to CreateTeamMembers API failed: %s", err.Error())
@@ -1877,7 +1877,7 @@ func (g *apiRPCClient) CreateTeamMembers(teamId string, userIds []string, reques
func (s *apiRPCServer) CreateTeamMembers(args *Z_CreateTeamMembersArgs, returns *Z_CreateTeamMembersReturns) error {
if hook, ok := s.impl.(interface {
CreateTeamMembers(teamId string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError)
CreateTeamMembers(teamID string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.CreateTeamMembers(args.A, args.B, args.C)
} else {
@@ -1897,8 +1897,8 @@ type Z_CreateTeamMembersGracefullyReturns struct {
B *model.AppError
}
func (g *apiRPCClient) CreateTeamMembersGracefully(teamId string, userIds []string, requestorId string) ([]*model.TeamMemberWithError, *model.AppError) {
_args := &Z_CreateTeamMembersGracefullyArgs{teamId, userIds, requestorId}
func (g *apiRPCClient) CreateTeamMembersGracefully(teamID string, userIds []string, requestorId string) ([]*model.TeamMemberWithError, *model.AppError) {
_args := &Z_CreateTeamMembersGracefullyArgs{teamID, userIds, requestorId}
_returns := &Z_CreateTeamMembersGracefullyReturns{}
if err := g.client.Call("Plugin.CreateTeamMembersGracefully", _args, _returns); err != nil {
log.Printf("RPC call to CreateTeamMembersGracefully API failed: %s", err.Error())
@@ -1908,7 +1908,7 @@ func (g *apiRPCClient) CreateTeamMembersGracefully(teamId string, userIds []stri
func (s *apiRPCServer) CreateTeamMembersGracefully(args *Z_CreateTeamMembersGracefullyArgs, returns *Z_CreateTeamMembersGracefullyReturns) error {
if hook, ok := s.impl.(interface {
CreateTeamMembersGracefully(teamId string, userIds []string, requestorId string) ([]*model.TeamMemberWithError, *model.AppError)
CreateTeamMembersGracefully(teamID string, userIds []string, requestorId string) ([]*model.TeamMemberWithError, *model.AppError)
}); ok {
returns.A, returns.B = hook.CreateTeamMembersGracefully(args.A, args.B, args.C)
} else {
@@ -1927,8 +1927,8 @@ type Z_DeleteTeamMemberReturns struct {
A *model.AppError
}
func (g *apiRPCClient) DeleteTeamMember(teamId, userId, requestorId string) *model.AppError {
_args := &Z_DeleteTeamMemberArgs{teamId, userId, requestorId}
func (g *apiRPCClient) DeleteTeamMember(teamID, userID, requestorId string) *model.AppError {
_args := &Z_DeleteTeamMemberArgs{teamID, userID, requestorId}
_returns := &Z_DeleteTeamMemberReturns{}
if err := g.client.Call("Plugin.DeleteTeamMember", _args, _returns); err != nil {
log.Printf("RPC call to DeleteTeamMember API failed: %s", err.Error())
@@ -1938,7 +1938,7 @@ func (g *apiRPCClient) DeleteTeamMember(teamId, userId, requestorId string) *mod
func (s *apiRPCServer) DeleteTeamMember(args *Z_DeleteTeamMemberArgs, returns *Z_DeleteTeamMemberReturns) error {
if hook, ok := s.impl.(interface {
DeleteTeamMember(teamId, userId, requestorId string) *model.AppError
DeleteTeamMember(teamID, userID, requestorId string) *model.AppError
}); ok {
returns.A = hook.DeleteTeamMember(args.A, args.B, args.C)
} else {
@@ -1958,8 +1958,8 @@ type Z_GetTeamMembersReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeamMembers(teamId string, page, perPage int) ([]*model.TeamMember, *model.AppError) {
_args := &Z_GetTeamMembersArgs{teamId, page, perPage}
func (g *apiRPCClient) GetTeamMembers(teamID string, page, perPage int) ([]*model.TeamMember, *model.AppError) {
_args := &Z_GetTeamMembersArgs{teamID, page, perPage}
_returns := &Z_GetTeamMembersReturns{}
if err := g.client.Call("Plugin.GetTeamMembers", _args, _returns); err != nil {
log.Printf("RPC call to GetTeamMembers API failed: %s", err.Error())
@@ -1969,7 +1969,7 @@ func (g *apiRPCClient) GetTeamMembers(teamId string, page, perPage int) ([]*mode
func (s *apiRPCServer) GetTeamMembers(args *Z_GetTeamMembersArgs, returns *Z_GetTeamMembersReturns) error {
if hook, ok := s.impl.(interface {
GetTeamMembers(teamId string, page, perPage int) ([]*model.TeamMember, *model.AppError)
GetTeamMembers(teamID string, page, perPage int) ([]*model.TeamMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeamMembers(args.A, args.B, args.C)
} else {
@@ -1988,8 +1988,8 @@ type Z_GetTeamMemberReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
_args := &Z_GetTeamMemberArgs{teamId, userId}
func (g *apiRPCClient) GetTeamMember(teamID, userID string) (*model.TeamMember, *model.AppError) {
_args := &Z_GetTeamMemberArgs{teamID, userID}
_returns := &Z_GetTeamMemberReturns{}
if err := g.client.Call("Plugin.GetTeamMember", _args, _returns); err != nil {
log.Printf("RPC call to GetTeamMember API failed: %s", err.Error())
@@ -1999,7 +1999,7 @@ func (g *apiRPCClient) GetTeamMember(teamId, userId string) (*model.TeamMember,
func (s *apiRPCServer) GetTeamMember(args *Z_GetTeamMemberArgs, returns *Z_GetTeamMemberReturns) error {
if hook, ok := s.impl.(interface {
GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError)
GetTeamMember(teamID, userID string) (*model.TeamMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeamMember(args.A, args.B)
} else {
@@ -2019,8 +2019,8 @@ type Z_GetTeamMembersForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeamMembersForUser(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
_args := &Z_GetTeamMembersForUserArgs{userId, page, perPage}
func (g *apiRPCClient) GetTeamMembersForUser(userID string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
_args := &Z_GetTeamMembersForUserArgs{userID, page, perPage}
_returns := &Z_GetTeamMembersForUserReturns{}
if err := g.client.Call("Plugin.GetTeamMembersForUser", _args, _returns); err != nil {
log.Printf("RPC call to GetTeamMembersForUser API failed: %s", err.Error())
@@ -2030,7 +2030,7 @@ func (g *apiRPCClient) GetTeamMembersForUser(userId string, page int, perPage in
func (s *apiRPCServer) GetTeamMembersForUser(args *Z_GetTeamMembersForUserArgs, returns *Z_GetTeamMembersForUserReturns) error {
if hook, ok := s.impl.(interface {
GetTeamMembersForUser(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError)
GetTeamMembersForUser(userID string, page int, perPage int) ([]*model.TeamMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeamMembersForUser(args.A, args.B, args.C)
} else {
@@ -2050,8 +2050,8 @@ type Z_UpdateTeamMemberRolesReturns struct {
B *model.AppError
}
func (g *apiRPCClient) UpdateTeamMemberRoles(teamId, userId, newRoles string) (*model.TeamMember, *model.AppError) {
_args := &Z_UpdateTeamMemberRolesArgs{teamId, userId, newRoles}
func (g *apiRPCClient) UpdateTeamMemberRoles(teamID, userID, newRoles string) (*model.TeamMember, *model.AppError) {
_args := &Z_UpdateTeamMemberRolesArgs{teamID, userID, newRoles}
_returns := &Z_UpdateTeamMemberRolesReturns{}
if err := g.client.Call("Plugin.UpdateTeamMemberRoles", _args, _returns); err != nil {
log.Printf("RPC call to UpdateTeamMemberRoles API failed: %s", err.Error())
@@ -2061,7 +2061,7 @@ func (g *apiRPCClient) UpdateTeamMemberRoles(teamId, userId, newRoles string) (*
func (s *apiRPCServer) UpdateTeamMemberRoles(args *Z_UpdateTeamMemberRolesArgs, returns *Z_UpdateTeamMemberRolesReturns) error {
if hook, ok := s.impl.(interface {
UpdateTeamMemberRoles(teamId, userId, newRoles string) (*model.TeamMember, *model.AppError)
UpdateTeamMemberRoles(teamID, userID, newRoles string) (*model.TeamMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.UpdateTeamMemberRoles(args.A, args.B, args.C)
} else {
@@ -2138,8 +2138,8 @@ type Z_GetPublicChannelsForTeamReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetPublicChannelsForTeam(teamId string, page, perPage int) ([]*model.Channel, *model.AppError) {
_args := &Z_GetPublicChannelsForTeamArgs{teamId, page, perPage}
func (g *apiRPCClient) GetPublicChannelsForTeam(teamID string, page, perPage int) ([]*model.Channel, *model.AppError) {
_args := &Z_GetPublicChannelsForTeamArgs{teamID, page, perPage}
_returns := &Z_GetPublicChannelsForTeamReturns{}
if err := g.client.Call("Plugin.GetPublicChannelsForTeam", _args, _returns); err != nil {
log.Printf("RPC call to GetPublicChannelsForTeam API failed: %s", err.Error())
@@ -2149,7 +2149,7 @@ func (g *apiRPCClient) GetPublicChannelsForTeam(teamId string, page, perPage int
func (s *apiRPCServer) GetPublicChannelsForTeam(args *Z_GetPublicChannelsForTeamArgs, returns *Z_GetPublicChannelsForTeamReturns) error {
if hook, ok := s.impl.(interface {
GetPublicChannelsForTeam(teamId string, page, perPage int) ([]*model.Channel, *model.AppError)
GetPublicChannelsForTeam(teamID string, page, perPage int) ([]*model.Channel, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetPublicChannelsForTeam(args.A, args.B, args.C)
} else {
@@ -2198,8 +2198,8 @@ type Z_GetChannelByNameReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetChannelByName(teamId, name string, includeDeleted bool) (*model.Channel, *model.AppError) {
_args := &Z_GetChannelByNameArgs{teamId, name, includeDeleted}
func (g *apiRPCClient) GetChannelByName(teamID, name string, includeDeleted bool) (*model.Channel, *model.AppError) {
_args := &Z_GetChannelByNameArgs{teamID, name, includeDeleted}
_returns := &Z_GetChannelByNameReturns{}
if err := g.client.Call("Plugin.GetChannelByName", _args, _returns); err != nil {
log.Printf("RPC call to GetChannelByName API failed: %s", err.Error())
@@ -2209,7 +2209,7 @@ func (g *apiRPCClient) GetChannelByName(teamId, name string, includeDeleted bool
func (s *apiRPCServer) GetChannelByName(args *Z_GetChannelByNameArgs, returns *Z_GetChannelByNameReturns) error {
if hook, ok := s.impl.(interface {
GetChannelByName(teamId, name string, includeDeleted bool) (*model.Channel, *model.AppError)
GetChannelByName(teamID, name string, includeDeleted bool) (*model.Channel, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetChannelByName(args.A, args.B, args.C)
} else {
@@ -2260,8 +2260,8 @@ type Z_GetChannelsForTeamForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetChannelsForTeamForUser(teamId, userId string, includeDeleted bool) ([]*model.Channel, *model.AppError) {
_args := &Z_GetChannelsForTeamForUserArgs{teamId, userId, includeDeleted}
func (g *apiRPCClient) GetChannelsForTeamForUser(teamID, userID string, includeDeleted bool) ([]*model.Channel, *model.AppError) {
_args := &Z_GetChannelsForTeamForUserArgs{teamID, userID, includeDeleted}
_returns := &Z_GetChannelsForTeamForUserReturns{}
if err := g.client.Call("Plugin.GetChannelsForTeamForUser", _args, _returns); err != nil {
log.Printf("RPC call to GetChannelsForTeamForUser API failed: %s", err.Error())
@@ -2271,7 +2271,7 @@ func (g *apiRPCClient) GetChannelsForTeamForUser(teamId, userId string, includeD
func (s *apiRPCServer) GetChannelsForTeamForUser(args *Z_GetChannelsForTeamForUserArgs, returns *Z_GetChannelsForTeamForUserReturns) error {
if hook, ok := s.impl.(interface {
GetChannelsForTeamForUser(teamId, userId string, includeDeleted bool) ([]*model.Channel, *model.AppError)
GetChannelsForTeamForUser(teamID, userID string, includeDeleted bool) ([]*model.Channel, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetChannelsForTeamForUser(args.A, args.B, args.C)
} else {
@@ -2407,8 +2407,8 @@ type Z_SearchChannelsReturns struct {
B *model.AppError
}
func (g *apiRPCClient) SearchChannels(teamId string, term string) ([]*model.Channel, *model.AppError) {
_args := &Z_SearchChannelsArgs{teamId, term}
func (g *apiRPCClient) SearchChannels(teamID string, term string) ([]*model.Channel, *model.AppError) {
_args := &Z_SearchChannelsArgs{teamID, term}
_returns := &Z_SearchChannelsReturns{}
if err := g.client.Call("Plugin.SearchChannels", _args, _returns); err != nil {
log.Printf("RPC call to SearchChannels API failed: %s", err.Error())
@@ -2418,7 +2418,7 @@ func (g *apiRPCClient) SearchChannels(teamId string, term string) ([]*model.Chan
func (s *apiRPCServer) SearchChannels(args *Z_SearchChannelsArgs, returns *Z_SearchChannelsReturns) error {
if hook, ok := s.impl.(interface {
SearchChannels(teamId string, term string) ([]*model.Channel, *model.AppError)
SearchChannels(teamID string, term string) ([]*model.Channel, *model.AppError)
}); ok {
returns.A, returns.B = hook.SearchChannels(args.A, args.B)
} else {
@@ -2466,8 +2466,8 @@ type Z_SearchPostsInTeamReturns struct {
B *model.AppError
}
func (g *apiRPCClient) SearchPostsInTeam(teamId string, paramsList []*model.SearchParams) ([]*model.Post, *model.AppError) {
_args := &Z_SearchPostsInTeamArgs{teamId, paramsList}
func (g *apiRPCClient) SearchPostsInTeam(teamID string, paramsList []*model.SearchParams) ([]*model.Post, *model.AppError) {
_args := &Z_SearchPostsInTeamArgs{teamID, paramsList}
_returns := &Z_SearchPostsInTeamReturns{}
if err := g.client.Call("Plugin.SearchPostsInTeam", _args, _returns); err != nil {
log.Printf("RPC call to SearchPostsInTeam API failed: %s", err.Error())
@@ -2477,7 +2477,7 @@ func (g *apiRPCClient) SearchPostsInTeam(teamId string, paramsList []*model.Sear
func (s *apiRPCServer) SearchPostsInTeam(args *Z_SearchPostsInTeamArgs, returns *Z_SearchPostsInTeamReturns) error {
if hook, ok := s.impl.(interface {
SearchPostsInTeam(teamId string, paramsList []*model.SearchParams) ([]*model.Post, *model.AppError)
SearchPostsInTeam(teamID string, paramsList []*model.SearchParams) ([]*model.Post, *model.AppError)
}); ok {
returns.A, returns.B = hook.SearchPostsInTeam(args.A, args.B)
} else {
@@ -2497,8 +2497,8 @@ type Z_SearchPostsInTeamForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) SearchPostsInTeamForUser(teamId string, userId string, searchParams model.SearchParameter) (*model.PostSearchResults, *model.AppError) {
_args := &Z_SearchPostsInTeamForUserArgs{teamId, userId, searchParams}
func (g *apiRPCClient) SearchPostsInTeamForUser(teamID string, userID string, searchParams model.SearchParameter) (*model.PostSearchResults, *model.AppError) {
_args := &Z_SearchPostsInTeamForUserArgs{teamID, userID, searchParams}
_returns := &Z_SearchPostsInTeamForUserReturns{}
if err := g.client.Call("Plugin.SearchPostsInTeamForUser", _args, _returns); err != nil {
log.Printf("RPC call to SearchPostsInTeamForUser API failed: %s", err.Error())
@@ -2508,7 +2508,7 @@ func (g *apiRPCClient) SearchPostsInTeamForUser(teamId string, userId string, se
func (s *apiRPCServer) SearchPostsInTeamForUser(args *Z_SearchPostsInTeamForUserArgs, returns *Z_SearchPostsInTeamForUserReturns) error {
if hook, ok := s.impl.(interface {
SearchPostsInTeamForUser(teamId string, userId string, searchParams model.SearchParameter) (*model.PostSearchResults, *model.AppError)
SearchPostsInTeamForUser(teamID string, userID string, searchParams model.SearchParameter) (*model.PostSearchResults, *model.AppError)
}); ok {
returns.A, returns.B = hook.SearchPostsInTeamForUser(args.A, args.B, args.C)
} else {
@@ -2527,8 +2527,8 @@ type Z_AddChannelMemberReturns struct {
B *model.AppError
}
func (g *apiRPCClient) AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
_args := &Z_AddChannelMemberArgs{channelId, userId}
func (g *apiRPCClient) AddChannelMember(channelId, userID string) (*model.ChannelMember, *model.AppError) {
_args := &Z_AddChannelMemberArgs{channelId, userID}
_returns := &Z_AddChannelMemberReturns{}
if err := g.client.Call("Plugin.AddChannelMember", _args, _returns); err != nil {
log.Printf("RPC call to AddChannelMember API failed: %s", err.Error())
@@ -2538,7 +2538,7 @@ func (g *apiRPCClient) AddChannelMember(channelId, userId string) (*model.Channe
func (s *apiRPCServer) AddChannelMember(args *Z_AddChannelMemberArgs, returns *Z_AddChannelMemberReturns) error {
if hook, ok := s.impl.(interface {
AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError)
AddChannelMember(channelId, userID string) (*model.ChannelMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.AddChannelMember(args.A, args.B)
} else {
@@ -2558,8 +2558,8 @@ type Z_AddUserToChannelReturns struct {
B *model.AppError
}
func (g *apiRPCClient) AddUserToChannel(channelId, userId, asUserId string) (*model.ChannelMember, *model.AppError) {
_args := &Z_AddUserToChannelArgs{channelId, userId, asUserId}
func (g *apiRPCClient) AddUserToChannel(channelId, userID, asUserId string) (*model.ChannelMember, *model.AppError) {
_args := &Z_AddUserToChannelArgs{channelId, userID, asUserId}
_returns := &Z_AddUserToChannelReturns{}
if err := g.client.Call("Plugin.AddUserToChannel", _args, _returns); err != nil {
log.Printf("RPC call to AddUserToChannel API failed: %s", err.Error())
@@ -2569,7 +2569,7 @@ func (g *apiRPCClient) AddUserToChannel(channelId, userId, asUserId string) (*mo
func (s *apiRPCServer) AddUserToChannel(args *Z_AddUserToChannelArgs, returns *Z_AddUserToChannelReturns) error {
if hook, ok := s.impl.(interface {
AddUserToChannel(channelId, userId, asUserId string) (*model.ChannelMember, *model.AppError)
AddUserToChannel(channelId, userID, asUserId string) (*model.ChannelMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.AddUserToChannel(args.A, args.B, args.C)
} else {
@@ -2588,8 +2588,8 @@ type Z_GetChannelMemberReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
_args := &Z_GetChannelMemberArgs{channelId, userId}
func (g *apiRPCClient) GetChannelMember(channelId, userID string) (*model.ChannelMember, *model.AppError) {
_args := &Z_GetChannelMemberArgs{channelId, userID}
_returns := &Z_GetChannelMemberReturns{}
if err := g.client.Call("Plugin.GetChannelMember", _args, _returns); err != nil {
log.Printf("RPC call to GetChannelMember API failed: %s", err.Error())
@@ -2599,7 +2599,7 @@ func (g *apiRPCClient) GetChannelMember(channelId, userId string) (*model.Channe
func (s *apiRPCServer) GetChannelMember(args *Z_GetChannelMemberArgs, returns *Z_GetChannelMemberReturns) error {
if hook, ok := s.impl.(interface {
GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError)
GetChannelMember(channelId, userID string) (*model.ChannelMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetChannelMember(args.A, args.B)
} else {
@@ -2681,8 +2681,8 @@ type Z_GetChannelMembersForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetChannelMembersForUser(teamId, userId string, page, perPage int) ([]*model.ChannelMember, *model.AppError) {
_args := &Z_GetChannelMembersForUserArgs{teamId, userId, page, perPage}
func (g *apiRPCClient) GetChannelMembersForUser(teamID, userID string, page, perPage int) ([]*model.ChannelMember, *model.AppError) {
_args := &Z_GetChannelMembersForUserArgs{teamID, userID, page, perPage}
_returns := &Z_GetChannelMembersForUserReturns{}
if err := g.client.Call("Plugin.GetChannelMembersForUser", _args, _returns); err != nil {
log.Printf("RPC call to GetChannelMembersForUser API failed: %s", err.Error())
@@ -2692,7 +2692,7 @@ func (g *apiRPCClient) GetChannelMembersForUser(teamId, userId string, page, per
func (s *apiRPCServer) GetChannelMembersForUser(args *Z_GetChannelMembersForUserArgs, returns *Z_GetChannelMembersForUserReturns) error {
if hook, ok := s.impl.(interface {
GetChannelMembersForUser(teamId, userId string, page, perPage int) ([]*model.ChannelMember, *model.AppError)
GetChannelMembersForUser(teamID, userID string, page, perPage int) ([]*model.ChannelMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetChannelMembersForUser(args.A, args.B, args.C, args.D)
} else {
@@ -2712,8 +2712,8 @@ type Z_UpdateChannelMemberRolesReturns struct {
B *model.AppError
}
func (g *apiRPCClient) UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError) {
_args := &Z_UpdateChannelMemberRolesArgs{channelId, userId, newRoles}
func (g *apiRPCClient) UpdateChannelMemberRoles(channelId, userID, newRoles string) (*model.ChannelMember, *model.AppError) {
_args := &Z_UpdateChannelMemberRolesArgs{channelId, userID, newRoles}
_returns := &Z_UpdateChannelMemberRolesReturns{}
if err := g.client.Call("Plugin.UpdateChannelMemberRoles", _args, _returns); err != nil {
log.Printf("RPC call to UpdateChannelMemberRoles API failed: %s", err.Error())
@@ -2723,7 +2723,7 @@ func (g *apiRPCClient) UpdateChannelMemberRoles(channelId, userId, newRoles stri
func (s *apiRPCServer) UpdateChannelMemberRoles(args *Z_UpdateChannelMemberRolesArgs, returns *Z_UpdateChannelMemberRolesReturns) error {
if hook, ok := s.impl.(interface {
UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError)
UpdateChannelMemberRoles(channelId, userID, newRoles string) (*model.ChannelMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.UpdateChannelMemberRoles(args.A, args.B, args.C)
} else {
@@ -2743,8 +2743,8 @@ type Z_UpdateChannelMemberNotificationsReturns struct {
B *model.AppError
}
func (g *apiRPCClient) UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
_args := &Z_UpdateChannelMemberNotificationsArgs{channelId, userId, notifications}
func (g *apiRPCClient) UpdateChannelMemberNotifications(channelId, userID string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
_args := &Z_UpdateChannelMemberNotificationsArgs{channelId, userID, notifications}
_returns := &Z_UpdateChannelMemberNotificationsReturns{}
if err := g.client.Call("Plugin.UpdateChannelMemberNotifications", _args, _returns); err != nil {
log.Printf("RPC call to UpdateChannelMemberNotifications API failed: %s", err.Error())
@@ -2754,7 +2754,7 @@ func (g *apiRPCClient) UpdateChannelMemberNotifications(channelId, userId string
func (s *apiRPCServer) UpdateChannelMemberNotifications(args *Z_UpdateChannelMemberNotificationsArgs, returns *Z_UpdateChannelMemberNotificationsReturns) error {
if hook, ok := s.impl.(interface {
UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError)
UpdateChannelMemberNotifications(channelId, userID string, notifications map[string]string) (*model.ChannelMember, *model.AppError)
}); ok {
returns.A, returns.B = hook.UpdateChannelMemberNotifications(args.A, args.B, args.C)
} else {
@@ -2890,8 +2890,8 @@ type Z_GetGroupsForUserReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetGroupsForUser(userId string) ([]*model.Group, *model.AppError) {
_args := &Z_GetGroupsForUserArgs{userId}
func (g *apiRPCClient) GetGroupsForUser(userID string) ([]*model.Group, *model.AppError) {
_args := &Z_GetGroupsForUserArgs{userID}
_returns := &Z_GetGroupsForUserReturns{}
if err := g.client.Call("Plugin.GetGroupsForUser", _args, _returns); err != nil {
log.Printf("RPC call to GetGroupsForUser API failed: %s", err.Error())
@@ -2901,7 +2901,7 @@ func (g *apiRPCClient) GetGroupsForUser(userId string) ([]*model.Group, *model.A
func (s *apiRPCServer) GetGroupsForUser(args *Z_GetGroupsForUserArgs, returns *Z_GetGroupsForUserReturns) error {
if hook, ok := s.impl.(interface {
GetGroupsForUser(userId string) ([]*model.Group, *model.AppError)
GetGroupsForUser(userID string) ([]*model.Group, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetGroupsForUser(args.A)
} else {
@@ -2919,8 +2919,8 @@ type Z_DeleteChannelMemberReturns struct {
A *model.AppError
}
func (g *apiRPCClient) DeleteChannelMember(channelId, userId string) *model.AppError {
_args := &Z_DeleteChannelMemberArgs{channelId, userId}
func (g *apiRPCClient) DeleteChannelMember(channelId, userID string) *model.AppError {
_args := &Z_DeleteChannelMemberArgs{channelId, userID}
_returns := &Z_DeleteChannelMemberReturns{}
if err := g.client.Call("Plugin.DeleteChannelMember", _args, _returns); err != nil {
log.Printf("RPC call to DeleteChannelMember API failed: %s", err.Error())
@@ -2930,7 +2930,7 @@ func (g *apiRPCClient) DeleteChannelMember(channelId, userId string) *model.AppE
func (s *apiRPCServer) DeleteChannelMember(args *Z_DeleteChannelMemberArgs, returns *Z_DeleteChannelMemberReturns) error {
if hook, ok := s.impl.(interface {
DeleteChannelMember(channelId, userId string) *model.AppError
DeleteChannelMember(channelId, userID string) *model.AppError
}); ok {
returns.A = hook.DeleteChannelMember(args.A, args.B)
} else {
@@ -3063,8 +3063,8 @@ type Z_SendEphemeralPostReturns struct {
A *model.Post
}
func (g *apiRPCClient) SendEphemeralPost(userId string, post *model.Post) *model.Post {
_args := &Z_SendEphemeralPostArgs{userId, post}
func (g *apiRPCClient) SendEphemeralPost(userID string, post *model.Post) *model.Post {
_args := &Z_SendEphemeralPostArgs{userID, post}
_returns := &Z_SendEphemeralPostReturns{}
if err := g.client.Call("Plugin.SendEphemeralPost", _args, _returns); err != nil {
log.Printf("RPC call to SendEphemeralPost API failed: %s", err.Error())
@@ -3074,7 +3074,7 @@ func (g *apiRPCClient) SendEphemeralPost(userId string, post *model.Post) *model
func (s *apiRPCServer) SendEphemeralPost(args *Z_SendEphemeralPostArgs, returns *Z_SendEphemeralPostReturns) error {
if hook, ok := s.impl.(interface {
SendEphemeralPost(userId string, post *model.Post) *model.Post
SendEphemeralPost(userID string, post *model.Post) *model.Post
}); ok {
returns.A = hook.SendEphemeralPost(args.A, args.B)
} else {
@@ -3092,8 +3092,8 @@ type Z_UpdateEphemeralPostReturns struct {
A *model.Post
}
func (g *apiRPCClient) UpdateEphemeralPost(userId string, post *model.Post) *model.Post {
_args := &Z_UpdateEphemeralPostArgs{userId, post}
func (g *apiRPCClient) UpdateEphemeralPost(userID string, post *model.Post) *model.Post {
_args := &Z_UpdateEphemeralPostArgs{userID, post}
_returns := &Z_UpdateEphemeralPostReturns{}
if err := g.client.Call("Plugin.UpdateEphemeralPost", _args, _returns); err != nil {
log.Printf("RPC call to UpdateEphemeralPost API failed: %s", err.Error())
@@ -3103,7 +3103,7 @@ func (g *apiRPCClient) UpdateEphemeralPost(userId string, post *model.Post) *mod
func (s *apiRPCServer) UpdateEphemeralPost(args *Z_UpdateEphemeralPostArgs, returns *Z_UpdateEphemeralPostReturns) error {
if hook, ok := s.impl.(interface {
UpdateEphemeralPost(userId string, post *model.Post) *model.Post
UpdateEphemeralPost(userID string, post *model.Post) *model.Post
}); ok {
returns.A = hook.UpdateEphemeralPost(args.A, args.B)
} else {
@@ -3120,8 +3120,8 @@ type Z_DeleteEphemeralPostArgs struct {
type Z_DeleteEphemeralPostReturns struct {
}
func (g *apiRPCClient) DeleteEphemeralPost(userId, postId string) {
_args := &Z_DeleteEphemeralPostArgs{userId, postId}
func (g *apiRPCClient) DeleteEphemeralPost(userID, postId string) {
_args := &Z_DeleteEphemeralPostArgs{userID, postId}
_returns := &Z_DeleteEphemeralPostReturns{}
if err := g.client.Call("Plugin.DeleteEphemeralPost", _args, _returns); err != nil {
log.Printf("RPC call to DeleteEphemeralPost API failed: %s", err.Error())
@@ -3131,7 +3131,7 @@ func (g *apiRPCClient) DeleteEphemeralPost(userId, postId string) {
func (s *apiRPCServer) DeleteEphemeralPost(args *Z_DeleteEphemeralPostArgs, returns *Z_DeleteEphemeralPostReturns) error {
if hook, ok := s.impl.(interface {
DeleteEphemeralPost(userId, postId string)
DeleteEphemeralPost(userID, postId string)
}); ok {
hook.DeleteEphemeralPost(args.A, args.B)
} else {
@@ -3360,8 +3360,8 @@ type Z_GetTeamStatsReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetTeamStats(teamId string) (*model.TeamStats, *model.AppError) {
_args := &Z_GetTeamStatsArgs{teamId}
func (g *apiRPCClient) GetTeamStats(teamID string) (*model.TeamStats, *model.AppError) {
_args := &Z_GetTeamStatsArgs{teamID}
_returns := &Z_GetTeamStatsReturns{}
if err := g.client.Call("Plugin.GetTeamStats", _args, _returns); err != nil {
log.Printf("RPC call to GetTeamStats API failed: %s", err.Error())
@@ -3371,7 +3371,7 @@ func (g *apiRPCClient) GetTeamStats(teamId string) (*model.TeamStats, *model.App
func (s *apiRPCServer) GetTeamStats(args *Z_GetTeamStatsArgs, returns *Z_GetTeamStatsReturns) error {
if hook, ok := s.impl.(interface {
GetTeamStats(teamId string) (*model.TeamStats, *model.AppError)
GetTeamStats(teamID string) (*model.TeamStats, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetTeamStats(args.A)
} else {
@@ -3418,8 +3418,8 @@ type Z_GetProfileImageReturns struct {
B *model.AppError
}
func (g *apiRPCClient) GetProfileImage(userId string) ([]byte, *model.AppError) {
_args := &Z_GetProfileImageArgs{userId}
func (g *apiRPCClient) GetProfileImage(userID string) ([]byte, *model.AppError) {
_args := &Z_GetProfileImageArgs{userID}
_returns := &Z_GetProfileImageReturns{}
if err := g.client.Call("Plugin.GetProfileImage", _args, _returns); err != nil {
log.Printf("RPC call to GetProfileImage API failed: %s", err.Error())
@@ -3429,7 +3429,7 @@ func (g *apiRPCClient) GetProfileImage(userId string) ([]byte, *model.AppError)
func (s *apiRPCServer) GetProfileImage(args *Z_GetProfileImageArgs, returns *Z_GetProfileImageReturns) error {
if hook, ok := s.impl.(interface {
GetProfileImage(userId string) ([]byte, *model.AppError)
GetProfileImage(userID string) ([]byte, *model.AppError)
}); ok {
returns.A, returns.B = hook.GetProfileImage(args.A)
} else {
@@ -3447,8 +3447,8 @@ type Z_SetProfileImageReturns struct {
A *model.AppError
}
func (g *apiRPCClient) SetProfileImage(userId string, data []byte) *model.AppError {
_args := &Z_SetProfileImageArgs{userId, data}
func (g *apiRPCClient) SetProfileImage(userID string, data []byte) *model.AppError {
_args := &Z_SetProfileImageArgs{userID, data}
_returns := &Z_SetProfileImageReturns{}
if err := g.client.Call("Plugin.SetProfileImage", _args, _returns); err != nil {
log.Printf("RPC call to SetProfileImage API failed: %s", err.Error())
@@ -3458,7 +3458,7 @@ func (g *apiRPCClient) SetProfileImage(userId string, data []byte) *model.AppErr
func (s *apiRPCServer) SetProfileImage(args *Z_SetProfileImageArgs, returns *Z_SetProfileImageReturns) error {
if hook, ok := s.impl.(interface {
SetProfileImage(userId string, data []byte) *model.AppError
SetProfileImage(userID string, data []byte) *model.AppError
}); ok {
returns.A = hook.SetProfileImage(args.A, args.B)
} else {
@@ -3566,8 +3566,8 @@ type Z_CopyFileInfosReturns struct {
B *model.AppError
}
func (g *apiRPCClient) CopyFileInfos(userId string, fileIds []string) ([]string, *model.AppError) {
_args := &Z_CopyFileInfosArgs{userId, fileIds}
func (g *apiRPCClient) CopyFileInfos(userID string, fileIds []string) ([]string, *model.AppError) {
_args := &Z_CopyFileInfosArgs{userID, fileIds}
_returns := &Z_CopyFileInfosReturns{}
if err := g.client.Call("Plugin.CopyFileInfos", _args, _returns); err != nil {
log.Printf("RPC call to CopyFileInfos API failed: %s", err.Error())
@@ -3577,7 +3577,7 @@ func (g *apiRPCClient) CopyFileInfos(userId string, fileIds []string) ([]string,
func (s *apiRPCServer) CopyFileInfos(args *Z_CopyFileInfosArgs, returns *Z_CopyFileInfosReturns) error {
if hook, ok := s.impl.(interface {
CopyFileInfos(userId string, fileIds []string) ([]string, *model.AppError)
CopyFileInfos(userID string, fileIds []string) ([]string, *model.AppError)
}); ok {
returns.A, returns.B = hook.CopyFileInfos(args.A, args.B)
} else {
@@ -4266,8 +4266,8 @@ type Z_HasPermissionToReturns struct {
A bool
}
func (g *apiRPCClient) HasPermissionTo(userId string, permission *model.Permission) bool {
_args := &Z_HasPermissionToArgs{userId, permission}
func (g *apiRPCClient) HasPermissionTo(userID string, permission *model.Permission) bool {
_args := &Z_HasPermissionToArgs{userID, permission}
_returns := &Z_HasPermissionToReturns{}
if err := g.client.Call("Plugin.HasPermissionTo", _args, _returns); err != nil {
log.Printf("RPC call to HasPermissionTo API failed: %s", err.Error())
@@ -4277,7 +4277,7 @@ func (g *apiRPCClient) HasPermissionTo(userId string, permission *model.Permissi
func (s *apiRPCServer) HasPermissionTo(args *Z_HasPermissionToArgs, returns *Z_HasPermissionToReturns) error {
if hook, ok := s.impl.(interface {
HasPermissionTo(userId string, permission *model.Permission) bool
HasPermissionTo(userID string, permission *model.Permission) bool
}); ok {
returns.A = hook.HasPermissionTo(args.A, args.B)
} else {
@@ -4296,8 +4296,8 @@ type Z_HasPermissionToTeamReturns struct {
A bool
}
func (g *apiRPCClient) HasPermissionToTeam(userId, teamId string, permission *model.Permission) bool {
_args := &Z_HasPermissionToTeamArgs{userId, teamId, permission}
func (g *apiRPCClient) HasPermissionToTeam(userID, teamID string, permission *model.Permission) bool {
_args := &Z_HasPermissionToTeamArgs{userID, teamID, permission}
_returns := &Z_HasPermissionToTeamReturns{}
if err := g.client.Call("Plugin.HasPermissionToTeam", _args, _returns); err != nil {
log.Printf("RPC call to HasPermissionToTeam API failed: %s", err.Error())
@@ -4307,7 +4307,7 @@ func (g *apiRPCClient) HasPermissionToTeam(userId, teamId string, permission *mo
func (s *apiRPCServer) HasPermissionToTeam(args *Z_HasPermissionToTeamArgs, returns *Z_HasPermissionToTeamReturns) error {
if hook, ok := s.impl.(interface {
HasPermissionToTeam(userId, teamId string, permission *model.Permission) bool
HasPermissionToTeam(userID, teamID string, permission *model.Permission) bool
}); ok {
returns.A = hook.HasPermissionToTeam(args.A, args.B, args.C)
} else {
@@ -4326,8 +4326,8 @@ type Z_HasPermissionToChannelReturns struct {
A bool
}
func (g *apiRPCClient) HasPermissionToChannel(userId, channelId string, permission *model.Permission) bool {
_args := &Z_HasPermissionToChannelArgs{userId, channelId, permission}
func (g *apiRPCClient) HasPermissionToChannel(userID, channelId string, permission *model.Permission) bool {
_args := &Z_HasPermissionToChannelArgs{userID, channelId, permission}
_returns := &Z_HasPermissionToChannelReturns{}
if err := g.client.Call("Plugin.HasPermissionToChannel", _args, _returns); err != nil {
log.Printf("RPC call to HasPermissionToChannel API failed: %s", err.Error())
@@ -4337,7 +4337,7 @@ func (g *apiRPCClient) HasPermissionToChannel(userId, channelId string, permissi
func (s *apiRPCServer) HasPermissionToChannel(args *Z_HasPermissionToChannelArgs, returns *Z_HasPermissionToChannelReturns) error {
if hook, ok := s.impl.(interface {
HasPermissionToChannel(userId, channelId string, permission *model.Permission) bool
HasPermissionToChannel(userID, channelId string, permission *model.Permission) bool
}); ok {
returns.A = hook.HasPermissionToChannel(args.A, args.B, args.C)
} else {
@@ -4648,8 +4648,8 @@ type Z_PublishUserTypingReturns struct {
A *model.AppError
}
func (g *apiRPCClient) PublishUserTyping(userId, channelId, parentId string) *model.AppError {
_args := &Z_PublishUserTypingArgs{userId, channelId, parentId}
func (g *apiRPCClient) PublishUserTyping(userID, channelId, parentId string) *model.AppError {
_args := &Z_PublishUserTypingArgs{userID, channelId, parentId}
_returns := &Z_PublishUserTypingReturns{}
if err := g.client.Call("Plugin.PublishUserTyping", _args, _returns); err != nil {
log.Printf("RPC call to PublishUserTyping API failed: %s", err.Error())
@@ -4659,7 +4659,7 @@ func (g *apiRPCClient) PublishUserTyping(userId, channelId, parentId string) *mo
func (s *apiRPCServer) PublishUserTyping(args *Z_PublishUserTypingArgs, returns *Z_PublishUserTypingReturns) error {
if hook, ok := s.impl.(interface {
PublishUserTyping(userId, channelId, parentId string) *model.AppError
PublishUserTyping(userID, channelId, parentId string) *model.AppError
}); ok {
returns.A = hook.PublishUserTyping(args.A, args.B, args.C)
} else {

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

Разница между файлами не показана из-за своего большого размера Загрузить разницу

18
store/opentracinglayer/opentracinglayer.go
Просмотреть файл

@@ -5448,6 +5448,24 @@ func (s *OpenTracingLayerPostStore) GetSingle(id string, inclDeleted bool) (*mod
return result, err
}
func (s *OpenTracingLayerPostStore) HasAutoResponsePostByUserSince(options model.GetPostsSinceOptions, userId string) (bool, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.HasAutoResponsePostByUserSince")
s.Root.Store.SetContext(newCtx)
defer func() {
s.Root.Store.SetContext(origCtx)
}()
defer span.Finish()
result, err := s.PostStore.HasAutoResponsePostByUserSince(options, userId)
if err != nil {
span.LogFields(spanlog.Error(err))
ext.Error.Set(span, true)
}
return result, err
}
func (s *OpenTracingLayerPostStore) InvalidateLastPostTimeCache(channelID string) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.InvalidateLastPostTimeCache")

20
store/retrylayer/retrylayer.go
Просмотреть файл

@@ -5884,6 +5884,26 @@ func (s *RetryLayerPostStore) GetSingle(id string, inclDeleted bool) (*model.Pos
}
func (s *RetryLayerPostStore) HasAutoResponsePostByUserSince(options model.GetPostsSinceOptions, userId string) (bool, error) {
tries := 0
for {
result, err := s.PostStore.HasAutoResponsePostByUserSince(options, userId)
if err == nil {
return result, nil
}
if !isRepeatableError(err) {
return result, err
}
tries++
if tries >= 3 {
err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
return result, err
}
}
}
func (s *RetryLayerPostStore) InvalidateLastPostTimeCache(channelID string) {
s.PostStore.InvalidateLastPostTimeCache(channelID)

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

@@ -11,6 +11,7 @@ import (
"strconv"
"strings"
"sync"
"time"
sq "github.com/Masterminds/squirrel"
"github.com/mattermost/gorp"
@@ -958,6 +959,36 @@ func (s *SqlPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFr
return list, nil
}
func (s *SqlPostStore) HasAutoResponsePostByUserSince(options model.GetPostsSinceOptions, userId string) (bool, error) {
query := `
SELECT 1
FROM
Posts
WHERE
UpdateAt >= :Time
AND
ChannelId = :ChannelId
AND
UserId = :UserId
AND
Type = :Type
LIMIT 1`
exist, err := s.GetReplica().SelectInt(query, map[string]interface{}{
"ChannelId": options.ChannelId,
"Time": options.Time,
"UserId": userId,
"Type": model.POST_AUTO_RESPONDER,
})
if err != nil {
return false, errors.Wrapf(err,
"failed to check if autoresponse posts in channelId=%s for userId=%s since %s", options.ChannelId, userId, time.Unix(options.Time, 0).Format(time.RFC3339))
}
return exist > 0, nil
}
func (s *SqlPostStore) GetPostsSinceForSync(options model.GetPostsSinceForSyncOptions, _ /* allowFromCache */ bool) ([]*model.Post, error) {
if options.Limit < 0 || options.Limit > 1000 {
return nil, store.NewErrInvalidInput("Post", "<options.Limit>", options.Limit)

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

@@ -334,6 +334,7 @@ type PostStore interface {
GetDirectPostParentsForExportAfter(limit int, afterID string) ([]*model.DirectPostForExport, error)
SearchPostsInTeamForUser(paramsList []*model.SearchParams, userID, teamID string, page, perPage int) (*model.PostSearchResults, error)
GetOldestEntityCreationTime() (int64, error)
HasAutoResponsePostByUserSince(options model.GetPostsSinceOptions, userId string) (bool, error)
GetPostsSinceForSync(options model.GetPostsSinceForSyncOptions, allowFromCache bool) ([]*model.Post, error)
}

21
store/storetest/mocks/PostStore.go
Просмотреть файл

@@ -607,6 +607,27 @@ func (_m *PostStore) GetSingle(id string, inclDeleted bool) (*model.Post, error)
return r0, r1
}
// HasAutoResponsePostByUserSince provides a mock function with given fields: options, userId
func (_m *PostStore) HasAutoResponsePostByUserSince(options model.GetPostsSinceOptions, userId string) (bool, error) {
ret := _m.Called(options, userId)
var r0 bool
if rf, ok := ret.Get(0).(func(model.GetPostsSinceOptions, string) bool); ok {
r0 = rf(options, userId)
} else {
r0 = ret.Get(0).(bool)
}
var r1 error
if rf, ok := ret.Get(1).(func(model.GetPostsSinceOptions, string) error); ok {
r1 = rf(options, userId)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// InvalidateLastPostTimeCache provides a mock function with given fields: channelID
func (_m *PostStore) InvalidateLastPostTimeCache(channelID string) {
_m.Called(channelID)

45
store/storetest/post_store.go
Просмотреть файл

@@ -56,7 +56,7 @@ func TestPostStore(t *testing.T, ss store.Store, s SqlStore) {
t.Run("GetDirectPostParentsForExportAfterDeleted", func(t *testing.T) { testPostStoreGetDirectPostParentsForExportAfterDeleted(t, ss, s) })
t.Run("GetDirectPostParentsForExportAfterBatched", func(t *testing.T) { testPostStoreGetDirectPostParentsForExportAfterBatched(t, ss, s) })
t.Run("GetForThread", func(t *testing.T) { testPostStoreGetForThread(t, ss) })
t.Run("HasAutoResponsePostByUserSince", func(t *testing.T) { testHasAutoResponsePostByUserSince(t, ss) })
}
func testPostStoreSave(t *testing.T, ss store.Store) {
@@ -2970,3 +2970,46 @@ func testPostStoreGetDirectPostParentsForExportAfterBatched(t *testing.T, ss sto
// Manually truncate Channels table until testlib can handle cleanups
s.GetMaster().Exec("TRUNCATE Channels")
}
func testHasAutoResponsePostByUserSince(t *testing.T, ss store.Store) {
t.Run("should return posts created after the given time", func(t *testing.T) {
channelId := model.NewId()
userId := model.NewId()
_, err := ss.Post().Save(&model.Post{
ChannelId: channelId,
UserId: userId,
Message: "message",
})
require.NoError(t, err)
time.Sleep(time.Millisecond)
post2, err := ss.Post().Save(&model.Post{
ChannelId: channelId,
UserId: userId,
Message: "message",
})
require.NoError(t, err)
time.Sleep(time.Millisecond)
post3, err := ss.Post().Save(&model.Post{
ChannelId: channelId,
UserId: userId,
Message: "auto response message",
Type: model.POST_AUTO_RESPONDER,
})
require.NoError(t, err)
time.Sleep(time.Millisecond)
exists, err := ss.Post().HasAutoResponsePostByUserSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post2.CreateAt}, userId)
require.NoError(t, err)
assert.True(t, exists)
err = ss.Post().Delete(post3.Id, time.Now().Unix(), userId)
require.NoError(t, err)
exists, err = ss.Post().HasAutoResponsePostByUserSince(model.GetPostsSinceOptions{ChannelId: channelId, Time: post2.CreateAt}, userId)
require.NoError(t, err)
assert.False(t, exists)
})
}

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

@@ -7,6 +7,7 @@ import (
"github.com/mattermost/mattermost-server/v5/model"
)
// This function has a copy of it in app/helper_test
// NewTestId is used for testing as a replacement for model.NewId(). It is a [A-Z0-9] string 26
// characters long. It replaces every odd character with a digit.
func NewTestId() string {

16
store/timerlayer/timerlayer.go
Просмотреть файл

@@ -4938,6 +4938,22 @@ func (s *TimerLayerPostStore) GetSingle(id string, inclDeleted bool) (*model.Pos
return result, err
}
func (s *TimerLayerPostStore) HasAutoResponsePostByUserSince(options model.GetPostsSinceOptions, userId string) (bool, error) {
start := timemodule.Now()
result, err := s.PostStore.HasAutoResponsePostByUserSince(options, userId)
elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
if s.Root.Metrics != nil {
success := "false"
if err == nil {
success = "true"
}
s.Root.Metrics.ObserveStoreMethodDuration("PostStore.HasAutoResponsePostByUserSince", success, elapsed)
}
return result, err
}
func (s *TimerLayerPostStore) InvalidateLastPostTimeCache(channelID string) {
start := timemodule.Now()