116849842b
* add CUD support for channel members via plugins This effectively exposes AddChannelMember, UpdateChannelMemberRoles, UpdateChannelMemberNotifyProps and LeaveChannel via the plugin API. It also modifies the semantics of AddChannelMember to explicitly allow for an empty user requestor, left as such for now via the plugin API. * change the signature of AddChannelMember to accept a channel id instead of a channel
719 строки
22 KiB
Go
719 строки
22 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See License.txt for license information.
|
|
|
|
package rpcplugin
|
|
|
|
import (
|
|
"encoding/gob"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/rpc"
|
|
|
|
"github.com/mattermost/mattermost-server/model"
|
|
"github.com/mattermost/mattermost-server/plugin"
|
|
)
|
|
|
|
type LocalAPI struct {
|
|
api plugin.API
|
|
muxer *Muxer
|
|
}
|
|
|
|
func (api *LocalAPI) LoadPluginConfiguration(args struct{}, reply *[]byte) error {
|
|
var config interface{}
|
|
if err := api.api.LoadPluginConfiguration(&config); err != nil {
|
|
return err
|
|
}
|
|
b, err := json.Marshal(config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*reply = b
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) RegisterCommand(args *model.Command, reply *APITeamReply) error {
|
|
return api.api.RegisterCommand(args)
|
|
}
|
|
|
|
func (api *LocalAPI) UnregisterCommand(args *APIUnregisterCommandArgs, reply *APITeamReply) error {
|
|
return api.api.UnregisterCommand(args.TeamId, args.Trigger)
|
|
}
|
|
|
|
type APIErrorReply struct {
|
|
Error *model.AppError
|
|
}
|
|
|
|
type APITeamReply struct {
|
|
Team *model.Team
|
|
Error *model.AppError
|
|
}
|
|
|
|
func (api *LocalAPI) CreateTeam(args *model.Team, reply *APITeamReply) error {
|
|
team, err := api.api.CreateTeam(args)
|
|
*reply = APITeamReply{
|
|
Team: team,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) DeleteTeam(args string, reply *APIErrorReply) error {
|
|
*reply = APIErrorReply{
|
|
Error: api.api.DeleteTeam(args),
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetTeam(args string, reply *APITeamReply) error {
|
|
team, err := api.api.GetTeam(args)
|
|
*reply = APITeamReply{
|
|
Team: team,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetTeamByName(args string, reply *APITeamReply) error {
|
|
team, err := api.api.GetTeamByName(args)
|
|
*reply = APITeamReply{
|
|
Team: team,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) UpdateTeam(args *model.Team, reply *APITeamReply) error {
|
|
team, err := api.api.UpdateTeam(args)
|
|
*reply = APITeamReply{
|
|
Team: team,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type APIUserReply struct {
|
|
User *model.User
|
|
Error *model.AppError
|
|
}
|
|
|
|
func (api *LocalAPI) CreateUser(args *model.User, reply *APIUserReply) error {
|
|
user, err := api.api.CreateUser(args)
|
|
*reply = APIUserReply{
|
|
User: user,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) DeleteUser(args string, reply *APIErrorReply) error {
|
|
*reply = APIErrorReply{
|
|
Error: api.api.DeleteUser(args),
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetUser(args string, reply *APIUserReply) error {
|
|
user, err := api.api.GetUser(args)
|
|
*reply = APIUserReply{
|
|
User: user,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetUserByEmail(args string, reply *APIUserReply) error {
|
|
user, err := api.api.GetUserByEmail(args)
|
|
*reply = APIUserReply{
|
|
User: user,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetUserByUsername(args string, reply *APIUserReply) error {
|
|
user, err := api.api.GetUserByUsername(args)
|
|
*reply = APIUserReply{
|
|
User: user,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) UpdateUser(args *model.User, reply *APIUserReply) error {
|
|
user, err := api.api.UpdateUser(args)
|
|
*reply = APIUserReply{
|
|
User: user,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type APIGetChannelByNameArgs struct {
|
|
Name string
|
|
TeamId string
|
|
}
|
|
|
|
type APIGetDirectChannelArgs struct {
|
|
UserId1 string
|
|
UserId2 string
|
|
}
|
|
|
|
type APIGetGroupChannelArgs struct {
|
|
UserIds []string
|
|
}
|
|
|
|
type APIAddChannelMemberArgs struct {
|
|
ChannelId string
|
|
UserId string
|
|
}
|
|
|
|
type APIGetChannelMemberArgs struct {
|
|
ChannelId string
|
|
UserId string
|
|
}
|
|
|
|
type APIUpdateChannelMemberRolesArgs struct {
|
|
ChannelId string
|
|
UserId string
|
|
NewRoles string
|
|
}
|
|
|
|
type APIUpdateChannelMemberNotificationsArgs struct {
|
|
ChannelId string
|
|
UserId string
|
|
Notifications map[string]string
|
|
}
|
|
|
|
type APIDeleteChannelMemberArgs struct {
|
|
ChannelId string
|
|
UserId string
|
|
}
|
|
|
|
type APIChannelReply struct {
|
|
Channel *model.Channel
|
|
Error *model.AppError
|
|
}
|
|
|
|
type APIChannelMemberReply struct {
|
|
ChannelMember *model.ChannelMember
|
|
Error *model.AppError
|
|
}
|
|
|
|
func (api *LocalAPI) CreateChannel(args *model.Channel, reply *APIChannelReply) error {
|
|
channel, err := api.api.CreateChannel(args)
|
|
*reply = APIChannelReply{
|
|
Channel: channel,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) DeleteChannel(args string, reply *APIErrorReply) error {
|
|
*reply = APIErrorReply{
|
|
Error: api.api.DeleteChannel(args),
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetChannel(args string, reply *APIChannelReply) error {
|
|
channel, err := api.api.GetChannel(args)
|
|
*reply = APIChannelReply{
|
|
Channel: channel,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetChannelByName(args *APIGetChannelByNameArgs, reply *APIChannelReply) error {
|
|
channel, err := api.api.GetChannelByName(args.Name, args.TeamId)
|
|
*reply = APIChannelReply{
|
|
Channel: channel,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetDirectChannel(args *APIGetDirectChannelArgs, reply *APIChannelReply) error {
|
|
channel, err := api.api.GetDirectChannel(args.UserId1, args.UserId2)
|
|
*reply = APIChannelReply{
|
|
Channel: channel,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetGroupChannel(args *APIGetGroupChannelArgs, reply *APIChannelReply) error {
|
|
channel, err := api.api.GetGroupChannel(args.UserIds)
|
|
*reply = APIChannelReply{
|
|
Channel: channel,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) UpdateChannel(args *model.Channel, reply *APIChannelReply) error {
|
|
channel, err := api.api.UpdateChannel(args)
|
|
*reply = APIChannelReply{
|
|
Channel: channel,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) AddChannelMember(args *APIAddChannelMemberArgs, reply *APIChannelMemberReply) error {
|
|
member, err := api.api.AddChannelMember(args.ChannelId, args.UserId)
|
|
*reply = APIChannelMemberReply{
|
|
ChannelMember: member,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetChannelMember(args *APIGetChannelMemberArgs, reply *APIChannelMemberReply) error {
|
|
member, err := api.api.GetChannelMember(args.ChannelId, args.UserId)
|
|
*reply = APIChannelMemberReply{
|
|
ChannelMember: member,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) UpdateChannelMemberRoles(args *APIUpdateChannelMemberRolesArgs, reply *APIChannelMemberReply) error {
|
|
member, err := api.api.UpdateChannelMemberRoles(args.ChannelId, args.UserId, args.NewRoles)
|
|
*reply = APIChannelMemberReply{
|
|
ChannelMember: member,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) UpdateChannelMemberNotifications(args *APIUpdateChannelMemberNotificationsArgs, reply *APIChannelMemberReply) error {
|
|
member, err := api.api.UpdateChannelMemberNotifications(args.ChannelId, args.UserId, args.Notifications)
|
|
*reply = APIChannelMemberReply{
|
|
ChannelMember: member,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) DeleteChannelMember(args *APIDeleteChannelMemberArgs, reply *APIErrorReply) error {
|
|
err := api.api.DeleteChannelMember(args.ChannelId, args.UserId)
|
|
*reply = APIErrorReply{
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type APIPostReply struct {
|
|
Post *model.Post
|
|
Error *model.AppError
|
|
}
|
|
|
|
func (api *LocalAPI) CreatePost(args *model.Post, reply *APIPostReply) error {
|
|
post, err := api.api.CreatePost(args)
|
|
*reply = APIPostReply{
|
|
Post: post,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) DeletePost(args string, reply *APIErrorReply) error {
|
|
*reply = APIErrorReply{
|
|
Error: api.api.DeletePost(args),
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) GetPost(args string, reply *APIPostReply) error {
|
|
post, err := api.api.GetPost(args)
|
|
*reply = APIPostReply{
|
|
Post: post,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) UpdatePost(args *model.Post, reply *APIPostReply) error {
|
|
post, err := api.api.UpdatePost(args)
|
|
*reply = APIPostReply{
|
|
Post: post,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type APIKeyValueStoreReply struct {
|
|
Value []byte
|
|
Error *model.AppError
|
|
}
|
|
|
|
type APIKeyValueStoreSetArgs struct {
|
|
Key string
|
|
Value []byte
|
|
}
|
|
|
|
func (api *LocalAPI) KeyValueStoreSet(args *APIKeyValueStoreSetArgs, reply *APIErrorReply) error {
|
|
err := api.api.KeyValueStore().Set(args.Key, args.Value)
|
|
*reply = APIErrorReply{
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) KeyValueStoreGet(args string, reply *APIKeyValueStoreReply) error {
|
|
v, err := api.api.KeyValueStore().Get(args)
|
|
*reply = APIKeyValueStoreReply{
|
|
Value: v,
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (api *LocalAPI) KeyValueStoreDelete(args string, reply *APIErrorReply) error {
|
|
err := api.api.KeyValueStore().Delete(args)
|
|
*reply = APIErrorReply{
|
|
Error: err,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ServeAPI(api plugin.API, conn io.ReadWriteCloser, muxer *Muxer) {
|
|
server := rpc.NewServer()
|
|
server.Register(&LocalAPI{
|
|
api: api,
|
|
muxer: muxer,
|
|
})
|
|
server.ServeConn(conn)
|
|
}
|
|
|
|
type RemoteAPI struct {
|
|
client *rpc.Client
|
|
muxer *Muxer
|
|
keyValueStore *RemoteKeyValueStore
|
|
}
|
|
|
|
type RemoteKeyValueStore struct {
|
|
api *RemoteAPI
|
|
}
|
|
|
|
var _ plugin.API = (*RemoteAPI)(nil)
|
|
var _ plugin.KeyValueStore = (*RemoteKeyValueStore)(nil)
|
|
|
|
func (api *RemoteAPI) LoadPluginConfiguration(dest interface{}) error {
|
|
var config []byte
|
|
if err := api.client.Call("LocalAPI.LoadPluginConfiguration", struct{}{}, &config); err != nil {
|
|
return err
|
|
}
|
|
return json.Unmarshal(config, dest)
|
|
}
|
|
|
|
func (api *RemoteAPI) RegisterCommand(command *model.Command) error {
|
|
return api.client.Call("LocalAPI.RegisterCommand", command, nil)
|
|
}
|
|
|
|
type APIUnregisterCommandArgs struct {
|
|
TeamId string
|
|
Trigger string
|
|
}
|
|
|
|
func (api *RemoteAPI) UnregisterCommand(teamId, trigger string) error {
|
|
return api.client.Call("LocalAPI.UnregisterCommand", &APIUnregisterCommandArgs{
|
|
TeamId: teamId,
|
|
Trigger: trigger,
|
|
}, nil)
|
|
}
|
|
|
|
func (api *RemoteAPI) CreateUser(user *model.User) (*model.User, *model.AppError) {
|
|
var reply APIUserReply
|
|
if err := api.client.Call("LocalAPI.CreateUser", user, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.CreateUser", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.User, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) DeleteUser(userId string) *model.AppError {
|
|
var reply APIErrorReply
|
|
if err := api.client.Call("LocalAPI.DeleteUser", userId, &reply); err != nil {
|
|
return model.NewAppError("RemoteAPI.DeleteUser", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetUser(userId string) (*model.User, *model.AppError) {
|
|
var reply APIUserReply
|
|
if err := api.client.Call("LocalAPI.GetUser", userId, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetUser", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.User, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetUserByEmail(email string) (*model.User, *model.AppError) {
|
|
var reply APIUserReply
|
|
if err := api.client.Call("LocalAPI.GetUserByEmail", email, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetUserByEmail", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.User, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetUserByUsername(name string) (*model.User, *model.AppError) {
|
|
var reply APIUserReply
|
|
if err := api.client.Call("LocalAPI.GetUserByUsername", name, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetUserByUsername", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.User, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) UpdateUser(user *model.User) (*model.User, *model.AppError) {
|
|
var reply APIUserReply
|
|
if err := api.client.Call("LocalAPI.UpdateUser", user, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.UpdateUser", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.User, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) CreateTeam(team *model.Team) (*model.Team, *model.AppError) {
|
|
var reply APITeamReply
|
|
if err := api.client.Call("LocalAPI.CreateTeam", team, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.CreateTeam", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Team, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) DeleteTeam(teamId string) *model.AppError {
|
|
var reply APIErrorReply
|
|
if err := api.client.Call("LocalAPI.DeleteTeam", teamId, &reply); err != nil {
|
|
return model.NewAppError("RemoteAPI.DeleteTeam", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetTeam(teamId string) (*model.Team, *model.AppError) {
|
|
var reply APITeamReply
|
|
if err := api.client.Call("LocalAPI.GetTeam", teamId, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetTeam", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Team, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetTeamByName(name string) (*model.Team, *model.AppError) {
|
|
var reply APITeamReply
|
|
if err := api.client.Call("LocalAPI.GetTeamByName", name, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetTeamByName", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Team, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) UpdateTeam(team *model.Team) (*model.Team, *model.AppError) {
|
|
var reply APITeamReply
|
|
if err := api.client.Call("LocalAPI.UpdateTeam", team, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.UpdateTeam", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Team, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) CreateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
|
|
var reply APIChannelReply
|
|
if err := api.client.Call("LocalAPI.CreateChannel", channel, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.CreateChannel", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Channel, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) DeleteChannel(channelId string) *model.AppError {
|
|
var reply APIErrorReply
|
|
if err := api.client.Call("LocalAPI.DeleteChannel", channelId, &reply); err != nil {
|
|
return model.NewAppError("RemoteAPI.DeleteChannel", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetChannel(channelId string) (*model.Channel, *model.AppError) {
|
|
var reply APIChannelReply
|
|
if err := api.client.Call("LocalAPI.GetChannel", channelId, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetChannel", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Channel, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetChannelByName(name, teamId string) (*model.Channel, *model.AppError) {
|
|
var reply APIChannelReply
|
|
if err := api.client.Call("LocalAPI.GetChannelByName", &APIGetChannelByNameArgs{
|
|
Name: name,
|
|
TeamId: teamId,
|
|
}, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetChannelByName", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Channel, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetDirectChannel(userId1, userId2 string) (*model.Channel, *model.AppError) {
|
|
var reply APIChannelReply
|
|
if err := api.client.Call("LocalAPI.GetDirectChannel", &APIGetDirectChannelArgs{
|
|
UserId1: userId1,
|
|
UserId2: userId2,
|
|
}, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetDirectChannel", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Channel, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetGroupChannel(userIds []string) (*model.Channel, *model.AppError) {
|
|
var reply APIChannelReply
|
|
if err := api.client.Call("LocalAPI.GetGroupChannel", &APIGetGroupChannelArgs{
|
|
UserIds: userIds,
|
|
}, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetGroupChannel", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Channel, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) UpdateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
|
|
var reply APIChannelReply
|
|
if err := api.client.Call("LocalAPI.UpdateChannel", channel, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.UpdateChannel", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Channel, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
|
|
var reply APIChannelMemberReply
|
|
if err := api.client.Call("LocalAPI.AddChannelMember", &APIAddChannelMemberArgs{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
}, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.AddChannelMember", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.ChannelMember, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
|
|
var reply APIChannelMemberReply
|
|
if err := api.client.Call("LocalAPI.GetChannelMember", &APIGetChannelMemberArgs{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
}, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetChannelMember", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.ChannelMember, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError) {
|
|
var reply APIChannelMemberReply
|
|
if err := api.client.Call("LocalAPI.UpdateChannelMemberRoles", &APIUpdateChannelMemberRolesArgs{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
NewRoles: newRoles,
|
|
}, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.UpdateChannelMemberRoles", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.ChannelMember, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
|
|
var reply APIChannelMemberReply
|
|
if err := api.client.Call("LocalAPI.UpdateChannelMemberNotifications", &APIUpdateChannelMemberNotificationsArgs{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
Notifications: notifications,
|
|
}, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.UpdateChannelMemberNotifications", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.ChannelMember, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) DeleteChannelMember(channelId, userId string) *model.AppError {
|
|
var reply APIErrorReply
|
|
if err := api.client.Call("LocalAPI.DeleteChannelMember", &APIDeleteChannelMemberArgs{
|
|
ChannelId: channelId,
|
|
UserId: userId,
|
|
}, &reply); err != nil {
|
|
return model.NewAppError("RemoteAPI.DeleteChannelMember", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) CreatePost(post *model.Post) (*model.Post, *model.AppError) {
|
|
var reply APIPostReply
|
|
if err := api.client.Call("LocalAPI.CreatePost", post, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.CreatePost", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Post, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) DeletePost(postId string) *model.AppError {
|
|
var reply APIErrorReply
|
|
if err := api.client.Call("LocalAPI.DeletePost", postId, &reply); err != nil {
|
|
return model.NewAppError("RemoteAPI.DeletePost", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) GetPost(postId string) (*model.Post, *model.AppError) {
|
|
var reply APIPostReply
|
|
if err := api.client.Call("LocalAPI.GetPost", postId, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.GetPost", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Post, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) UpdatePost(post *model.Post) (*model.Post, *model.AppError) {
|
|
var reply APIPostReply
|
|
if err := api.client.Call("LocalAPI.UpdatePost", post, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.UpdatePost", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Post, reply.Error
|
|
}
|
|
|
|
func (api *RemoteAPI) KeyValueStore() plugin.KeyValueStore {
|
|
return api.keyValueStore
|
|
}
|
|
|
|
func (s *RemoteKeyValueStore) Set(key string, value []byte) *model.AppError {
|
|
var reply APIErrorReply
|
|
if err := s.api.client.Call("LocalAPI.KeyValueStoreSet", &APIKeyValueStoreSetArgs{Key: key, Value: value}, &reply); err != nil {
|
|
return model.NewAppError("RemoteAPI.KeyValueStoreSet", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Error
|
|
}
|
|
|
|
func (s *RemoteKeyValueStore) Get(key string) ([]byte, *model.AppError) {
|
|
var reply APIKeyValueStoreReply
|
|
if err := s.api.client.Call("LocalAPI.KeyValueStoreGet", key, &reply); err != nil {
|
|
return nil, model.NewAppError("RemoteAPI.KeyValueStoreGet", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Value, reply.Error
|
|
}
|
|
|
|
func (s *RemoteKeyValueStore) Delete(key string) *model.AppError {
|
|
var reply APIErrorReply
|
|
if err := s.api.client.Call("LocalAPI.KeyValueStoreDelete", key, &reply); err != nil {
|
|
return model.NewAppError("RemoteAPI.KeyValueStoreDelete", "plugin.rpcplugin.invocation.error", nil, "err="+err.Error(), http.StatusInternalServerError)
|
|
}
|
|
return reply.Error
|
|
}
|
|
|
|
func (h *RemoteAPI) Close() error {
|
|
return h.client.Close()
|
|
}
|
|
|
|
func ConnectAPI(conn io.ReadWriteCloser, muxer *Muxer) *RemoteAPI {
|
|
remoteKeyValueStore := &RemoteKeyValueStore{}
|
|
remoteApi := &RemoteAPI{
|
|
client: rpc.NewClient(conn),
|
|
muxer: muxer,
|
|
keyValueStore: remoteKeyValueStore,
|
|
}
|
|
|
|
remoteKeyValueStore.api = remoteApi
|
|
|
|
return remoteApi
|
|
}
|
|
|
|
func init() {
|
|
gob.Register([]*model.SlackAttachment{})
|
|
gob.Register([]interface{}{})
|
|
gob.Register(map[string]interface{}{})
|
|
}
|