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

MM-63285: Add property field methods to plugin API (#31035)

Просмотр исходного кода 
Co-authored-by: Claude <noreply@anthropic.com>
Этот коммит содержится в:
Julien Tant
2025-06-10 16:10:28 -07:00
коммит произвёл GitHub
родитель 81856f9e7d
Коммит 731bd7c414
13 изменённых файлов: 2675 добавлений и 0 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@@ -1411,6 +1411,132 @@ type API interface {
// @tag Group
// Minimum server version: 10.9
DeleteGroupConstrainedMemberships() *model.AppError
// CreatePropertyField creates a new property field.
//
// @tag PropertyField
// Minimum server version: 10.10
CreatePropertyField(field *model.PropertyField) (*model.PropertyField, error)
// GetPropertyField gets a property field by groupID and fieldID.
//
// @tag PropertyField
// Minimum server version: 10.10
GetPropertyField(groupID, fieldID string) (*model.PropertyField, error)
// GetPropertyFields gets multiple property fields by groupID and a list of IDs.
//
// @tag PropertyField
// Minimum server version: 10.10
GetPropertyFields(groupID string, ids []string) ([]*model.PropertyField, error)
// UpdatePropertyField updates an existing property field.
//
// @tag PropertyField
// Minimum server version: 10.10
UpdatePropertyField(groupID string, field *model.PropertyField) (*model.PropertyField, error)
// DeletePropertyField deletes a property field (soft delete).
//
// @tag PropertyField
// Minimum server version: 10.10
DeletePropertyField(groupID, fieldID string) error
// SearchPropertyFields searches for property fields with filtering options.
//
// @tag PropertyField
// Minimum server version: 10.10
SearchPropertyFields(groupID, targetID string, opts model.PropertyFieldSearchOpts) ([]*model.PropertyField, error)
// CreatePropertyValue creates a new property value.
//
// @tag PropertyValue
// Minimum server version: 10.10
CreatePropertyValue(value *model.PropertyValue) (*model.PropertyValue, error)
// GetPropertyValue gets a property value by groupID and valueID.
//
// @tag PropertyValue
// Minimum server version: 10.10
GetPropertyValue(groupID, valueID string) (*model.PropertyValue, error)
// GetPropertyValues gets multiple property values by groupID and a list of IDs.
//
// @tag PropertyValue
// Minimum server version: 10.10
GetPropertyValues(groupID string, ids []string) ([]*model.PropertyValue, error)
// UpdatePropertyValue updates an existing property value.
//
// @tag PropertyValue
// Minimum server version: 10.10
UpdatePropertyValue(groupID string, value *model.PropertyValue) (*model.PropertyValue, error)
// UpsertPropertyValue creates a new property value or updates if it already exists.
//
// @tag PropertyValue
// Minimum server version: 10.10
UpsertPropertyValue(value *model.PropertyValue) (*model.PropertyValue, error)
// DeletePropertyValue deletes a property value (soft delete).
//
// @tag PropertyValue
// Minimum server version: 10.10
DeletePropertyValue(groupID, valueID string) error
// SearchPropertyValues searches for property values with filtering options.
//
// @tag PropertyValue
// Minimum server version: 10.10
SearchPropertyValues(groupID, targetID string, opts model.PropertyValueSearchOpts) ([]*model.PropertyValue, error)
// RegisterPropertyGroup registers a new property group.
//
// @tag PropertyGroup
// Minimum server version: 10.10
RegisterPropertyGroup(name string) (*model.PropertyGroup, error)
// GetPropertyGroup gets a property group by name.
//
// @tag PropertyGroup
// Minimum server version: 10.10
GetPropertyGroup(name string) (*model.PropertyGroup, error)
// GetPropertyFieldByName gets a property field by groupID, targetID and name.
//
// @tag PropertyField
// Minimum server version: 10.10
GetPropertyFieldByName(groupID, targetID, name string) (*model.PropertyField, error)
// UpdatePropertyFields updates multiple property fields in a single operation.
//
// @tag PropertyField
// Minimum server version: 10.10
UpdatePropertyFields(groupID string, fields []*model.PropertyField) ([]*model.PropertyField, error)
// UpdatePropertyValues updates multiple property values in a single operation.
//
// @tag PropertyValue
// Minimum server version: 10.10
UpdatePropertyValues(groupID string, values []*model.PropertyValue) ([]*model.PropertyValue, error)
// UpsertPropertyValues creates or updates multiple property values in a single operation.
//
// @tag PropertyValue
// Minimum server version: 10.10
UpsertPropertyValues(values []*model.PropertyValue) ([]*model.PropertyValue, error)
// DeletePropertyValuesForTarget deletes all property values for a specific target.
//
// @tag PropertyValue
// Minimum server version: 10.10
DeletePropertyValuesForTarget(groupID, targetType, targetID string) error
// DeletePropertyValuesForField deletes all property values for a specific field.
//
// @tag PropertyValue
// Minimum server version: 10.10
DeletePropertyValuesForField(groupID, fieldID string) error
}
var handshake = plugin.HandshakeConfig{

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

@@ -1497,3 +1497,150 @@ func (api *apiTimerLayer) DeleteGroupConstrainedMemberships() *model.AppError {
api.recordTime(startTime, "DeleteGroupConstrainedMemberships", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) CreatePropertyField(field *model.PropertyField) (*model.PropertyField, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.CreatePropertyField(field)
api.recordTime(startTime, "CreatePropertyField", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetPropertyField(groupID, fieldID string) (*model.PropertyField, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPropertyField(groupID, fieldID)
api.recordTime(startTime, "GetPropertyField", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetPropertyFields(groupID string, ids []string) ([]*model.PropertyField, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPropertyFields(groupID, ids)
api.recordTime(startTime, "GetPropertyFields", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdatePropertyField(groupID string, field *model.PropertyField) (*model.PropertyField, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdatePropertyField(groupID, field)
api.recordTime(startTime, "UpdatePropertyField", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeletePropertyField(groupID, fieldID string) error {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeletePropertyField(groupID, fieldID)
api.recordTime(startTime, "DeletePropertyField", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) SearchPropertyFields(groupID, targetID string, opts model.PropertyFieldSearchOpts) ([]*model.PropertyField, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.SearchPropertyFields(groupID, targetID, opts)
api.recordTime(startTime, "SearchPropertyFields", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) CreatePropertyValue(value *model.PropertyValue) (*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.CreatePropertyValue(value)
api.recordTime(startTime, "CreatePropertyValue", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetPropertyValue(groupID, valueID string) (*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPropertyValue(groupID, valueID)
api.recordTime(startTime, "GetPropertyValue", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetPropertyValues(groupID string, ids []string) ([]*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPropertyValues(groupID, ids)
api.recordTime(startTime, "GetPropertyValues", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdatePropertyValue(groupID string, value *model.PropertyValue) (*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdatePropertyValue(groupID, value)
api.recordTime(startTime, "UpdatePropertyValue", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpsertPropertyValue(value *model.PropertyValue) (*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpsertPropertyValue(value)
api.recordTime(startTime, "UpsertPropertyValue", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeletePropertyValue(groupID, valueID string) error {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeletePropertyValue(groupID, valueID)
api.recordTime(startTime, "DeletePropertyValue", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) SearchPropertyValues(groupID, targetID string, opts model.PropertyValueSearchOpts) ([]*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.SearchPropertyValues(groupID, targetID, opts)
api.recordTime(startTime, "SearchPropertyValues", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) RegisterPropertyGroup(name string) (*model.PropertyGroup, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.RegisterPropertyGroup(name)
api.recordTime(startTime, "RegisterPropertyGroup", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetPropertyGroup(name string) (*model.PropertyGroup, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPropertyGroup(name)
api.recordTime(startTime, "GetPropertyGroup", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) GetPropertyFieldByName(groupID, targetID, name string) (*model.PropertyField, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.GetPropertyFieldByName(groupID, targetID, name)
api.recordTime(startTime, "GetPropertyFieldByName", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdatePropertyFields(groupID string, fields []*model.PropertyField) ([]*model.PropertyField, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdatePropertyFields(groupID, fields)
api.recordTime(startTime, "UpdatePropertyFields", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpdatePropertyValues(groupID string, values []*model.PropertyValue) ([]*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpdatePropertyValues(groupID, values)
api.recordTime(startTime, "UpdatePropertyValues", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) UpsertPropertyValues(values []*model.PropertyValue) ([]*model.PropertyValue, error) {
startTime := timePkg.Now()
_returnsA, _returnsB := api.apiImpl.UpsertPropertyValues(values)
api.recordTime(startTime, "UpsertPropertyValues", _returnsB == nil)
return _returnsA, _returnsB
}
func (api *apiTimerLayer) DeletePropertyValuesForTarget(groupID, targetType, targetID string) error {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeletePropertyValuesForTarget(groupID, targetType, targetID)
api.recordTime(startTime, "DeletePropertyValuesForTarget", _returnsA == nil)
return _returnsA
}
func (api *apiTimerLayer) DeletePropertyValuesForField(groupID, fieldID string) error {
startTime := timePkg.Now()
_returnsA := api.apiImpl.DeletePropertyValuesForField(groupID, fieldID)
api.recordTime(startTime, "DeletePropertyValuesForField", _returnsA == nil)
return _returnsA
}

1
server/public/plugin/client_rpc.go
Просмотреть файл

@@ -168,6 +168,7 @@ func init() {
gob.Register(&model.AutocompleteStaticListArg{})
gob.Register(&model.AutocompleteTextArg{})
gob.Register(&model.PreviewPost{})
gob.Register(model.PropertyOptions[*model.PluginPropertyOption]{})
}
// These enforce compile time checks to make sure types implement the interface

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

@@ -7168,3 +7168,648 @@ func (s *apiRPCServer) DeleteGroupConstrainedMemberships(args *Z_DeleteGroupCons
}
return nil
}
type Z_CreatePropertyFieldArgs struct {
A *model.PropertyField
}
type Z_CreatePropertyFieldReturns struct {
A *model.PropertyField
B error
}
func (g *apiRPCClient) CreatePropertyField(field *model.PropertyField) (*model.PropertyField, error) {
_args := &Z_CreatePropertyFieldArgs{field}
_returns := &Z_CreatePropertyFieldReturns{}
if err := g.client.Call("Plugin.CreatePropertyField", _args, _returns); err != nil {
log.Printf("RPC call to CreatePropertyField API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) CreatePropertyField(args *Z_CreatePropertyFieldArgs, returns *Z_CreatePropertyFieldReturns) error {
if hook, ok := s.impl.(interface {
CreatePropertyField(field *model.PropertyField) (*model.PropertyField, error)
}); ok {
returns.A, returns.B = hook.CreatePropertyField(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API CreatePropertyField called but not implemented."))
}
return nil
}
type Z_GetPropertyFieldArgs struct {
A string
B string
}
type Z_GetPropertyFieldReturns struct {
A *model.PropertyField
B error
}
func (g *apiRPCClient) GetPropertyField(groupID, fieldID string) (*model.PropertyField, error) {
_args := &Z_GetPropertyFieldArgs{groupID, fieldID}
_returns := &Z_GetPropertyFieldReturns{}
if err := g.client.Call("Plugin.GetPropertyField", _args, _returns); err != nil {
log.Printf("RPC call to GetPropertyField API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) GetPropertyField(args *Z_GetPropertyFieldArgs, returns *Z_GetPropertyFieldReturns) error {
if hook, ok := s.impl.(interface {
GetPropertyField(groupID, fieldID string) (*model.PropertyField, error)
}); ok {
returns.A, returns.B = hook.GetPropertyField(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API GetPropertyField called but not implemented."))
}
return nil
}
type Z_GetPropertyFieldsArgs struct {
A string
B []string
}
type Z_GetPropertyFieldsReturns struct {
A []*model.PropertyField
B error
}
func (g *apiRPCClient) GetPropertyFields(groupID string, ids []string) ([]*model.PropertyField, error) {
_args := &Z_GetPropertyFieldsArgs{groupID, ids}
_returns := &Z_GetPropertyFieldsReturns{}
if err := g.client.Call("Plugin.GetPropertyFields", _args, _returns); err != nil {
log.Printf("RPC call to GetPropertyFields API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) GetPropertyFields(args *Z_GetPropertyFieldsArgs, returns *Z_GetPropertyFieldsReturns) error {
if hook, ok := s.impl.(interface {
GetPropertyFields(groupID string, ids []string) ([]*model.PropertyField, error)
}); ok {
returns.A, returns.B = hook.GetPropertyFields(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API GetPropertyFields called but not implemented."))
}
return nil
}
type Z_UpdatePropertyFieldArgs struct {
A string
B *model.PropertyField
}
type Z_UpdatePropertyFieldReturns struct {
A *model.PropertyField
B error
}
func (g *apiRPCClient) UpdatePropertyField(groupID string, field *model.PropertyField) (*model.PropertyField, error) {
_args := &Z_UpdatePropertyFieldArgs{groupID, field}
_returns := &Z_UpdatePropertyFieldReturns{}
if err := g.client.Call("Plugin.UpdatePropertyField", _args, _returns); err != nil {
log.Printf("RPC call to UpdatePropertyField API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) UpdatePropertyField(args *Z_UpdatePropertyFieldArgs, returns *Z_UpdatePropertyFieldReturns) error {
if hook, ok := s.impl.(interface {
UpdatePropertyField(groupID string, field *model.PropertyField) (*model.PropertyField, error)
}); ok {
returns.A, returns.B = hook.UpdatePropertyField(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API UpdatePropertyField called but not implemented."))
}
return nil
}
type Z_DeletePropertyFieldArgs struct {
A string
B string
}
type Z_DeletePropertyFieldReturns struct {
A error
}
func (g *apiRPCClient) DeletePropertyField(groupID, fieldID string) error {
_args := &Z_DeletePropertyFieldArgs{groupID, fieldID}
_returns := &Z_DeletePropertyFieldReturns{}
if err := g.client.Call("Plugin.DeletePropertyField", _args, _returns); err != nil {
log.Printf("RPC call to DeletePropertyField API failed: %s", err.Error())
}
return _returns.A
}
func (s *apiRPCServer) DeletePropertyField(args *Z_DeletePropertyFieldArgs, returns *Z_DeletePropertyFieldReturns) error {
if hook, ok := s.impl.(interface {
DeletePropertyField(groupID, fieldID string) error
}); ok {
returns.A = hook.DeletePropertyField(args.A, args.B)
returns.A = encodableError(returns.A)
} else {
return encodableError(fmt.Errorf("API DeletePropertyField called but not implemented."))
}
return nil
}
type Z_SearchPropertyFieldsArgs struct {
A string
B string
C model.PropertyFieldSearchOpts
}
type Z_SearchPropertyFieldsReturns struct {
A []*model.PropertyField
B error
}
func (g *apiRPCClient) SearchPropertyFields(groupID, targetID string, opts model.PropertyFieldSearchOpts) ([]*model.PropertyField, error) {
_args := &Z_SearchPropertyFieldsArgs{groupID, targetID, opts}
_returns := &Z_SearchPropertyFieldsReturns{}
if err := g.client.Call("Plugin.SearchPropertyFields", _args, _returns); err != nil {
log.Printf("RPC call to SearchPropertyFields API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) SearchPropertyFields(args *Z_SearchPropertyFieldsArgs, returns *Z_SearchPropertyFieldsReturns) error {
if hook, ok := s.impl.(interface {
SearchPropertyFields(groupID, targetID string, opts model.PropertyFieldSearchOpts) ([]*model.PropertyField, error)
}); ok {
returns.A, returns.B = hook.SearchPropertyFields(args.A, args.B, args.C)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API SearchPropertyFields called but not implemented."))
}
return nil
}
type Z_CreatePropertyValueArgs struct {
A *model.PropertyValue
}
type Z_CreatePropertyValueReturns struct {
A *model.PropertyValue
B error
}
func (g *apiRPCClient) CreatePropertyValue(value *model.PropertyValue) (*model.PropertyValue, error) {
_args := &Z_CreatePropertyValueArgs{value}
_returns := &Z_CreatePropertyValueReturns{}
if err := g.client.Call("Plugin.CreatePropertyValue", _args, _returns); err != nil {
log.Printf("RPC call to CreatePropertyValue API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) CreatePropertyValue(args *Z_CreatePropertyValueArgs, returns *Z_CreatePropertyValueReturns) error {
if hook, ok := s.impl.(interface {
CreatePropertyValue(value *model.PropertyValue) (*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.CreatePropertyValue(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API CreatePropertyValue called but not implemented."))
}
return nil
}
type Z_GetPropertyValueArgs struct {
A string
B string
}
type Z_GetPropertyValueReturns struct {
A *model.PropertyValue
B error
}
func (g *apiRPCClient) GetPropertyValue(groupID, valueID string) (*model.PropertyValue, error) {
_args := &Z_GetPropertyValueArgs{groupID, valueID}
_returns := &Z_GetPropertyValueReturns{}
if err := g.client.Call("Plugin.GetPropertyValue", _args, _returns); err != nil {
log.Printf("RPC call to GetPropertyValue API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) GetPropertyValue(args *Z_GetPropertyValueArgs, returns *Z_GetPropertyValueReturns) error {
if hook, ok := s.impl.(interface {
GetPropertyValue(groupID, valueID string) (*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.GetPropertyValue(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API GetPropertyValue called but not implemented."))
}
return nil
}
type Z_GetPropertyValuesArgs struct {
A string
B []string
}
type Z_GetPropertyValuesReturns struct {
A []*model.PropertyValue
B error
}
func (g *apiRPCClient) GetPropertyValues(groupID string, ids []string) ([]*model.PropertyValue, error) {
_args := &Z_GetPropertyValuesArgs{groupID, ids}
_returns := &Z_GetPropertyValuesReturns{}
if err := g.client.Call("Plugin.GetPropertyValues", _args, _returns); err != nil {
log.Printf("RPC call to GetPropertyValues API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) GetPropertyValues(args *Z_GetPropertyValuesArgs, returns *Z_GetPropertyValuesReturns) error {
if hook, ok := s.impl.(interface {
GetPropertyValues(groupID string, ids []string) ([]*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.GetPropertyValues(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API GetPropertyValues called but not implemented."))
}
return nil
}
type Z_UpdatePropertyValueArgs struct {
A string
B *model.PropertyValue
}
type Z_UpdatePropertyValueReturns struct {
A *model.PropertyValue
B error
}
func (g *apiRPCClient) UpdatePropertyValue(groupID string, value *model.PropertyValue) (*model.PropertyValue, error) {
_args := &Z_UpdatePropertyValueArgs{groupID, value}
_returns := &Z_UpdatePropertyValueReturns{}
if err := g.client.Call("Plugin.UpdatePropertyValue", _args, _returns); err != nil {
log.Printf("RPC call to UpdatePropertyValue API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) UpdatePropertyValue(args *Z_UpdatePropertyValueArgs, returns *Z_UpdatePropertyValueReturns) error {
if hook, ok := s.impl.(interface {
UpdatePropertyValue(groupID string, value *model.PropertyValue) (*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.UpdatePropertyValue(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API UpdatePropertyValue called but not implemented."))
}
return nil
}
type Z_UpsertPropertyValueArgs struct {
A *model.PropertyValue
}
type Z_UpsertPropertyValueReturns struct {
A *model.PropertyValue
B error
}
func (g *apiRPCClient) UpsertPropertyValue(value *model.PropertyValue) (*model.PropertyValue, error) {
_args := &Z_UpsertPropertyValueArgs{value}
_returns := &Z_UpsertPropertyValueReturns{}
if err := g.client.Call("Plugin.UpsertPropertyValue", _args, _returns); err != nil {
log.Printf("RPC call to UpsertPropertyValue API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) UpsertPropertyValue(args *Z_UpsertPropertyValueArgs, returns *Z_UpsertPropertyValueReturns) error {
if hook, ok := s.impl.(interface {
UpsertPropertyValue(value *model.PropertyValue) (*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.UpsertPropertyValue(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API UpsertPropertyValue called but not implemented."))
}
return nil
}
type Z_DeletePropertyValueArgs struct {
A string
B string
}
type Z_DeletePropertyValueReturns struct {
A error
}
func (g *apiRPCClient) DeletePropertyValue(groupID, valueID string) error {
_args := &Z_DeletePropertyValueArgs{groupID, valueID}
_returns := &Z_DeletePropertyValueReturns{}
if err := g.client.Call("Plugin.DeletePropertyValue", _args, _returns); err != nil {
log.Printf("RPC call to DeletePropertyValue API failed: %s", err.Error())
}
return _returns.A
}
func (s *apiRPCServer) DeletePropertyValue(args *Z_DeletePropertyValueArgs, returns *Z_DeletePropertyValueReturns) error {
if hook, ok := s.impl.(interface {
DeletePropertyValue(groupID, valueID string) error
}); ok {
returns.A = hook.DeletePropertyValue(args.A, args.B)
returns.A = encodableError(returns.A)
} else {
return encodableError(fmt.Errorf("API DeletePropertyValue called but not implemented."))
}
return nil
}
type Z_SearchPropertyValuesArgs struct {
A string
B string
C model.PropertyValueSearchOpts
}
type Z_SearchPropertyValuesReturns struct {
A []*model.PropertyValue
B error
}
func (g *apiRPCClient) SearchPropertyValues(groupID, targetID string, opts model.PropertyValueSearchOpts) ([]*model.PropertyValue, error) {
_args := &Z_SearchPropertyValuesArgs{groupID, targetID, opts}
_returns := &Z_SearchPropertyValuesReturns{}
if err := g.client.Call("Plugin.SearchPropertyValues", _args, _returns); err != nil {
log.Printf("RPC call to SearchPropertyValues API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) SearchPropertyValues(args *Z_SearchPropertyValuesArgs, returns *Z_SearchPropertyValuesReturns) error {
if hook, ok := s.impl.(interface {
SearchPropertyValues(groupID, targetID string, opts model.PropertyValueSearchOpts) ([]*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.SearchPropertyValues(args.A, args.B, args.C)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API SearchPropertyValues called but not implemented."))
}
return nil
}
type Z_RegisterPropertyGroupArgs struct {
A string
}
type Z_RegisterPropertyGroupReturns struct {
A *model.PropertyGroup
B error
}
func (g *apiRPCClient) RegisterPropertyGroup(name string) (*model.PropertyGroup, error) {
_args := &Z_RegisterPropertyGroupArgs{name}
_returns := &Z_RegisterPropertyGroupReturns{}
if err := g.client.Call("Plugin.RegisterPropertyGroup", _args, _returns); err != nil {
log.Printf("RPC call to RegisterPropertyGroup API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) RegisterPropertyGroup(args *Z_RegisterPropertyGroupArgs, returns *Z_RegisterPropertyGroupReturns) error {
if hook, ok := s.impl.(interface {
RegisterPropertyGroup(name string) (*model.PropertyGroup, error)
}); ok {
returns.A, returns.B = hook.RegisterPropertyGroup(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API RegisterPropertyGroup called but not implemented."))
}
return nil
}
type Z_GetPropertyGroupArgs struct {
A string
}
type Z_GetPropertyGroupReturns struct {
A *model.PropertyGroup
B error
}
func (g *apiRPCClient) GetPropertyGroup(name string) (*model.PropertyGroup, error) {
_args := &Z_GetPropertyGroupArgs{name}
_returns := &Z_GetPropertyGroupReturns{}
if err := g.client.Call("Plugin.GetPropertyGroup", _args, _returns); err != nil {
log.Printf("RPC call to GetPropertyGroup API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) GetPropertyGroup(args *Z_GetPropertyGroupArgs, returns *Z_GetPropertyGroupReturns) error {
if hook, ok := s.impl.(interface {
GetPropertyGroup(name string) (*model.PropertyGroup, error)
}); ok {
returns.A, returns.B = hook.GetPropertyGroup(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API GetPropertyGroup called but not implemented."))
}
return nil
}
type Z_GetPropertyFieldByNameArgs struct {
A string
B string
C string
}
type Z_GetPropertyFieldByNameReturns struct {
A *model.PropertyField
B error
}
func (g *apiRPCClient) GetPropertyFieldByName(groupID, targetID, name string) (*model.PropertyField, error) {
_args := &Z_GetPropertyFieldByNameArgs{groupID, targetID, name}
_returns := &Z_GetPropertyFieldByNameReturns{}
if err := g.client.Call("Plugin.GetPropertyFieldByName", _args, _returns); err != nil {
log.Printf("RPC call to GetPropertyFieldByName API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) GetPropertyFieldByName(args *Z_GetPropertyFieldByNameArgs, returns *Z_GetPropertyFieldByNameReturns) error {
if hook, ok := s.impl.(interface {
GetPropertyFieldByName(groupID, targetID, name string) (*model.PropertyField, error)
}); ok {
returns.A, returns.B = hook.GetPropertyFieldByName(args.A, args.B, args.C)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API GetPropertyFieldByName called but not implemented."))
}
return nil
}
type Z_UpdatePropertyFieldsArgs struct {
A string
B []*model.PropertyField
}
type Z_UpdatePropertyFieldsReturns struct {
A []*model.PropertyField
B error
}
func (g *apiRPCClient) UpdatePropertyFields(groupID string, fields []*model.PropertyField) ([]*model.PropertyField, error) {
_args := &Z_UpdatePropertyFieldsArgs{groupID, fields}
_returns := &Z_UpdatePropertyFieldsReturns{}
if err := g.client.Call("Plugin.UpdatePropertyFields", _args, _returns); err != nil {
log.Printf("RPC call to UpdatePropertyFields API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) UpdatePropertyFields(args *Z_UpdatePropertyFieldsArgs, returns *Z_UpdatePropertyFieldsReturns) error {
if hook, ok := s.impl.(interface {
UpdatePropertyFields(groupID string, fields []*model.PropertyField) ([]*model.PropertyField, error)
}); ok {
returns.A, returns.B = hook.UpdatePropertyFields(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API UpdatePropertyFields called but not implemented."))
}
return nil
}
type Z_UpdatePropertyValuesArgs struct {
A string
B []*model.PropertyValue
}
type Z_UpdatePropertyValuesReturns struct {
A []*model.PropertyValue
B error
}
func (g *apiRPCClient) UpdatePropertyValues(groupID string, values []*model.PropertyValue) ([]*model.PropertyValue, error) {
_args := &Z_UpdatePropertyValuesArgs{groupID, values}
_returns := &Z_UpdatePropertyValuesReturns{}
if err := g.client.Call("Plugin.UpdatePropertyValues", _args, _returns); err != nil {
log.Printf("RPC call to UpdatePropertyValues API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) UpdatePropertyValues(args *Z_UpdatePropertyValuesArgs, returns *Z_UpdatePropertyValuesReturns) error {
if hook, ok := s.impl.(interface {
UpdatePropertyValues(groupID string, values []*model.PropertyValue) ([]*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.UpdatePropertyValues(args.A, args.B)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API UpdatePropertyValues called but not implemented."))
}
return nil
}
type Z_UpsertPropertyValuesArgs struct {
A []*model.PropertyValue
}
type Z_UpsertPropertyValuesReturns struct {
A []*model.PropertyValue
B error
}
func (g *apiRPCClient) UpsertPropertyValues(values []*model.PropertyValue) ([]*model.PropertyValue, error) {
_args := &Z_UpsertPropertyValuesArgs{values}
_returns := &Z_UpsertPropertyValuesReturns{}
if err := g.client.Call("Plugin.UpsertPropertyValues", _args, _returns); err != nil {
log.Printf("RPC call to UpsertPropertyValues API failed: %s", err.Error())
}
return _returns.A, _returns.B
}
func (s *apiRPCServer) UpsertPropertyValues(args *Z_UpsertPropertyValuesArgs, returns *Z_UpsertPropertyValuesReturns) error {
if hook, ok := s.impl.(interface {
UpsertPropertyValues(values []*model.PropertyValue) ([]*model.PropertyValue, error)
}); ok {
returns.A, returns.B = hook.UpsertPropertyValues(args.A)
returns.B = encodableError(returns.B)
} else {
return encodableError(fmt.Errorf("API UpsertPropertyValues called but not implemented."))
}
return nil
}
type Z_DeletePropertyValuesForTargetArgs struct {
A string
B string
C string
}
type Z_DeletePropertyValuesForTargetReturns struct {
A error
}
func (g *apiRPCClient) DeletePropertyValuesForTarget(groupID, targetType, targetID string) error {
_args := &Z_DeletePropertyValuesForTargetArgs{groupID, targetType, targetID}
_returns := &Z_DeletePropertyValuesForTargetReturns{}
if err := g.client.Call("Plugin.DeletePropertyValuesForTarget", _args, _returns); err != nil {
log.Printf("RPC call to DeletePropertyValuesForTarget API failed: %s", err.Error())
}
return _returns.A
}
func (s *apiRPCServer) DeletePropertyValuesForTarget(args *Z_DeletePropertyValuesForTargetArgs, returns *Z_DeletePropertyValuesForTargetReturns) error {
if hook, ok := s.impl.(interface {
DeletePropertyValuesForTarget(groupID, targetType, targetID string) error
}); ok {
returns.A = hook.DeletePropertyValuesForTarget(args.A, args.B, args.C)
returns.A = encodableError(returns.A)
} else {
return encodableError(fmt.Errorf("API DeletePropertyValuesForTarget called but not implemented."))
}
return nil
}
type Z_DeletePropertyValuesForFieldArgs struct {
A string
B string
}
type Z_DeletePropertyValuesForFieldReturns struct {
A error
}
func (g *apiRPCClient) DeletePropertyValuesForField(groupID, fieldID string) error {
_args := &Z_DeletePropertyValuesForFieldArgs{groupID, fieldID}
_returns := &Z_DeletePropertyValuesForFieldReturns{}
if err := g.client.Call("Plugin.DeletePropertyValuesForField", _args, _returns); err != nil {
log.Printf("RPC call to DeletePropertyValuesForField API failed: %s", err.Error())
}
return _returns.A
}
func (s *apiRPCServer) DeletePropertyValuesForField(args *Z_DeletePropertyValuesForFieldArgs, returns *Z_DeletePropertyValuesForFieldReturns) error {
if hook, ok := s.impl.(interface {
DeletePropertyValuesForField(groupID, fieldID string) error
}); ok {
returns.A = hook.DeletePropertyValuesForField(args.A, args.B)
returns.A = encodableError(returns.A)
} else {
return encodableError(fmt.Errorf("API DeletePropertyValuesForField called but not implemented."))
}
return nil
}

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

@@ -388,6 +388,66 @@ func (_m *API) CreatePost(post *model.Post) (*model.Post, *model.AppError) {
return r0, r1
}
// CreatePropertyField provides a mock function with given fields: field
func (_m *API) CreatePropertyField(field *model.PropertyField) (*model.PropertyField, error) {
ret := _m.Called(field)
if len(ret) == 0 {
panic("no return value specified for CreatePropertyField")
}
var r0 *model.PropertyField
var r1 error
if rf, ok := ret.Get(0).(func(*model.PropertyField) (*model.PropertyField, error)); ok {
return rf(field)
}
if rf, ok := ret.Get(0).(func(*model.PropertyField) *model.PropertyField); ok {
r0 = rf(field)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyField)
}
}
if rf, ok := ret.Get(1).(func(*model.PropertyField) error); ok {
r1 = rf(field)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// CreatePropertyValue provides a mock function with given fields: value
func (_m *API) CreatePropertyValue(value *model.PropertyValue) (*model.PropertyValue, error) {
ret := _m.Called(value)
if len(ret) == 0 {
panic("no return value specified for CreatePropertyValue")
}
var r0 *model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func(*model.PropertyValue) (*model.PropertyValue, error)); ok {
return rf(value)
}
if rf, ok := ret.Get(0).(func(*model.PropertyValue) *model.PropertyValue); ok {
r0 = rf(value)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func(*model.PropertyValue) error); ok {
r1 = rf(value)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// CreateSession provides a mock function with given fields: session
func (_m *API) CreateSession(session *model.Session) (*model.Session, *model.AppError) {
ret := _m.Called(session)
@@ -881,6 +941,78 @@ func (_m *API) DeletePreferencesForUser(userID string, preferences []model.Prefe
return r0
}
// DeletePropertyField provides a mock function with given fields: groupID, fieldID
func (_m *API) DeletePropertyField(groupID string, fieldID string) error {
ret := _m.Called(groupID, fieldID)
if len(ret) == 0 {
panic("no return value specified for DeletePropertyField")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, string) error); ok {
r0 = rf(groupID, fieldID)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeletePropertyValue provides a mock function with given fields: groupID, valueID
func (_m *API) DeletePropertyValue(groupID string, valueID string) error {
ret := _m.Called(groupID, valueID)
if len(ret) == 0 {
panic("no return value specified for DeletePropertyValue")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, string) error); ok {
r0 = rf(groupID, valueID)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeletePropertyValuesForField provides a mock function with given fields: groupID, fieldID
func (_m *API) DeletePropertyValuesForField(groupID string, fieldID string) error {
ret := _m.Called(groupID, fieldID)
if len(ret) == 0 {
panic("no return value specified for DeletePropertyValuesForField")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, string) error); ok {
r0 = rf(groupID, fieldID)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeletePropertyValuesForTarget provides a mock function with given fields: groupID, targetType, targetID
func (_m *API) DeletePropertyValuesForTarget(groupID string, targetType string, targetID string) error {
ret := _m.Called(groupID, targetType, targetID)
if len(ret) == 0 {
panic("no return value specified for DeletePropertyValuesForTarget")
}
var r0 error
if rf, ok := ret.Get(0).(func(string, string, string) error); ok {
r0 = rf(groupID, targetType, targetID)
} else {
r0 = ret.Error(0)
}
return r0
}
// DeleteTeam provides a mock function with given fields: teamID
func (_m *API) DeleteTeam(teamID string) *model.AppError {
ret := _m.Called(teamID)
@@ -2654,6 +2786,186 @@ func (_m *API) GetProfileImage(userID string) ([]byte, *model.AppError) {
return r0, r1
}
// GetPropertyField provides a mock function with given fields: groupID, fieldID
func (_m *API) GetPropertyField(groupID string, fieldID string) (*model.PropertyField, error) {
ret := _m.Called(groupID, fieldID)
if len(ret) == 0 {
panic("no return value specified for GetPropertyField")
}
var r0 *model.PropertyField
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (*model.PropertyField, error)); ok {
return rf(groupID, fieldID)
}
if rf, ok := ret.Get(0).(func(string, string) *model.PropertyField); ok {
r0 = rf(groupID, fieldID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyField)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(groupID, fieldID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPropertyFieldByName provides a mock function with given fields: groupID, targetID, name
func (_m *API) GetPropertyFieldByName(groupID string, targetID string, name string) (*model.PropertyField, error) {
ret := _m.Called(groupID, targetID, name)
if len(ret) == 0 {
panic("no return value specified for GetPropertyFieldByName")
}
var r0 *model.PropertyField
var r1 error
if rf, ok := ret.Get(0).(func(string, string, string) (*model.PropertyField, error)); ok {
return rf(groupID, targetID, name)
}
if rf, ok := ret.Get(0).(func(string, string, string) *model.PropertyField); ok {
r0 = rf(groupID, targetID, name)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyField)
}
}
if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
r1 = rf(groupID, targetID, name)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPropertyFields provides a mock function with given fields: groupID, ids
func (_m *API) GetPropertyFields(groupID string, ids []string) ([]*model.PropertyField, error) {
ret := _m.Called(groupID, ids)
if len(ret) == 0 {
panic("no return value specified for GetPropertyFields")
}
var r0 []*model.PropertyField
var r1 error
if rf, ok := ret.Get(0).(func(string, []string) ([]*model.PropertyField, error)); ok {
return rf(groupID, ids)
}
if rf, ok := ret.Get(0).(func(string, []string) []*model.PropertyField); ok {
r0 = rf(groupID, ids)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.PropertyField)
}
}
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
r1 = rf(groupID, ids)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPropertyGroup provides a mock function with given fields: name
func (_m *API) GetPropertyGroup(name string) (*model.PropertyGroup, error) {
ret := _m.Called(name)
if len(ret) == 0 {
panic("no return value specified for GetPropertyGroup")
}
var r0 *model.PropertyGroup
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.PropertyGroup, error)); ok {
return rf(name)
}
if rf, ok := ret.Get(0).(func(string) *model.PropertyGroup); ok {
r0 = rf(name)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyGroup)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(name)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPropertyValue provides a mock function with given fields: groupID, valueID
func (_m *API) GetPropertyValue(groupID string, valueID string) (*model.PropertyValue, error) {
ret := _m.Called(groupID, valueID)
if len(ret) == 0 {
panic("no return value specified for GetPropertyValue")
}
var r0 *model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func(string, string) (*model.PropertyValue, error)); ok {
return rf(groupID, valueID)
}
if rf, ok := ret.Get(0).(func(string, string) *model.PropertyValue); ok {
r0 = rf(groupID, valueID)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(groupID, valueID)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPropertyValues provides a mock function with given fields: groupID, ids
func (_m *API) GetPropertyValues(groupID string, ids []string) ([]*model.PropertyValue, error) {
ret := _m.Called(groupID, ids)
if len(ret) == 0 {
panic("no return value specified for GetPropertyValues")
}
var r0 []*model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func(string, []string) ([]*model.PropertyValue, error)); ok {
return rf(groupID, ids)
}
if rf, ok := ret.Get(0).(func(string, []string) []*model.PropertyValue); ok {
r0 = rf(groupID, ids)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
r1 = rf(groupID, ids)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPublicChannelsForTeam provides a mock function with given fields: teamID, page, perPage
func (_m *API) GetPublicChannelsForTeam(teamID string, page int, perPage int) ([]*model.Channel, *model.AppError) {
ret := _m.Called(teamID, page, perPage)
@@ -4283,6 +4595,36 @@ func (_m *API) RegisterPluginForSharedChannels(opts model.RegisterPluginOpts) (s
return r0, r1
}
// RegisterPropertyGroup provides a mock function with given fields: name
func (_m *API) RegisterPropertyGroup(name string) (*model.PropertyGroup, error) {
ret := _m.Called(name)
if len(ret) == 0 {
panic("no return value specified for RegisterPropertyGroup")
}
var r0 *model.PropertyGroup
var r1 error
if rf, ok := ret.Get(0).(func(string) (*model.PropertyGroup, error)); ok {
return rf(name)
}
if rf, ok := ret.Get(0).(func(string) *model.PropertyGroup); ok {
r0 = rf(name)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyGroup)
}
}
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(name)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// RemovePlugin provides a mock function with given fields: id
func (_m *API) RemovePlugin(id string) *model.AppError {
ret := _m.Called(id)
@@ -4609,6 +4951,66 @@ func (_m *API) SearchPostsInTeamForUser(teamID string, userID string, searchPara
return r0, r1
}
// SearchPropertyFields provides a mock function with given fields: groupID, targetID, opts
func (_m *API) SearchPropertyFields(groupID string, targetID string, opts model.PropertyFieldSearchOpts) ([]*model.PropertyField, error) {
ret := _m.Called(groupID, targetID, opts)
if len(ret) == 0 {
panic("no return value specified for SearchPropertyFields")
}
var r0 []*model.PropertyField
var r1 error
if rf, ok := ret.Get(0).(func(string, string, model.PropertyFieldSearchOpts) ([]*model.PropertyField, error)); ok {
return rf(groupID, targetID, opts)
}
if rf, ok := ret.Get(0).(func(string, string, model.PropertyFieldSearchOpts) []*model.PropertyField); ok {
r0 = rf(groupID, targetID, opts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.PropertyField)
}
}
if rf, ok := ret.Get(1).(func(string, string, model.PropertyFieldSearchOpts) error); ok {
r1 = rf(groupID, targetID, opts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SearchPropertyValues provides a mock function with given fields: groupID, targetID, opts
func (_m *API) SearchPropertyValues(groupID string, targetID string, opts model.PropertyValueSearchOpts) ([]*model.PropertyValue, error) {
ret := _m.Called(groupID, targetID, opts)
if len(ret) == 0 {
panic("no return value specified for SearchPropertyValues")
}
var r0 []*model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func(string, string, model.PropertyValueSearchOpts) ([]*model.PropertyValue, error)); ok {
return rf(groupID, targetID, opts)
}
if rf, ok := ret.Get(0).(func(string, string, model.PropertyValueSearchOpts) []*model.PropertyValue); ok {
r0 = rf(groupID, targetID, opts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func(string, string, model.PropertyValueSearchOpts) error); ok {
r1 = rf(groupID, targetID, opts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// SearchTeams provides a mock function with given fields: term
func (_m *API) SearchTeams(term string) ([]*model.Team, *model.AppError) {
ret := _m.Called(term)
@@ -5313,6 +5715,126 @@ func (_m *API) UpdatePreferencesForUser(userID string, preferences []model.Prefe
return r0
}
// UpdatePropertyField provides a mock function with given fields: groupID, field
func (_m *API) UpdatePropertyField(groupID string, field *model.PropertyField) (*model.PropertyField, error) {
ret := _m.Called(groupID, field)
if len(ret) == 0 {
panic("no return value specified for UpdatePropertyField")
}
var r0 *model.PropertyField
var r1 error
if rf, ok := ret.Get(0).(func(string, *model.PropertyField) (*model.PropertyField, error)); ok {
return rf(groupID, field)
}
if rf, ok := ret.Get(0).(func(string, *model.PropertyField) *model.PropertyField); ok {
r0 = rf(groupID, field)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyField)
}
}
if rf, ok := ret.Get(1).(func(string, *model.PropertyField) error); ok {
r1 = rf(groupID, field)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdatePropertyFields provides a mock function with given fields: groupID, fields
func (_m *API) UpdatePropertyFields(groupID string, fields []*model.PropertyField) ([]*model.PropertyField, error) {
ret := _m.Called(groupID, fields)
if len(ret) == 0 {
panic("no return value specified for UpdatePropertyFields")
}
var r0 []*model.PropertyField
var r1 error
if rf, ok := ret.Get(0).(func(string, []*model.PropertyField) ([]*model.PropertyField, error)); ok {
return rf(groupID, fields)
}
if rf, ok := ret.Get(0).(func(string, []*model.PropertyField) []*model.PropertyField); ok {
r0 = rf(groupID, fields)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.PropertyField)
}
}
if rf, ok := ret.Get(1).(func(string, []*model.PropertyField) error); ok {
r1 = rf(groupID, fields)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdatePropertyValue provides a mock function with given fields: groupID, value
func (_m *API) UpdatePropertyValue(groupID string, value *model.PropertyValue) (*model.PropertyValue, error) {
ret := _m.Called(groupID, value)
if len(ret) == 0 {
panic("no return value specified for UpdatePropertyValue")
}
var r0 *model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func(string, *model.PropertyValue) (*model.PropertyValue, error)); ok {
return rf(groupID, value)
}
if rf, ok := ret.Get(0).(func(string, *model.PropertyValue) *model.PropertyValue); ok {
r0 = rf(groupID, value)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func(string, *model.PropertyValue) error); ok {
r1 = rf(groupID, value)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdatePropertyValues provides a mock function with given fields: groupID, values
func (_m *API) UpdatePropertyValues(groupID string, values []*model.PropertyValue) ([]*model.PropertyValue, error) {
ret := _m.Called(groupID, values)
if len(ret) == 0 {
panic("no return value specified for UpdatePropertyValues")
}
var r0 []*model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func(string, []*model.PropertyValue) ([]*model.PropertyValue, error)); ok {
return rf(groupID, values)
}
if rf, ok := ret.Get(0).(func(string, []*model.PropertyValue) []*model.PropertyValue); ok {
r0 = rf(groupID, values)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func(string, []*model.PropertyValue) error); ok {
r1 = rf(groupID, values)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpdateSharedChannel provides a mock function with given fields: sc
func (_m *API) UpdateSharedChannel(sc *model.SharedChannel) (*model.SharedChannel, error) {
ret := _m.Called(sc)
@@ -5751,6 +6273,66 @@ func (_m *API) UpsertGroupSyncable(groupSyncable *model.GroupSyncable) (*model.G
return r0, r1
}
// UpsertPropertyValue provides a mock function with given fields: value
func (_m *API) UpsertPropertyValue(value *model.PropertyValue) (*model.PropertyValue, error) {
ret := _m.Called(value)
if len(ret) == 0 {
panic("no return value specified for UpsertPropertyValue")
}
var r0 *model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func(*model.PropertyValue) (*model.PropertyValue, error)); ok {
return rf(value)
}
if rf, ok := ret.Get(0).(func(*model.PropertyValue) *model.PropertyValue); ok {
r0 = rf(value)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func(*model.PropertyValue) error); ok {
r1 = rf(value)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// UpsertPropertyValues provides a mock function with given fields: values
func (_m *API) UpsertPropertyValues(values []*model.PropertyValue) ([]*model.PropertyValue, error) {
ret := _m.Called(values)
if len(ret) == 0 {
panic("no return value specified for UpsertPropertyValues")
}
var r0 []*model.PropertyValue
var r1 error
if rf, ok := ret.Get(0).(func([]*model.PropertyValue) ([]*model.PropertyValue, error)); ok {
return rf(values)
}
if rf, ok := ret.Get(0).(func([]*model.PropertyValue) []*model.PropertyValue); ok {
r0 = rf(values)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]*model.PropertyValue)
}
}
if rf, ok := ret.Get(1).(func([]*model.PropertyValue) error); ok {
r1 = rf(values)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// NewAPI creates a new instance of API. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewAPI(t interface {