diff --git a/internal/adapter/gql/generated.go b/internal/adapter/gql/generated.go index 87334227..d1873b0d 100644 --- a/internal/adapter/gql/generated.go +++ b/internal/adapter/gql/generated.go @@ -73,6 +73,7 @@ type ResolverRoot interface { Scene() SceneResolver ScenePlugin() ScenePluginResolver SceneWidget() SceneWidgetResolver + TagItem() TagItemResolver Team() TeamResolver TeamMember() TeamMemberResolver User() UserResolver @@ -171,6 +172,14 @@ type ComplexityRoot struct { Scene func(childComplexity int) int } + CreateTagGroupPayload struct { + Tag func(childComplexity int) int + } + + CreateTagItemPayload struct { + Tag func(childComplexity int) int + } + CreateTeamPayload struct { Team func(childComplexity int) int } @@ -455,6 +464,8 @@ type ComplexityRoot struct { CreateInfobox func(childComplexity int, input gqlmodel.CreateInfoboxInput) int CreateProject func(childComplexity int, input gqlmodel.CreateProjectInput) int CreateScene func(childComplexity int, input gqlmodel.CreateSceneInput) int + CreateTagGroup func(childComplexity int, input gqlmodel.CreateTagGroupInput) int + CreateTagItem func(childComplexity int, input gqlmodel.CreateTagItemInput) int CreateTeam func(childComplexity int, input gqlmodel.CreateTeamInput) int DeleteMe func(childComplexity int, input gqlmodel.DeleteMeInput) int DeleteProject func(childComplexity int, input gqlmodel.DeleteProjectInput) int @@ -833,6 +844,25 @@ type ComplexityRoot struct { URL func(childComplexity int) int } + TagGroup struct { + ID func(childComplexity int) int + Label func(childComplexity int) int + SceneID func(childComplexity int) int + Tags func(childComplexity int) int + } + + TagItem struct { + ID func(childComplexity int) int + Label func(childComplexity int) int + LinkedDataset func(childComplexity int) int + LinkedDatasetField func(childComplexity int) int + LinkedDatasetFieldID func(childComplexity int) int + LinkedDatasetID func(childComplexity int) int + LinkedDatasetSchema func(childComplexity int) int + LinkedDatasetSchemaID func(childComplexity int) int + SceneID func(childComplexity int) int + } + Team struct { Assets func(childComplexity int, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) int ID func(childComplexity int) int @@ -1059,6 +1089,8 @@ type MutationResolver interface { MoveInfoboxField(ctx context.Context, input gqlmodel.MoveInfoboxFieldInput) (*gqlmodel.MoveInfoboxFieldPayload, error) RemoveInfoboxField(ctx context.Context, input gqlmodel.RemoveInfoboxFieldInput) (*gqlmodel.RemoveInfoboxFieldPayload, error) ImportLayer(ctx context.Context, input gqlmodel.ImportLayerInput) (*gqlmodel.ImportLayerPayload, error) + CreateTagItem(ctx context.Context, input gqlmodel.CreateTagItemInput) (*gqlmodel.CreateTagItemPayload, error) + CreateTagGroup(ctx context.Context, input gqlmodel.CreateTagGroupInput) (*gqlmodel.CreateTagGroupPayload, error) } type PluginResolver interface { Scene(ctx context.Context, obj *gqlmodel.Plugin) (*gqlmodel.Scene, error) @@ -1156,6 +1188,11 @@ type SceneWidgetResolver interface { Extension(ctx context.Context, obj *gqlmodel.SceneWidget) (*gqlmodel.PluginExtension, error) Property(ctx context.Context, obj *gqlmodel.SceneWidget) (*gqlmodel.Property, error) } +type TagItemResolver interface { + LinkedDatasetSchema(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.DatasetSchema, error) + LinkedDataset(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.Dataset, error) + LinkedDatasetField(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.DatasetField, error) +} type TeamResolver interface { Assets(ctx context.Context, obj *gqlmodel.Team, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.AssetConnection, error) Projects(ctx context.Context, obj *gqlmodel.Team, includeArchived *bool, first *int, last *int, after *usecase.Cursor, before *usecase.Cursor) (*gqlmodel.ProjectConnection, error) @@ -1470,6 +1507,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.CreateScenePayload.Scene(childComplexity), true + case "CreateTagGroupPayload.tag": + if e.complexity.CreateTagGroupPayload.Tag == nil { + break + } + + return e.complexity.CreateTagGroupPayload.Tag(childComplexity), true + + case "CreateTagItemPayload.tag": + if e.complexity.CreateTagItemPayload.Tag == nil { + break + } + + return e.complexity.CreateTagItemPayload.Tag(childComplexity), true + case "CreateTeamPayload.team": if e.complexity.CreateTeamPayload.Team == nil { break @@ -2912,6 +2963,30 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Mutation.CreateScene(childComplexity, args["input"].(gqlmodel.CreateSceneInput)), true + case "Mutation.createTagGroup": + if e.complexity.Mutation.CreateTagGroup == nil { + break + } + + args, err := ec.field_Mutation_createTagGroup_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.CreateTagGroup(childComplexity, args["input"].(gqlmodel.CreateTagGroupInput)), true + + case "Mutation.createTagItem": + if e.complexity.Mutation.CreateTagItem == nil { + break + } + + args, err := ec.field_Mutation_createTagItem_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.CreateTagItem(childComplexity, args["input"].(gqlmodel.CreateTagItemInput)), true + case "Mutation.createTeam": if e.complexity.Mutation.CreateTeam == nil { break @@ -5128,6 +5203,97 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.SyncDatasetPayload.URL(childComplexity), true + case "TagGroup.id": + if e.complexity.TagGroup.ID == nil { + break + } + + return e.complexity.TagGroup.ID(childComplexity), true + + case "TagGroup.label": + if e.complexity.TagGroup.Label == nil { + break + } + + return e.complexity.TagGroup.Label(childComplexity), true + + case "TagGroup.sceneId": + if e.complexity.TagGroup.SceneID == nil { + break + } + + return e.complexity.TagGroup.SceneID(childComplexity), true + + case "TagGroup.tags": + if e.complexity.TagGroup.Tags == nil { + break + } + + return e.complexity.TagGroup.Tags(childComplexity), true + + case "TagItem.id": + if e.complexity.TagItem.ID == nil { + break + } + + return e.complexity.TagItem.ID(childComplexity), true + + case "TagItem.label": + if e.complexity.TagItem.Label == nil { + break + } + + return e.complexity.TagItem.Label(childComplexity), true + + case "TagItem.linkedDataset": + if e.complexity.TagItem.LinkedDataset == nil { + break + } + + return e.complexity.TagItem.LinkedDataset(childComplexity), true + + case "TagItem.linkedDatasetField": + if e.complexity.TagItem.LinkedDatasetField == nil { + break + } + + return e.complexity.TagItem.LinkedDatasetField(childComplexity), true + + case "TagItem.linkedDatasetFieldID": + if e.complexity.TagItem.LinkedDatasetFieldID == nil { + break + } + + return e.complexity.TagItem.LinkedDatasetFieldID(childComplexity), true + + case "TagItem.linkedDatasetID": + if e.complexity.TagItem.LinkedDatasetID == nil { + break + } + + return e.complexity.TagItem.LinkedDatasetID(childComplexity), true + + case "TagItem.linkedDatasetSchema": + if e.complexity.TagItem.LinkedDatasetSchema == nil { + break + } + + return e.complexity.TagItem.LinkedDatasetSchema(childComplexity), true + + case "TagItem.linkedDatasetSchemaID": + if e.complexity.TagItem.LinkedDatasetSchemaID == nil { + break + } + + return e.complexity.TagItem.LinkedDatasetSchemaID(childComplexity), true + + case "TagItem.sceneId": + if e.complexity.TagItem.SceneID == nil { + break + } + + return e.complexity.TagItem.SceneID(childComplexity), true + case "Team.assets": if e.complexity.Team.Assets == nil { break @@ -6190,6 +6356,33 @@ type MergedInfoboxField { scenePlugin: ScenePlugin @goField(forceResolver: true) } +interface Tag { + id: ID! + sceneId: ID! + label: String! +} + +type TagItem implements Tag { + id: ID! + sceneId: ID! + label: String! + linkedDatasetID: ID + linkedDatasetSchemaID: ID + linkedDatasetFieldID: ID + linkedDatasetSchema: DatasetSchema @goField(forceResolver: true) + linkedDataset: Dataset @goField(forceResolver: true) + linkedDatasetField: DatasetField @goField(forceResolver: true) +} + +type TagGroup implements Tag { + id: ID! + sceneId: ID! + label: String! + tags: [ID!] +} + +union Tags = TagItem | TagGroup + # InputType input CreateAssetInput { teamId: ID! @@ -6530,6 +6723,20 @@ input AddDatasetSchemaInput { representativefield: ID } +input CreateTagItemInput{ + sceneId: ID! + label: String! + linkedDatasetSchemaID: ID + linkedDatasetID: ID + linkedDatasetField: ID +} + +input CreateTagGroupInput{ + sceneId: ID! + label: String! + tags: [ID!] +} + # Payload type CreateAssetPayload { asset: Asset! @@ -6724,6 +6931,14 @@ type AddDatasetSchemaPayload { datasetSchema: DatasetSchema } +type CreateTagItemPayload{ + tag: TagItem! +} + +type CreateTagGroupPayload{ + tag: TagGroup! +} + # Connection enum NodeType { @@ -6917,6 +7132,10 @@ type Mutation { moveInfoboxField(input: MoveInfoboxFieldInput!): MoveInfoboxFieldPayload removeInfoboxField(input: RemoveInfoboxFieldInput!): RemoveInfoboxFieldPayload importLayer(input: ImportLayerInput!): ImportLayerPayload + + # Tag + createTagItem(input: CreateTagItemInput!): CreateTagItemPayload + createTagGroup(input: CreateTagGroupInput!): CreateTagGroupPayload } schema { @@ -7168,6 +7387,36 @@ func (ec *executionContext) field_Mutation_createScene_args(ctx context.Context, return args, nil } +func (ec *executionContext) field_Mutation_createTagGroup_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + var arg0 gqlmodel.CreateTagGroupInput + if tmp, ok := rawArgs["input"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) + arg0, err = ec.unmarshalNCreateTagGroupInput2githubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagGroupInput(ctx, tmp) + if err != nil { + return nil, err + } + } + args["input"] = arg0 + return args, nil +} + +func (ec *executionContext) field_Mutation_createTagItem_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + var arg0 gqlmodel.CreateTagItemInput + if tmp, ok := rawArgs["input"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) + arg0, err = ec.unmarshalNCreateTagItemInput2githubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagItemInput(ctx, tmp) + if err != nil { + return nil, err + } + } + args["input"] = arg0 + return args, nil +} + func (ec *executionContext) field_Mutation_createTeam_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} @@ -9943,6 +10192,76 @@ func (ec *executionContext) _CreateScenePayload_scene(ctx context.Context, field return ec.marshalNScene2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐScene(ctx, field.Selections, res) } +func (ec *executionContext) _CreateTagGroupPayload_tag(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.CreateTagGroupPayload) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "CreateTagGroupPayload", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Tag, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*gqlmodel.TagGroup) + fc.Result = res + return ec.marshalNTagGroup2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐTagGroup(ctx, field.Selections, res) +} + +func (ec *executionContext) _CreateTagItemPayload_tag(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.CreateTagItemPayload) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "CreateTagItemPayload", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Tag, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*gqlmodel.TagItem) + fc.Result = res + return ec.marshalNTagItem2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐTagItem(ctx, field.Selections, res) +} + func (ec *executionContext) _CreateTeamPayload_team(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.CreateTeamPayload) (ret graphql.Marshaler) { defer func() { if r := recover(); r != nil { @@ -18104,6 +18423,84 @@ func (ec *executionContext) _Mutation_importLayer(ctx context.Context, field gra return ec.marshalOImportLayerPayload2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐImportLayerPayload(ctx, field.Selections, res) } +func (ec *executionContext) _Mutation_createTagItem(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + IsResolver: true, + } + + ctx = graphql.WithFieldContext(ctx, fc) + rawArgs := field.ArgumentMap(ec.Variables) + args, err := ec.field_Mutation_createTagItem_args(ctx, rawArgs) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + fc.Args = args + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().CreateTagItem(rctx, args["input"].(gqlmodel.CreateTagItemInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*gqlmodel.CreateTagItemPayload) + fc.Result = res + return ec.marshalOCreateTagItemPayload2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagItemPayload(ctx, field.Selections, res) +} + +func (ec *executionContext) _Mutation_createTagGroup(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "Mutation", + Field: field, + Args: nil, + IsMethod: true, + IsResolver: true, + } + + ctx = graphql.WithFieldContext(ctx, fc) + rawArgs := field.ArgumentMap(ec.Variables) + args, err := ec.field_Mutation_createTagGroup_args(ctx, rawArgs) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + fc.Args = args + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().CreateTagGroup(rctx, args["input"].(gqlmodel.CreateTagGroupInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*gqlmodel.CreateTagGroupPayload) + fc.Result = res + return ec.marshalOCreateTagGroupPayload2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagGroupPayload(ctx, field.Selections, res) +} + func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.PageInfo) (ret graphql.Marshaler) { defer func() { if r := recover(); r != nil { @@ -26141,6 +26538,440 @@ func (ec *executionContext) _SyncDatasetPayload_dataset(ctx context.Context, fie return ec.marshalNDataset2ᚕᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐDatasetᚄ(ctx, field.Selections, res) } +func (ec *executionContext) _TagGroup_id(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagGroup) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagGroup", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(id.ID) + fc.Result = res + return ec.marshalNID2githubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagGroup_sceneId(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagGroup) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagGroup", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.SceneID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(id.ID) + fc.Result = res + return ec.marshalNID2githubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagGroup_label(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagGroup) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagGroup", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Label, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagGroup_tags(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagGroup) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagGroup", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Tags, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*id.ID) + fc.Result = res + return ec.marshalOID2ᚕᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐIDᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_id(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(id.ID) + fc.Result = res + return ec.marshalNID2githubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_sceneId(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.SceneID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(id.ID) + fc.Result = res + return ec.marshalNID2githubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_label(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Label, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_linkedDatasetID(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.LinkedDatasetID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*id.ID) + fc.Result = res + return ec.marshalOID2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_linkedDatasetSchemaID(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.LinkedDatasetSchemaID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*id.ID) + fc.Result = res + return ec.marshalOID2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_linkedDatasetFieldID(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.LinkedDatasetFieldID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*id.ID) + fc.Result = res + return ec.marshalOID2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_linkedDatasetSchema(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: true, + IsResolver: true, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.TagItem().LinkedDatasetSchema(rctx, obj) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*gqlmodel.DatasetSchema) + fc.Result = res + return ec.marshalODatasetSchema2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐDatasetSchema(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_linkedDataset(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: true, + IsResolver: true, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.TagItem().LinkedDataset(rctx, obj) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*gqlmodel.Dataset) + fc.Result = res + return ec.marshalODataset2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐDataset(ctx, field.Selections, res) +} + +func (ec *executionContext) _TagItem_linkedDatasetField(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.TagItem) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "TagItem", + Field: field, + Args: nil, + IsMethod: true, + IsResolver: true, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.TagItem().LinkedDatasetField(rctx, obj) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*gqlmodel.DatasetField) + fc.Result = res + return ec.marshalODatasetField2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐDatasetField(ctx, field.Selections, res) +} + func (ec *executionContext) _Team_id(ctx context.Context, field graphql.CollectedField, obj *gqlmodel.Team) (ret graphql.Marshaler) { defer func() { if r := recover(); r != nil { @@ -29168,6 +29999,94 @@ func (ec *executionContext) unmarshalInputCreateSceneInput(ctx context.Context, return it, nil } +func (ec *executionContext) unmarshalInputCreateTagGroupInput(ctx context.Context, obj interface{}) (gqlmodel.CreateTagGroupInput, error) { + var it gqlmodel.CreateTagGroupInput + var asMap = obj.(map[string]interface{}) + + for k, v := range asMap { + switch k { + case "sceneId": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sceneId")) + it.SceneID, err = ec.unmarshalNID2githubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, v) + if err != nil { + return it, err + } + case "label": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("label")) + it.Label, err = ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + case "tags": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags")) + it.Tags, err = ec.unmarshalOID2ᚕᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐIDᚄ(ctx, v) + if err != nil { + return it, err + } + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputCreateTagItemInput(ctx context.Context, obj interface{}) (gqlmodel.CreateTagItemInput, error) { + var it gqlmodel.CreateTagItemInput + var asMap = obj.(map[string]interface{}) + + for k, v := range asMap { + switch k { + case "sceneId": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sceneId")) + it.SceneID, err = ec.unmarshalNID2githubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, v) + if err != nil { + return it, err + } + case "label": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("label")) + it.Label, err = ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + case "linkedDatasetSchemaID": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("linkedDatasetSchemaID")) + it.LinkedDatasetSchemaID, err = ec.unmarshalOID2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, v) + if err != nil { + return it, err + } + case "linkedDatasetID": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("linkedDatasetID")) + it.LinkedDatasetID, err = ec.unmarshalOID2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, v) + if err != nil { + return it, err + } + case "linkedDatasetField": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("linkedDatasetField")) + it.LinkedDatasetField, err = ec.unmarshalOID2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋpkgᚋidᚐID(ctx, v) + if err != nil { + return it, err + } + } + } + + return it, nil +} + func (ec *executionContext) unmarshalInputCreateTeamInput(ctx context.Context, obj interface{}) (gqlmodel.CreateTeamInput, error) { var it gqlmodel.CreateTeamInput var asMap = obj.(map[string]interface{}) @@ -30833,6 +31752,52 @@ func (ec *executionContext) _PropertyItem(ctx context.Context, sel ast.Selection } } +func (ec *executionContext) _Tag(ctx context.Context, sel ast.SelectionSet, obj gqlmodel.Tag) graphql.Marshaler { + switch obj := (obj).(type) { + case nil: + return graphql.Null + case gqlmodel.TagItem: + return ec._TagItem(ctx, sel, &obj) + case *gqlmodel.TagItem: + if obj == nil { + return graphql.Null + } + return ec._TagItem(ctx, sel, obj) + case gqlmodel.TagGroup: + return ec._TagGroup(ctx, sel, &obj) + case *gqlmodel.TagGroup: + if obj == nil { + return graphql.Null + } + return ec._TagGroup(ctx, sel, obj) + default: + panic(fmt.Errorf("unexpected type %T", obj)) + } +} + +func (ec *executionContext) _Tags(ctx context.Context, sel ast.SelectionSet, obj gqlmodel.Tags) graphql.Marshaler { + switch obj := (obj).(type) { + case nil: + return graphql.Null + case gqlmodel.TagItem: + return ec._TagItem(ctx, sel, &obj) + case *gqlmodel.TagItem: + if obj == nil { + return graphql.Null + } + return ec._TagItem(ctx, sel, obj) + case gqlmodel.TagGroup: + return ec._TagGroup(ctx, sel, &obj) + case *gqlmodel.TagGroup: + if obj == nil { + return graphql.Null + } + return ec._TagGroup(ctx, sel, obj) + default: + panic(fmt.Errorf("unexpected type %T", obj)) + } +} + // endregion ************************** interface.gotpl *************************** // region **************************** object.gotpl **************************** @@ -31379,6 +32344,60 @@ func (ec *executionContext) _CreateScenePayload(ctx context.Context, sel ast.Sel return out } +var createTagGroupPayloadImplementors = []string{"CreateTagGroupPayload"} + +func (ec *executionContext) _CreateTagGroupPayload(ctx context.Context, sel ast.SelectionSet, obj *gqlmodel.CreateTagGroupPayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, createTagGroupPayloadImplementors) + + out := graphql.NewFieldSet(fields) + var invalids uint32 + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("CreateTagGroupPayload") + case "tag": + out.Values[i] = ec._CreateTagGroupPayload_tag(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch() + if invalids > 0 { + return graphql.Null + } + return out +} + +var createTagItemPayloadImplementors = []string{"CreateTagItemPayload"} + +func (ec *executionContext) _CreateTagItemPayload(ctx context.Context, sel ast.SelectionSet, obj *gqlmodel.CreateTagItemPayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, createTagItemPayloadImplementors) + + out := graphql.NewFieldSet(fields) + var invalids uint32 + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("CreateTagItemPayload") + case "tag": + out.Values[i] = ec._CreateTagItemPayload_tag(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch() + if invalids > 0 { + return graphql.Null + } + return out +} + var createTeamPayloadImplementors = []string{"CreateTeamPayload"} func (ec *executionContext) _CreateTeamPayload(ctx context.Context, sel ast.SelectionSet, obj *gqlmodel.CreateTeamPayload) graphql.Marshaler { @@ -33330,6 +34349,10 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) out.Values[i] = ec._Mutation_removeInfoboxField(ctx, field) case "importLayer": out.Values[i] = ec._Mutation_importLayer(ctx, field) + case "createTagItem": + out.Values[i] = ec._Mutation_createTagItem(ctx, field) + case "createTagGroup": + out.Values[i] = ec._Mutation_createTagGroup(ctx, field) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -35601,6 +36624,121 @@ func (ec *executionContext) _SyncDatasetPayload(ctx context.Context, sel ast.Sel return out } +var tagGroupImplementors = []string{"TagGroup", "Tag", "Tags"} + +func (ec *executionContext) _TagGroup(ctx context.Context, sel ast.SelectionSet, obj *gqlmodel.TagGroup) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, tagGroupImplementors) + + out := graphql.NewFieldSet(fields) + var invalids uint32 + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("TagGroup") + case "id": + out.Values[i] = ec._TagGroup_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } + case "sceneId": + out.Values[i] = ec._TagGroup_sceneId(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } + case "label": + out.Values[i] = ec._TagGroup_label(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } + case "tags": + out.Values[i] = ec._TagGroup_tags(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch() + if invalids > 0 { + return graphql.Null + } + return out +} + +var tagItemImplementors = []string{"TagItem", "Tag", "Tags"} + +func (ec *executionContext) _TagItem(ctx context.Context, sel ast.SelectionSet, obj *gqlmodel.TagItem) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, tagItemImplementors) + + out := graphql.NewFieldSet(fields) + var invalids uint32 + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("TagItem") + case "id": + out.Values[i] = ec._TagItem_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&invalids, 1) + } + case "sceneId": + out.Values[i] = ec._TagItem_sceneId(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&invalids, 1) + } + case "label": + out.Values[i] = ec._TagItem_label(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&invalids, 1) + } + case "linkedDatasetID": + out.Values[i] = ec._TagItem_linkedDatasetID(ctx, field, obj) + case "linkedDatasetSchemaID": + out.Values[i] = ec._TagItem_linkedDatasetSchemaID(ctx, field, obj) + case "linkedDatasetFieldID": + out.Values[i] = ec._TagItem_linkedDatasetFieldID(ctx, field, obj) + case "linkedDatasetSchema": + field := field + out.Concurrently(i, func() (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._TagItem_linkedDatasetSchema(ctx, field, obj) + return res + }) + case "linkedDataset": + field := field + out.Concurrently(i, func() (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._TagItem_linkedDataset(ctx, field, obj) + return res + }) + case "linkedDatasetField": + field := field + out.Concurrently(i, func() (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._TagItem_linkedDatasetField(ctx, field, obj) + return res + }) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch() + if invalids > 0 { + return graphql.Null + } + return out +} + var teamImplementors = []string{"Team", "Node"} func (ec *executionContext) _Team(ctx context.Context, sel ast.SelectionSet, obj *gqlmodel.Team) graphql.Marshaler { @@ -36549,6 +37687,16 @@ func (ec *executionContext) unmarshalNCreateSceneInput2githubᚗcomᚋreearthᚋ return res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) unmarshalNCreateTagGroupInput2githubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagGroupInput(ctx context.Context, v interface{}) (gqlmodel.CreateTagGroupInput, error) { + res, err := ec.unmarshalInputCreateTagGroupInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalNCreateTagItemInput2githubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagItemInput(ctx context.Context, v interface{}) (gqlmodel.CreateTagItemInput, error) { + res, err := ec.unmarshalInputCreateTagItemInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) unmarshalNCreateTeamInput2githubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTeamInput(ctx context.Context, v interface{}) (gqlmodel.CreateTeamInput, error) { res, err := ec.unmarshalInputCreateTeamInput(ctx, v) return res, graphql.ErrorOnPath(ctx, err) @@ -38519,6 +39667,26 @@ func (ec *executionContext) unmarshalNSyncDatasetInput2githubᚗcomᚋreearthᚋ return res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) marshalNTagGroup2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐTagGroup(ctx context.Context, sel ast.SelectionSet, v *gqlmodel.TagGroup) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + return ec._TagGroup(ctx, sel, v) +} + +func (ec *executionContext) marshalNTagItem2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐTagItem(ctx context.Context, sel ast.SelectionSet, v *gqlmodel.TagItem) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + return ec._TagItem(ctx, sel, v) +} + func (ec *executionContext) marshalNTeam2githubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐTeam(ctx context.Context, sel ast.SelectionSet, v gqlmodel.Team) graphql.Marshaler { return ec._Team(ctx, sel, &v) } @@ -39120,6 +40288,20 @@ func (ec *executionContext) marshalOCreateScenePayload2ᚖgithubᚗcomᚋreearth return ec._CreateScenePayload(ctx, sel, v) } +func (ec *executionContext) marshalOCreateTagGroupPayload2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagGroupPayload(ctx context.Context, sel ast.SelectionSet, v *gqlmodel.CreateTagGroupPayload) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._CreateTagGroupPayload(ctx, sel, v) +} + +func (ec *executionContext) marshalOCreateTagItemPayload2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTagItemPayload(ctx context.Context, sel ast.SelectionSet, v *gqlmodel.CreateTagItemPayload) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._CreateTagItemPayload(ctx, sel, v) +} + func (ec *executionContext) marshalOCreateTeamPayload2ᚖgithubᚗcomᚋreearthᚋreearthᚑbackendᚋinternalᚋadapterᚋgqlᚋgqlmodelᚐCreateTeamPayload(ctx context.Context, sel ast.SelectionSet, v *gqlmodel.CreateTeamPayload) graphql.Marshaler { if v == nil { return graphql.Null diff --git a/internal/adapter/gql/gqlmodel/convert_tag.go b/internal/adapter/gql/gqlmodel/convert_tag.go new file mode 100644 index 00000000..903524de --- /dev/null +++ b/internal/adapter/gql/gqlmodel/convert_tag.go @@ -0,0 +1,34 @@ +package gqlmodel + +import ( + "github.com/reearth/reearth-backend/pkg/id" + "github.com/reearth/reearth-backend/pkg/tag" +) + +func ToTagItem(ti *tag.Item) *TagItem { + return &TagItem{ + ID: ti.ID().ID(), + SceneID: ti.Scene().ID(), + Label: ti.Label(), + LinkedDatasetID: ti.LinkedDatasetID().IDRef(), + LinkedDatasetSchemaID: ti.LinkedDatasetSchemaID().IDRef(), + LinkedDatasetFieldID: ti.LinkedDatasetFieldID().IDRef(), + } +} + +func ToTagGroup(tg *tag.Group) *TagGroup { + tags := tg.Tags() + tids := tags.Tags() + var ids []*id.ID + for _, tid := range tids { + if !tid.IsNil() { + ids = append(ids, tid.IDRef()) + } + } + return &TagGroup{ + ID: tg.ID().ID(), + SceneID: tg.Scene().ID(), + Label: tg.Label(), + Tags: ids, + } +} diff --git a/internal/adapter/gql/gqlmodel/models_gen.go b/internal/adapter/gql/gqlmodel/models_gen.go index fa12a356..97f5bf5e 100644 --- a/internal/adapter/gql/gqlmodel/models_gen.go +++ b/internal/adapter/gql/gqlmodel/models_gen.go @@ -31,6 +31,14 @@ type PropertyItem interface { IsPropertyItem() } +type Tag interface { + IsTag() +} + +type Tags interface { + IsTags() +} + type AddDatasetSchemaInput struct { SceneID id.ID `json:"sceneId"` Name string `json:"name"` @@ -211,6 +219,28 @@ type CreateScenePayload struct { Scene *Scene `json:"scene"` } +type CreateTagGroupInput struct { + SceneID id.ID `json:"sceneId"` + Label string `json:"label"` + Tags []*id.ID `json:"tags"` +} + +type CreateTagGroupPayload struct { + Tag *TagGroup `json:"tag"` +} + +type CreateTagItemInput struct { + SceneID id.ID `json:"sceneId"` + Label string `json:"label"` + LinkedDatasetSchemaID *id.ID `json:"linkedDatasetSchemaID"` + LinkedDatasetID *id.ID `json:"linkedDatasetID"` + LinkedDatasetField *id.ID `json:"linkedDatasetField"` +} + +type CreateTagItemPayload struct { + Tag *TagItem `json:"tag"` +} + type CreateTeamInput struct { Name string `json:"name"` } @@ -958,6 +988,31 @@ type SyncDatasetPayload struct { Dataset []*Dataset `json:"dataset"` } +type TagGroup struct { + ID id.ID `json:"id"` + SceneID id.ID `json:"sceneId"` + Label string `json:"label"` + Tags []*id.ID `json:"tags"` +} + +func (TagGroup) IsTag() {} +func (TagGroup) IsTags() {} + +type TagItem struct { + ID id.ID `json:"id"` + SceneID id.ID `json:"sceneId"` + Label string `json:"label"` + LinkedDatasetID *id.ID `json:"linkedDatasetID"` + LinkedDatasetSchemaID *id.ID `json:"linkedDatasetSchemaID"` + LinkedDatasetFieldID *id.ID `json:"linkedDatasetFieldID"` + LinkedDatasetSchema *DatasetSchema `json:"linkedDatasetSchema"` + LinkedDataset *Dataset `json:"linkedDataset"` + LinkedDatasetField *DatasetField `json:"linkedDatasetField"` +} + +func (TagItem) IsTag() {} +func (TagItem) IsTags() {} + type Team struct { ID id.ID `json:"id"` Name string `json:"name"` diff --git a/internal/adapter/gql/resolver_mutation_tag.go b/internal/adapter/gql/resolver_mutation_tag.go new file mode 100644 index 00000000..b060b820 --- /dev/null +++ b/internal/adapter/gql/resolver_mutation_tag.go @@ -0,0 +1,45 @@ +package gql + +import ( + "context" + + "github.com/reearth/reearth-backend/internal/adapter/gql/gqlmodel" + "github.com/reearth/reearth-backend/internal/usecase/interfaces" + "github.com/reearth/reearth-backend/pkg/id" +) + +func (r *mutationResolver) CreateTagItem(ctx context.Context, input gqlmodel.CreateTagItemInput) (*gqlmodel.CreateTagItemPayload, error) { + exit := trace(ctx) + defer exit() + + tag, err := r.usecases.Tag.CreateItem(ctx, interfaces.CreateTagItemParam{ + Label: input.Label, + SceneID: id.SceneID(input.SceneID), + LinkedDatasetSchemaID: id.DatasetSchemaIDFromRefID(input.LinkedDatasetSchemaID), + LinkedDatasetID: id.DatasetIDFromRefID(input.LinkedDatasetID), + LinkedDatasetField: id.DatasetSchemaFieldIDFromRefID(input.LinkedDatasetField), + }, getOperator(ctx)) + if err != nil { + return nil, err + } + return &gqlmodel.CreateTagItemPayload{ + Tag: gqlmodel.ToTagItem(tag), + }, nil +} + +func (r *mutationResolver) CreateTagGroup(ctx context.Context, input gqlmodel.CreateTagGroupInput) (*gqlmodel.CreateTagGroupPayload, error) { + exit := trace(ctx) + defer exit() + + tag, err := r.usecases.Tag.CreateGroup(ctx, interfaces.CreateTagGroupParam{ + Label: input.Label, + SceneID: id.SceneID(input.SceneID), + Tags: id.TagIDsFromIDRef(input.Tags), + }, getOperator(ctx)) + if err != nil { + return nil, err + } + return &gqlmodel.CreateTagGroupPayload{ + Tag: gqlmodel.ToTagGroup(tag), + }, nil +} diff --git a/internal/adapter/gql/resolver_tag.go b/internal/adapter/gql/resolver_tag.go new file mode 100644 index 00000000..b3bd77e4 --- /dev/null +++ b/internal/adapter/gql/resolver_tag.go @@ -0,0 +1,45 @@ +package gql + +import ( + "context" + + "github.com/reearth/reearth-backend/internal/adapter/gql/gqlmodel" + "github.com/reearth/reearth-backend/pkg/id" +) + +type tagItemResolver struct{ *Resolver } + +func (r *Resolver) TagItem() TagItemResolver { + return &tagItemResolver{r} +} + +func (t tagItemResolver) LinkedDatasetSchema(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.DatasetSchema, error) { + exit := trace(ctx) + defer exit() + + if obj.LinkedDatasetID == nil { + return nil, nil + } + return DataLoadersFromContext(ctx).DatasetSchema.Load(id.DatasetSchemaID(*obj.LinkedDatasetSchemaID)) +} + +func (t tagItemResolver) LinkedDataset(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.Dataset, error) { + exit := trace(ctx) + defer exit() + + if obj.LinkedDatasetID == nil { + return nil, nil + } + return DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) +} + +func (t tagItemResolver) LinkedDatasetField(ctx context.Context, obj *gqlmodel.TagItem) (*gqlmodel.DatasetField, error) { + exit := trace(ctx) + defer exit() + + if obj.LinkedDatasetID == nil { + return nil, nil + } + ds, err := DataLoadersFromContext(ctx).Dataset.Load(id.DatasetID(*obj.LinkedDatasetID)) + return ds.Field(*obj.LinkedDatasetFieldID), err +} diff --git a/internal/infrastructure/memory/container.go b/internal/infrastructure/memory/container.go index 93311683..2c9b9d45 100644 --- a/internal/infrastructure/memory/container.go +++ b/internal/infrastructure/memory/container.go @@ -19,6 +19,7 @@ func InitRepos(c *repo.Container) *repo.Container { c.PropertySchema = NewPropertySchema() c.Property = NewProperty() c.Scene = NewScene() + c.Tag = NewTag() c.Team = NewTeam() c.User = NewUser() c.SceneLock = NewSceneLock() diff --git a/internal/infrastructure/memory/tag.go b/internal/infrastructure/memory/tag.go new file mode 100644 index 00000000..7129f3db --- /dev/null +++ b/internal/infrastructure/memory/tag.go @@ -0,0 +1,68 @@ +package memory + +import ( + "context" + + "github.com/reearth/reearth-backend/internal/usecase/repo" + "github.com/reearth/reearth-backend/pkg/id" + "github.com/reearth/reearth-backend/pkg/tag" +) + +type Tag struct { + //lock sync.Mutex + data map[id.TagID]tag.Tag +} + +func NewTag() repo.Tag { + return &Tag{ + data: map[id.TagID]tag.Tag{}, + } +} + +func (t Tag) FindByID(ctx context.Context, tagID id.TagID, ids []id.SceneID) (*tag.Tag, error) { + panic("implement me") +} + +func (t Tag) FindByIDs(ctx context.Context, ids []id.TagID, ids2 []id.SceneID) ([]*tag.Tag, error) { + panic("implement me") +} + +func (t Tag) FindItemByID(ctx context.Context, tagID id.TagID, ids []id.SceneID) (*tag.Item, error) { + panic("implement me") +} + +func (t Tag) FindItemByIDs(ctx context.Context, ids []id.TagID, ids2 []id.SceneID) ([]*tag.Item, error) { + panic("implement me") +} + +func (t Tag) FindGroupByID(ctx context.Context, tagID id.TagID, ids []id.SceneID) (*tag.Group, error) { + panic("implement me") +} + +func (t Tag) FindGroupByIDs(ctx context.Context, ids []id.TagID, ids2 []id.SceneID) ([]*tag.Group, error) { + panic("implement me") +} + +func (t Tag) FindByScene(ctx context.Context, sceneID id.SceneID) ([]*tag.Tag, error) { + panic("implement me") +} + +func (t Tag) Save(ctx context.Context, t2 tag.Tag) error { + panic("implement me") +} + +func (t Tag) SaveAll(ctx context.Context, tags []*tag.Tag) error { + panic("implement me") +} + +func (t Tag) Remove(ctx context.Context, tagID id.TagID) error { + panic("implement me") +} + +func (t Tag) RemoveAll(ctx context.Context, ids []id.TagID) error { + panic("implement me") +} + +func (t Tag) RemoveByScene(ctx context.Context, sceneID id.SceneID) error { + panic("implement me") +} diff --git a/internal/infrastructure/mongo/container.go b/internal/infrastructure/mongo/container.go index a112483d..ead33b18 100644 --- a/internal/infrastructure/mongo/container.go +++ b/internal/infrastructure/mongo/container.go @@ -25,6 +25,7 @@ func InitRepos(ctx context.Context, c *repo.Container, mc *mongo.Client, databas c.PropertySchema = NewPropertySchema(client) c.Property = NewProperty(client) c.Scene = NewScene(client) + c.Tag = NewTag(client) c.Team = NewTeam(client) c.User = NewUser(client) c.SceneLock = NewSceneLock(client) diff --git a/internal/infrastructure/mongo/mongodoc/tag.go b/internal/infrastructure/mongo/mongodoc/tag.go index ca897314..68ff9cfd 100644 --- a/internal/infrastructure/mongo/mongodoc/tag.go +++ b/internal/infrastructure/mongo/mongodoc/tag.go @@ -164,6 +164,6 @@ func (d *TagDocument) ModelGroup() (*tag.Group, error) { ID(tid). Label(d.Label). Scene(sid). - Tags(*tag.NewListFromTags(ids)). + Tags(tag.NewListFromTags(ids)). Build() } diff --git a/internal/usecase/interactor/common.go b/internal/usecase/interactor/common.go index a0b5f019..6c5a383d 100644 --- a/internal/usecase/interactor/common.go +++ b/internal/usecase/interactor/common.go @@ -28,6 +28,7 @@ func NewContainer(r *repo.Container, g *gateway.Container, config ContainerConfi Project: NewProject(r, g), Property: NewProperty(r, g), Scene: NewScene(r, g), + Tag: NewTag(r), Team: NewTeam(r), User: NewUser(r, g, config.SignupSecret), } diff --git a/internal/usecase/interactor/tag.go b/internal/usecase/interactor/tag.go new file mode 100644 index 00000000..9ce0c98d --- /dev/null +++ b/internal/usecase/interactor/tag.go @@ -0,0 +1,99 @@ +package interactor + +import ( + "context" + + "github.com/reearth/reearth-backend/internal/usecase" + "github.com/reearth/reearth-backend/internal/usecase/interfaces" + "github.com/reearth/reearth-backend/internal/usecase/repo" + "github.com/reearth/reearth-backend/pkg/tag" +) + +type Tag struct { + commonScene + tagRepo repo.Tag + sceneRepo repo.Scene + transaction repo.Transaction +} + +func NewTag(r *repo.Container) interfaces.Tag { + return &Tag{ + commonScene: commonScene{sceneRepo: r.Scene}, + tagRepo: r.Tag, + sceneRepo: r.Scene, + transaction: r.Transaction, + } +} + +func (i *Tag) CreateItem(ctx context.Context, inp interfaces.CreateTagItemParam, operator *usecase.Operator) (*tag.Item, error) { + tx, err := i.transaction.Begin() + if err != nil { + return nil, err + } + defer func() { + if err2 := tx.End(ctx); err == nil && err2 != nil { + err = err2 + } + }() + + if err := i.CanWriteScene(ctx, inp.SceneID, operator); err != nil { + return nil, interfaces.ErrOperationDenied + } + + builder := tag.NewItem(). + NewID(). + Label(inp.Label). + Scene(inp.SceneID) + if inp.LinkedDatasetSchemaID != nil && inp.LinkedDatasetID != nil && inp.LinkedDatasetField != nil { + builder = builder. + LinkedDatasetFieldID(inp.LinkedDatasetField). + LinkedDatasetID(inp.LinkedDatasetID). + LinkedDatasetSchemaID(inp.LinkedDatasetSchemaID) + } + item, err := builder.Build() + if err != nil { + return nil, err + } + + err = i.tagRepo.Save(ctx, item) + if err != nil { + return nil, err + } + tx.Commit() + return item, nil +} + +func (i *Tag) CreateGroup(ctx context.Context, inp interfaces.CreateTagGroupParam, operator *usecase.Operator) (*tag.Group, error) { + tx, err := i.transaction.Begin() + if err != nil { + return nil, err + } + defer func() { + if err2 := tx.End(ctx); err == nil && err2 != nil { + err = err2 + } + }() + + if err := i.CanWriteScene(ctx, inp.SceneID, operator); err != nil { + return nil, interfaces.ErrOperationDenied + } + + list := tag.NewListFromTags(inp.Tags) + group, err := tag.NewGroup(). + NewID(). + Label(inp.Label). + Scene(inp.SceneID). + Tags(list). + Build() + + if err != nil { + return nil, err + } + + err = i.tagRepo.Save(ctx, group) + if err != nil { + return nil, err + } + tx.Commit() + return group, nil +} diff --git a/internal/usecase/interfaces/common.go b/internal/usecase/interfaces/common.go index 8c90ad1b..3fa48695 100644 --- a/internal/usecase/interfaces/common.go +++ b/internal/usecase/interfaces/common.go @@ -25,6 +25,7 @@ type Container struct { Property Property Published Published Scene Scene + Tag Tag Team Team User User } diff --git a/internal/usecase/interfaces/tag.go b/internal/usecase/interfaces/tag.go new file mode 100644 index 00000000..8c606ce8 --- /dev/null +++ b/internal/usecase/interfaces/tag.go @@ -0,0 +1,28 @@ +package interfaces + +import ( + "context" + + "github.com/reearth/reearth-backend/internal/usecase" + "github.com/reearth/reearth-backend/pkg/id" + "github.com/reearth/reearth-backend/pkg/tag" +) + +type CreateTagItemParam struct { + Label string + SceneID id.SceneID + LinkedDatasetSchemaID *id.DatasetSchemaID + LinkedDatasetID *id.DatasetID + LinkedDatasetField *id.DatasetSchemaFieldID +} + +type CreateTagGroupParam struct { + Label string + SceneID id.SceneID + Tags []id.TagID +} + +type Tag interface { + CreateItem(context.Context, CreateTagItemParam, *usecase.Operator) (*tag.Item, error) + CreateGroup(context.Context, CreateTagGroupParam, *usecase.Operator) (*tag.Group, error) +} diff --git a/internal/usecase/repo/container.go b/internal/usecase/repo/container.go index f329feb8..35c679e4 100644 --- a/internal/usecase/repo/container.go +++ b/internal/usecase/repo/container.go @@ -11,6 +11,7 @@ type Container struct { PropertySchema PropertySchema Property Property Scene Scene + Tag Tag Team Team User User SceneLock SceneLock diff --git a/pkg/tag/group_builder.go b/pkg/tag/group_builder.go index 9f97a569..644e74b2 100644 --- a/pkg/tag/group_builder.go +++ b/pkg/tag/group_builder.go @@ -60,7 +60,10 @@ func (b *GroupBuilder) Scene(sid id.SceneID) *GroupBuilder { return b } -func (b *GroupBuilder) Tags(tl List) *GroupBuilder { - b.g.tags = tl +func (b *GroupBuilder) Tags(tl *List) *GroupBuilder { + if tl != nil { + b.g.tags = *tl + } + return b } diff --git a/pkg/tag/group_test.go b/pkg/tag/group_test.go index d42cf89b..e4adbf2d 100644 --- a/pkg/tag/group_test.go +++ b/pkg/tag/group_test.go @@ -25,7 +25,7 @@ func TestGroupBuilder_Build(t *testing.T) { Name, Label string Id id.TagID Scene id.SceneID - Tags List + Tags *List Expected struct { Group Group Error error @@ -81,7 +81,7 @@ func TestGroupBuilder_Build(t *testing.T) { Id: tid, Label: "xxx", Scene: sid, - Tags: List{ + Tags: &List{ tags: tags, }, Expected: struct { diff --git a/schema.graphql b/schema.graphql index 02d9b34c..9b4a633d 100644 --- a/schema.graphql +++ b/schema.graphql @@ -706,6 +706,33 @@ type MergedInfoboxField { scenePlugin: ScenePlugin @goField(forceResolver: true) } +interface Tag { + id: ID! + sceneId: ID! + label: String! +} + +type TagItem implements Tag { + id: ID! + sceneId: ID! + label: String! + linkedDatasetID: ID + linkedDatasetSchemaID: ID + linkedDatasetFieldID: ID + linkedDatasetSchema: DatasetSchema @goField(forceResolver: true) + linkedDataset: Dataset @goField(forceResolver: true) + linkedDatasetField: DatasetField @goField(forceResolver: true) +} + +type TagGroup implements Tag { + id: ID! + sceneId: ID! + label: String! + tags: [ID!] +} + +union Tags = TagItem | TagGroup + # InputType input CreateAssetInput { teamId: ID! @@ -1046,6 +1073,20 @@ input AddDatasetSchemaInput { representativefield: ID } +input CreateTagItemInput{ + sceneId: ID! + label: String! + linkedDatasetSchemaID: ID + linkedDatasetID: ID + linkedDatasetField: ID +} + +input CreateTagGroupInput{ + sceneId: ID! + label: String! + tags: [ID!] +} + # Payload type CreateAssetPayload { asset: Asset! @@ -1240,6 +1281,14 @@ type AddDatasetSchemaPayload { datasetSchema: DatasetSchema } +type CreateTagItemPayload{ + tag: TagItem! +} + +type CreateTagGroupPayload{ + tag: TagGroup! +} + # Connection enum NodeType { @@ -1433,6 +1482,10 @@ type Mutation { moveInfoboxField(input: MoveInfoboxFieldInput!): MoveInfoboxFieldPayload removeInfoboxField(input: RemoveInfoboxFieldInput!): RemoveInfoboxFieldPayload importLayer(input: ImportLayerInput!): ImportLayerPayload + + # Tag + createTagItem(input: CreateTagItemInput!): CreateTagItemPayload + createTagGroup(input: CreateTagGroupInput!): CreateTagGroupPayload } schema {