mirror of
https://github.com/Unkn0wnCat/calapi.git
synced 2025-04-28 17:46:19 +02:00
488 lines
12 KiB
Go
488 lines
12 KiB
Go
package graph
|
|
|
|
// This file will be automatically regenerated based on the schema, any resolver implementations
|
|
// will be copied through when generating and any unknown code will be moved to the end.
|
|
// Code generated by github.com/99designs/gqlgen version v0.17.24
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"github.com/99designs/gqlgen/graphql"
|
|
"github.com/Unkn0wnCat/calapi/internal/auth"
|
|
"github.com/Unkn0wnCat/calapi/internal/logger"
|
|
"github.com/go-chi/chi/middleware"
|
|
"go.uber.org/zap"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/Unkn0wnCat/calapi/graph/model"
|
|
"github.com/Unkn0wnCat/calapi/internal/database"
|
|
"github.com/Unkn0wnCat/calapi/internal/db_model"
|
|
"github.com/objectbox/objectbox-go/objectbox"
|
|
)
|
|
|
|
// Events is the resolver for the events field.
|
|
func (r *calendarResolver) Events(ctx context.Context, obj *model.Calendar, after *time.Time, before *time.Time) ([]*model.Event, error) {
|
|
if auth.ChallengeQuery(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
if after == nil {
|
|
now := time.Now()
|
|
after = &now
|
|
}
|
|
if before == nil {
|
|
oneYearLater := time.Now().Add(time.Hour * 24 * 365)
|
|
before = &oneYearLater
|
|
}
|
|
|
|
eventBox := db_model.BoxForEvent(database.ObjectBox)
|
|
|
|
filters := []objectbox.Condition{db_model.Event_.Start.Between(after.UnixMilli(), before.UnixMilli()), db_model.Event_.Start.OrderAsc()}
|
|
|
|
filters = append(filters, db_model.Event_.Calendar.In(obj.DbID))
|
|
|
|
query := eventBox.Query(filters...)
|
|
results, err := query.Find()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
events := make([]*model.Event, len(results))
|
|
|
|
for i, result := range results {
|
|
event := model.FromEvent(*result)
|
|
events[i] = &event
|
|
}
|
|
|
|
return events, nil
|
|
}
|
|
|
|
// Calendar is the resolver for the calendar field.
|
|
func (r *eventResolver) Calendar(ctx context.Context, obj *model.Event) (*model.Calendar, error) {
|
|
if auth.ChallengeQuery(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
modelCalendar := model.FromCalendar(*obj.DbCalendar)
|
|
|
|
return &modelCalendar, nil
|
|
}
|
|
|
|
// CreateEvent is the resolver for the createEvent field.
|
|
func (r *mutationResolver) CreateEvent(ctx context.Context, input model.NewEvent) (*model.Event, error) {
|
|
if auth.ChallengeMutation(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
actualId, err := strconv.ParseUint(input.Calendar, 16, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calendarBox := db_model.BoxForCalendar(database.ObjectBox)
|
|
calendar, err := calendarBox.Get(actualId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if calendar == nil {
|
|
return nil, errors.New("calendar not found")
|
|
}
|
|
|
|
event := db_model.Event{
|
|
Title: input.Title,
|
|
Description: input.Description,
|
|
Calendar: calendar,
|
|
LocationLat: 0,
|
|
LocationLon: 0,
|
|
LocationName: "",
|
|
LocationAddr: "",
|
|
Start: input.Start,
|
|
End: input.End,
|
|
DateCreated: time.Now(),
|
|
}
|
|
|
|
if input.Location != nil {
|
|
if input.Location.Lat != nil && input.Location.Lon != nil {
|
|
event.LocationLat = *input.Location.Lat
|
|
event.LocationLon = *input.Location.Lon
|
|
}
|
|
if input.Location.Name != nil {
|
|
event.LocationName = *input.Location.Name
|
|
}
|
|
if input.Location.Address != nil {
|
|
event.LocationAddr = *input.Location.Address
|
|
}
|
|
}
|
|
|
|
eventBox := db_model.BoxForEvent(database.ObjectBox)
|
|
_, err = eventBox.Put(&event)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
modelEvent := model.FromEvent(event)
|
|
|
|
logger.Logger.Info("event created",
|
|
zap.String("requestId", middleware.GetReqID(ctx)),
|
|
zap.String("gqlPath", graphql.GetPath(ctx).String()),
|
|
zap.Uint64("newID", event.Id),
|
|
)
|
|
|
|
return &modelEvent, nil
|
|
}
|
|
|
|
// EditEvent is the resolver for the editEvent field.
|
|
func (r *mutationResolver) EditEvent(ctx context.Context, input model.EditEvent) (*model.Event, error) {
|
|
if auth.ChallengeMutation(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
actualId, err := strconv.ParseUint(input.ID, 16, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
eventBox := db_model.BoxForEvent(database.ObjectBox)
|
|
event, err := eventBox.Get(actualId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if event == nil {
|
|
return nil, errors.New("event not found")
|
|
}
|
|
|
|
if input.Location != nil {
|
|
if input.Location.Lat != nil && input.Location.Lon != nil {
|
|
event.LocationLat = *input.Location.Lat
|
|
event.LocationLon = *input.Location.Lon
|
|
}
|
|
if input.Location.Name != nil {
|
|
event.LocationName = *input.Location.Name
|
|
}
|
|
if input.Location.Address != nil {
|
|
event.LocationAddr = *input.Location.Address
|
|
}
|
|
}
|
|
|
|
if input.Start != nil {
|
|
event.Start = *input.Start
|
|
}
|
|
|
|
if input.End != nil {
|
|
event.End = *input.End
|
|
}
|
|
|
|
if input.Title != nil {
|
|
event.Title = *input.Title
|
|
}
|
|
|
|
if input.Description != nil {
|
|
event.Description = *input.Description
|
|
}
|
|
|
|
if input.Calendar != nil {
|
|
calendarId, err := strconv.ParseUint(input.ID, 16, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calendarBox := db_model.BoxForCalendar(database.ObjectBox)
|
|
calendar, err := calendarBox.Get(calendarId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if calendar == nil {
|
|
return nil, errors.New("calendar not found")
|
|
}
|
|
event.Calendar = calendar
|
|
}
|
|
|
|
err = eventBox.Update(event)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
modelEvent := model.FromEvent(*event)
|
|
|
|
logger.Logger.Info("event edited",
|
|
zap.String("requestId", middleware.GetReqID(ctx)),
|
|
zap.String("gqlPath", graphql.GetPath(ctx).String()),
|
|
zap.Uint64("ID", event.Id),
|
|
)
|
|
|
|
return &modelEvent, nil
|
|
}
|
|
|
|
// DeleteEvent is the resolver for the deleteEvent field.
|
|
func (r *mutationResolver) DeleteEvent(ctx context.Context, input string) (bool, error) {
|
|
if auth.ChallengeMutation(ctx) != nil {
|
|
return false, errors.New("unauthorized")
|
|
}
|
|
|
|
actualId, err := strconv.ParseUint(input, 16, 64)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
eventBox := db_model.BoxForEvent(database.ObjectBox)
|
|
err = eventBox.RemoveId(actualId)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
logger.Logger.Info("event deleted",
|
|
zap.String("requestId", middleware.GetReqID(ctx)),
|
|
zap.String("gqlPath", graphql.GetPath(ctx).String()),
|
|
zap.Uint64("oldID", actualId),
|
|
)
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// CreateCalendar is the resolver for the createCalendar field.
|
|
func (r *mutationResolver) CreateCalendar(ctx context.Context, input model.NewCalendar) (*model.Calendar, error) {
|
|
if auth.ChallengeMutation(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
calendar := db_model.Calendar{
|
|
Name: input.Name,
|
|
Description: input.Description,
|
|
DateCreated: time.Now(),
|
|
}
|
|
|
|
calendarBox := db_model.BoxForCalendar(database.ObjectBox)
|
|
_, err := calendarBox.Put(&calendar)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
modelCalendar := model.FromCalendar(calendar)
|
|
|
|
logger.Logger.Info("calendar created",
|
|
zap.String("requestId", middleware.GetReqID(ctx)),
|
|
zap.String("gqlPath", graphql.GetPath(ctx).String()),
|
|
zap.Uint64("newID", calendar.Id),
|
|
)
|
|
|
|
return &modelCalendar, nil
|
|
}
|
|
|
|
// EditCalendar is the resolver for the editCalendar field.
|
|
func (r *mutationResolver) EditCalendar(ctx context.Context, input model.EditCalendar) (*model.Calendar, error) {
|
|
if auth.ChallengeMutation(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
actualId, err := strconv.ParseUint(input.ID, 16, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calendarBox := db_model.BoxForCalendar(database.ObjectBox)
|
|
calendar, err := calendarBox.Get(actualId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if calendar == nil {
|
|
return nil, errors.New("calendar not found")
|
|
}
|
|
|
|
if input.Name != nil {
|
|
calendar.Name = *input.Name
|
|
}
|
|
|
|
if input.Description != nil {
|
|
calendar.Description = *input.Description
|
|
}
|
|
|
|
err = calendarBox.Update(calendar)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
modelCalendar := model.FromCalendar(*calendar)
|
|
|
|
logger.Logger.Info("calendar edited",
|
|
zap.String("requestId", middleware.GetReqID(ctx)),
|
|
zap.String("gqlPath", graphql.GetPath(ctx).String()),
|
|
zap.Uint64("ID", calendar.Id),
|
|
)
|
|
|
|
return &modelCalendar, nil
|
|
}
|
|
|
|
// DeleteCalendar is the resolver for the deleteCalendar field.
|
|
func (r *mutationResolver) DeleteCalendar(ctx context.Context, input string) (bool, error) {
|
|
if auth.ChallengeMutation(ctx) != nil {
|
|
return false, errors.New("unauthorized")
|
|
}
|
|
|
|
actualId, err := strconv.ParseUint(input, 16, 64)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
calendarBox := db_model.BoxForCalendar(database.ObjectBox)
|
|
err = calendarBox.RemoveId(actualId)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
logger.Logger.Info("calendar deleted",
|
|
zap.String("requestId", middleware.GetReqID(ctx)),
|
|
zap.String("gqlPath", graphql.GetPath(ctx).String()),
|
|
zap.Uint64("newID", actualId),
|
|
)
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// Login is the resolver for the login field.
|
|
func (r *mutationResolver) Login(ctx context.Context, input model.Login) (string, error) {
|
|
user, err := auth.Authenticate(ctx, input.Username, input.Password)
|
|
if err != nil || user == nil {
|
|
return "", errors.New("invalid credentials")
|
|
}
|
|
|
|
token, err := auth.MakeJWT(user)
|
|
if err != nil {
|
|
return "", errors.New("failed to create token")
|
|
}
|
|
|
|
return token, nil
|
|
}
|
|
|
|
// Events is the resolver for the events field.
|
|
func (r *queryResolver) Events(ctx context.Context, after *time.Time, before *time.Time, calendar *string) ([]*model.Event, error) {
|
|
if auth.ChallengeQuery(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
if after == nil {
|
|
now := time.Now()
|
|
after = &now
|
|
}
|
|
if before == nil {
|
|
oneYearLater := time.Now().Add(time.Hour * 24 * 365)
|
|
before = &oneYearLater
|
|
}
|
|
|
|
eventBox := db_model.BoxForEvent(database.ObjectBox)
|
|
|
|
filters := []objectbox.Condition{db_model.Event_.Start.Between(after.UnixMilli(), before.UnixMilli()), db_model.Event_.Start.OrderAsc()}
|
|
|
|
if calendar != nil {
|
|
calendarId, err := strconv.ParseUint(*calendar, 16, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
filters = append(filters, db_model.Event_.Calendar.In(calendarId))
|
|
}
|
|
|
|
query := eventBox.Query(filters...)
|
|
results, err := query.Find()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
events := make([]*model.Event, len(results))
|
|
|
|
for i, result := range results {
|
|
event := model.FromEvent(*result)
|
|
events[i] = &event
|
|
}
|
|
|
|
return events, nil
|
|
}
|
|
|
|
// Calendars is the resolver for the calendars field.
|
|
func (r *queryResolver) Calendars(ctx context.Context) ([]*model.Calendar, error) {
|
|
if auth.ChallengeQuery(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
calendarBox := db_model.BoxForCalendar(database.ObjectBox)
|
|
results, err := calendarBox.GetAll()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calendars := make([]*model.Calendar, len(results))
|
|
|
|
for i, result := range results {
|
|
calendar := model.FromCalendar(*result)
|
|
calendars[i] = &calendar
|
|
}
|
|
|
|
return calendars, nil
|
|
}
|
|
|
|
// Calendar is the resolver for the calendar field.
|
|
func (r *queryResolver) Calendar(ctx context.Context, id string) (*model.Calendar, error) {
|
|
if auth.ChallengeQuery(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
actualId, err := strconv.ParseUint(id, 16, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calendarBox := db_model.BoxForCalendar(database.ObjectBox)
|
|
calendar, err := calendarBox.Get(actualId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if calendar == nil {
|
|
return nil, errors.New("not found")
|
|
}
|
|
|
|
modelCalendar := model.FromCalendar(*calendar)
|
|
return &modelCalendar, nil
|
|
}
|
|
|
|
// Event is the resolver for the event field.
|
|
func (r *queryResolver) Event(ctx context.Context, id string) (*model.Event, error) {
|
|
if auth.ChallengeQuery(ctx) != nil {
|
|
return nil, errors.New("unauthorized")
|
|
}
|
|
|
|
actualId, err := strconv.ParseUint(id, 16, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
eventBox := db_model.BoxForEvent(database.ObjectBox)
|
|
event, err := eventBox.Get(actualId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if event == nil {
|
|
return nil, errors.New("not found")
|
|
}
|
|
|
|
modelEvent := model.FromEvent(*event)
|
|
return &modelEvent, nil
|
|
}
|
|
|
|
// Calendar returns CalendarResolver implementation.
|
|
func (r *Resolver) Calendar() CalendarResolver { return &calendarResolver{r} }
|
|
|
|
// Event returns EventResolver implementation.
|
|
func (r *Resolver) Event() EventResolver { return &eventResolver{r} }
|
|
|
|
// Mutation returns MutationResolver implementation.
|
|
func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }
|
|
|
|
// Query returns QueryResolver implementation.
|
|
func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }
|
|
|
|
type calendarResolver struct{ *Resolver }
|
|
type eventResolver struct{ *Resolver }
|
|
type mutationResolver struct{ *Resolver }
|
|
type queryResolver struct{ *Resolver }
|