mirror of
https://github.com/opencloud-eu/opencloud.git
synced 2026-04-06 00:23:53 -04:00
f144a7cc8b
* add Groupware APIs for creating and deleting addressbooks * add Groupware APIs for creating and deleting calendars * add JMAP APIs for creating and deleting addressbooks, calendars * add JMAP APIs to retrieve Principals * fix API tagging * move addressbook JMAP APIs into its own file * move addressbook Groupware APIs into its own file
269 lines
11 KiB
Go
269 lines
11 KiB
Go
package jmap
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/opencloud-eu/opencloud/pkg/log"
|
|
"github.com/opencloud-eu/opencloud/pkg/structs"
|
|
)
|
|
|
|
var NS_CALENDARS = ns(JmapCalendars)
|
|
|
|
func (j *Client) ParseICalendarBlob(accountId string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string, blobIds []string) (CalendarEventParseResponse, SessionState, State, Language, Error) {
|
|
logger = j.logger("ParseICalendarBlob", session, logger)
|
|
|
|
cmd, err := j.request(session, logger, NS_CALENDARS,
|
|
invocation(CommandCalendarEventParse, CalendarEventParseCommand{AccountId: accountId, BlobIds: blobIds}, "0"),
|
|
)
|
|
if err != nil {
|
|
return CalendarEventParseResponse{}, "", "", "", err
|
|
}
|
|
|
|
return command(j.api, logger, ctx, session, j.onSessionOutdated, cmd, acceptLanguage, func(body *Response) (CalendarEventParseResponse, State, Error) {
|
|
var response CalendarEventParseResponse
|
|
err = retrieveResponseMatchParameters(logger, body, CommandCalendarEventParse, "0", &response)
|
|
if err != nil {
|
|
return CalendarEventParseResponse{}, "", err
|
|
}
|
|
return response, "", nil
|
|
})
|
|
}
|
|
|
|
type CalendarsResponse struct {
|
|
Calendars []Calendar `json:"calendars"`
|
|
NotFound []string `json:"notFound,omitempty"`
|
|
}
|
|
|
|
func (j *Client) GetCalendars(accountId string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string, ids []string) (CalendarsResponse, SessionState, State, Language, Error) {
|
|
return getTemplate(j, "GetCalendars", NS_CALENDARS, CommandCalendarGet,
|
|
func(accountId string, ids []string) CalendarGetCommand {
|
|
return CalendarGetCommand{AccountId: accountId, Ids: ids}
|
|
},
|
|
func(resp CalendarGetResponse) CalendarsResponse {
|
|
return CalendarsResponse{Calendars: resp.List, NotFound: resp.NotFound}
|
|
},
|
|
func(resp CalendarGetResponse) State { return resp.State },
|
|
accountId, session, ctx, logger, acceptLanguage, ids,
|
|
)
|
|
}
|
|
|
|
type CalendarChanges struct {
|
|
HasMoreChanges bool `json:"hasMoreChanges"`
|
|
OldState State `json:"oldState,omitempty"`
|
|
NewState State `json:"newState"`
|
|
Created []Calendar `json:"created,omitempty"`
|
|
Updated []Calendar `json:"updated,omitempty"`
|
|
Destroyed []string `json:"destroyed,omitempty"`
|
|
}
|
|
|
|
// Retrieve Calendar changes since a given state.
|
|
// @apidoc calendar,changes
|
|
func (j *Client) GetCalendarChanges(accountId string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string, sinceState State, maxChanges uint) (CalendarChanges, SessionState, State, Language, Error) {
|
|
return changesTemplate(j, "GetCalendarChanges", NS_CALENDARS,
|
|
CommandCalendarChanges, CommandCalendarGet,
|
|
func() CalendarChangesCommand {
|
|
return CalendarChangesCommand{AccountId: accountId, SinceState: sinceState, MaxChanges: posUIntPtr(maxChanges)}
|
|
},
|
|
func(path string, rof string) CalendarGetRefCommand {
|
|
return CalendarGetRefCommand{
|
|
AccountId: accountId,
|
|
IdsRef: &ResultReference{
|
|
Name: CommandCalendarChanges,
|
|
Path: path,
|
|
ResultOf: rof,
|
|
},
|
|
}
|
|
},
|
|
func(resp CalendarChangesResponse) (State, State, bool, []string) {
|
|
return resp.OldState, resp.NewState, resp.HasMoreChanges, resp.Destroyed
|
|
},
|
|
func(resp CalendarGetResponse) []Calendar { return resp.List },
|
|
func(oldState, newState State, hasMoreChanges bool, created, updated []Calendar, destroyed []string) CalendarChanges {
|
|
return CalendarChanges{
|
|
OldState: oldState,
|
|
NewState: newState,
|
|
HasMoreChanges: hasMoreChanges,
|
|
Created: created,
|
|
Updated: updated,
|
|
Destroyed: destroyed,
|
|
}
|
|
},
|
|
func(resp CalendarGetResponse) State { return resp.State },
|
|
session, ctx, logger, acceptLanguage,
|
|
)
|
|
}
|
|
|
|
func (j *Client) QueryCalendarEvents(accountIds []string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string, //NOSONAR
|
|
filter CalendarEventFilterElement, sortBy []CalendarEventComparator,
|
|
position uint, limit uint) (map[string][]CalendarEvent, SessionState, State, Language, Error) {
|
|
logger = j.logger("QueryCalendarEvents", session, logger)
|
|
|
|
uniqueAccountIds := structs.Uniq(accountIds)
|
|
|
|
if sortBy == nil {
|
|
sortBy = []CalendarEventComparator{{Property: CalendarEventPropertyStart, IsAscending: false}}
|
|
}
|
|
|
|
invocations := make([]Invocation, len(uniqueAccountIds)*2)
|
|
for i, accountId := range uniqueAccountIds {
|
|
query := CalendarEventQueryCommand{
|
|
AccountId: accountId,
|
|
Filter: filter,
|
|
Sort: sortBy,
|
|
}
|
|
if limit > 0 {
|
|
query.Limit = limit
|
|
}
|
|
if position > 0 {
|
|
query.Position = position
|
|
}
|
|
invocations[i*2+0] = invocation(CommandCalendarEventQuery, query, mcid(accountId, "0"))
|
|
invocations[i*2+1] = invocation(CommandCalendarEventGet, CalendarEventGetRefCommand{
|
|
AccountId: accountId,
|
|
IdsRef: &ResultReference{
|
|
Name: CommandCalendarEventQuery,
|
|
Path: "/ids/*",
|
|
ResultOf: mcid(accountId, "0"),
|
|
},
|
|
// Properties: CalendarEventProperties, // to also retrieve UTCStart and UTCEnd
|
|
}, mcid(accountId, "1"))
|
|
}
|
|
cmd, err := j.request(session, logger, NS_CALENDARS, invocations...)
|
|
if err != nil {
|
|
return nil, "", "", "", err
|
|
}
|
|
|
|
return command(j.api, logger, ctx, session, j.onSessionOutdated, cmd, acceptLanguage, func(body *Response) (map[string][]CalendarEvent, State, Error) {
|
|
resp := map[string][]CalendarEvent{}
|
|
stateByAccountId := map[string]State{}
|
|
for _, accountId := range uniqueAccountIds {
|
|
var response CalendarEventGetResponse
|
|
err = retrieveResponseMatchParameters(logger, body, CommandCalendarEventGet, mcid(accountId, "1"), &response)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
if len(response.NotFound) > 0 {
|
|
// TODO what to do when there are not-found calendarevents here? potentially nothing, they could have been deleted between query and get?
|
|
}
|
|
resp[accountId] = response.List
|
|
stateByAccountId[accountId] = response.State
|
|
}
|
|
return resp, squashState(stateByAccountId), nil
|
|
})
|
|
}
|
|
|
|
type CalendarEventChanges struct {
|
|
OldState State `json:"oldState,omitempty"`
|
|
NewState State `json:"newState"`
|
|
HasMoreChanges bool `json:"hasMoreChanges"`
|
|
Created []CalendarEvent `json:"created,omitempty"`
|
|
Updated []CalendarEvent `json:"updated,omitempty"`
|
|
Destroyed []string `json:"destroyed,omitempty"`
|
|
}
|
|
|
|
// Retrieve the changes in Calendar Events since a given State.
|
|
// @api:tags event,changes
|
|
func (j *Client) GetCalendarEventChanges(accountId string, session *Session, ctx context.Context, logger *log.Logger,
|
|
acceptLanguage string, sinceState State, maxChanges uint) (CalendarEventChanges, SessionState, State, Language, Error) {
|
|
return changesTemplate(j, "GetCalendarEventChanges", NS_CALENDARS,
|
|
CommandCalendarEventChanges, CommandCalendarEventGet,
|
|
func() CalendarEventChangesCommand {
|
|
return CalendarEventChangesCommand{AccountId: accountId, SinceState: sinceState, MaxChanges: posUIntPtr(maxChanges)}
|
|
},
|
|
func(path string, rof string) CalendarEventGetRefCommand {
|
|
return CalendarEventGetRefCommand{
|
|
AccountId: accountId,
|
|
IdsRef: &ResultReference{
|
|
Name: CommandCalendarEventChanges,
|
|
Path: path,
|
|
ResultOf: rof,
|
|
},
|
|
}
|
|
},
|
|
func(resp CalendarEventChangesResponse) (State, State, bool, []string) {
|
|
return resp.OldState, resp.NewState, resp.HasMoreChanges, resp.Destroyed
|
|
},
|
|
func(resp CalendarEventGetResponse) []CalendarEvent { return resp.List },
|
|
func(oldState, newState State, hasMoreChanges bool, created, updated []CalendarEvent, destroyed []string) CalendarEventChanges {
|
|
return CalendarEventChanges{
|
|
OldState: oldState,
|
|
NewState: newState,
|
|
HasMoreChanges: hasMoreChanges,
|
|
Created: created,
|
|
Updated: updated,
|
|
Destroyed: destroyed,
|
|
}
|
|
},
|
|
func(resp CalendarEventGetResponse) State { return resp.State },
|
|
session, ctx, logger, acceptLanguage,
|
|
)
|
|
}
|
|
|
|
func (j *Client) CreateCalendarEvent(accountId string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string, create CalendarEvent) (*CalendarEvent, SessionState, State, Language, Error) {
|
|
return createTemplate(j, "CreateCalendarEvent", NS_CALENDARS, CalendarEventType, CommandCalendarEventSet, CommandCalendarEventGet,
|
|
func(accountId string, create map[string]CalendarEvent) CalendarEventSetCommand {
|
|
return CalendarEventSetCommand{AccountId: accountId, Create: create}
|
|
},
|
|
func(accountId string, ref string) CalendarEventGetCommand {
|
|
return CalendarEventGetCommand{AccountId: accountId, Ids: []string{ref}}
|
|
},
|
|
func(resp CalendarEventSetResponse) map[string]*CalendarEvent {
|
|
return resp.Created
|
|
},
|
|
func(resp CalendarEventSetResponse) map[string]SetError {
|
|
return resp.NotCreated
|
|
},
|
|
func(resp CalendarEventGetResponse) []CalendarEvent {
|
|
return resp.List
|
|
},
|
|
func(resp CalendarEventSetResponse) State {
|
|
return resp.NewState
|
|
},
|
|
accountId, session, ctx, logger, acceptLanguage, create)
|
|
}
|
|
|
|
func (j *Client) DeleteCalendarEvent(accountId string, destroy []string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string) (map[string]SetError, SessionState, State, Language, Error) {
|
|
return deleteTemplate(j, "DeleteCalendarEvent", NS_CALENDARS, CommandCalendarEventSet,
|
|
func(accountId string, destroy []string) CalendarEventSetCommand {
|
|
return CalendarEventSetCommand{AccountId: accountId, Destroy: destroy}
|
|
},
|
|
func(resp CalendarEventSetResponse) map[string]SetError { return resp.NotDestroyed },
|
|
func(resp CalendarEventSetResponse) State { return resp.NewState },
|
|
accountId, destroy, session, ctx, logger, acceptLanguage)
|
|
}
|
|
|
|
func (j *Client) CreateCalendar(accountId string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string, create CalendarChange) (*Calendar, SessionState, State, Language, Error) {
|
|
return createTemplate(j, "CreateCalendar", NS_CALENDARS, CalendarType, CommandAddressBookSet, CommandAddressBookGet,
|
|
func(accountId string, create map[string]CalendarChange) CalendarSetCommand {
|
|
return CalendarSetCommand{AccountId: accountId, Create: create}
|
|
},
|
|
func(accountId string, ref string) CalendarGetCommand {
|
|
return CalendarGetCommand{AccountId: accountId, Ids: []string{ref}}
|
|
},
|
|
func(resp CalendarSetResponse) map[string]*Calendar {
|
|
return resp.Created
|
|
},
|
|
func(resp CalendarSetResponse) map[string]SetError {
|
|
return resp.NotCreated
|
|
},
|
|
func(resp CalendarGetResponse) []Calendar {
|
|
return resp.List
|
|
},
|
|
func(resp CalendarSetResponse) State {
|
|
return resp.NewState
|
|
},
|
|
accountId, session, ctx, logger, acceptLanguage, create,
|
|
)
|
|
}
|
|
|
|
func (j *Client) DeleteCalendar(accountId string, destroy []string, session *Session, ctx context.Context, logger *log.Logger, acceptLanguage string) (map[string]SetError, SessionState, State, Language, Error) {
|
|
return deleteTemplate(j, "DeleteCalendar", NS_ADDRESSBOOKS, CommandAddressBookSet,
|
|
func(accountId string, destroy []string) CalendarSetCommand {
|
|
return CalendarSetCommand{AccountId: accountId, Destroy: destroy}
|
|
},
|
|
func(resp CalendarSetResponse) map[string]SetError { return resp.NotDestroyed },
|
|
func(resp CalendarSetResponse) State { return resp.NewState },
|
|
accountId, destroy, session, ctx, logger, acceptLanguage,
|
|
)
|
|
}
|