organization.resolvers.go

package resolver

// 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.47

import (
	"context"
	"errors"
	"time"

	"github.com/99designs/gqlgen/graphql"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/constants"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/dataloader"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/entity"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/graph/generated"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/graph/model"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/mapper"
	enummapper "github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/mapper/enum"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-api/tracing"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-common-module/common"
	commonTracing "github.com/openline-ai/openline-customer-os/packages/server/customer-os-common-module/tracing"
	"github.com/openline-ai/openline-customer-os/packages/server/customer-os-common-module/utils"
	neo4jentity "github.com/openline-ai/openline-customer-os/packages/server/customer-os-neo4j-repository/entity"
	commonpb "github.com/openline-ai/openline-customer-os/packages/server/events-processing-proto/gen/proto/go/api/grpc/v1/common"
	organizationpb "github.com/openline-ai/openline-customer-os/packages/server/events-processing-proto/gen/proto/go/api/grpc/v1/organization"
	opentracing "github.com/opentracing/opentracing-go"
	"github.com/opentracing/opentracing-go/log"
	"google.golang.org/protobuf/types/known/timestamppb"
)

// LastTouchPointTimelineEvent is the resolver for the lastTouchPointTimelineEvent field.
func (r *lastTouchpointResolver) LastTouchPointTimelineEvent(ctx context.Context, obj *model.LastTouchpoint) (model.TimelineEvent, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	if obj.LastTouchPointTimelineEventID == nil {
		return nil, nil
	}

	timelineEventNillable, err := dataloader.For(ctx).GetTimelineEventForTimelineEventId(ctx, *obj.LastTouchPointTimelineEventID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Error fetching last touchpoint timeline event for organization %s: %s", *obj.LastTouchPointTimelineEventID, err.Error())
		graphql.AddErrorf(ctx, "Error fetching last touchpoint timeline event for organization %s", *obj.LastTouchPointTimelineEventID)
		return nil, err
	}
	return mapper.MapEntityToTimelineEvent(timelineEventNillable), nil
}

// OrganizationCreate is the resolver for the organization_Create field.
func (r *mutationResolver) OrganizationCreate(ctx context.Context, input model.OrganizationInput) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationCreate", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.Object("input", input))

	// Check and prepare custom fields
	for _, field := range input.CustomFields {
		if utils.IsEmptyString(field.TemplateID) && utils.IsEmptyString(field.Name) {
			tracing.TraceErr(span, errors.New("Custom field template id or name is required"))
			graphql.AddErrorf(ctx, "Custom field template id or name is required")
			return nil, nil
		}
		if utils.IsEmptyString(field.TemplateID) && field.Datatype == nil {
			tracing.TraceErr(span, errors.New("Custom field template id or data type is required"))
			graphql.AddErrorf(ctx, "Custom field template id or data type is required")
			return nil, nil
		}
		if !utils.IsEmptyString(field.TemplateID) {
			customFieldTemplate, err := r.Services.CustomFieldTemplateService.GetById(ctx, *field.TemplateID)
			if err != nil {
				tracing.TraceErr(span, err)
				graphql.AddErrorf(ctx, "Custom field template %s not found", *field.TemplateID)
				return nil, nil
			}
			if utils.IsEmptyString(field.Name) {
				field.Name = &customFieldTemplate.Name
			}
			if field.Datatype == nil {
				field.Datatype = mapper.MapTemplateTypeToFieldDataType(customFieldTemplate.Type)
			}
		}
	}

	upsertOrganizationRequest := organizationpb.UpsertOrganizationGrpcRequest{
		Tenant:             common.GetTenantFromContext(ctx),
		LoggedInUserId:     common.GetUserIdFromContext(ctx),
		Name:               utils.IfNotNilString(input.Name),
		ReferenceId:        utils.IfNotNilString(input.ReferenceID),
		Description:        utils.IfNotNilString(input.Description),
		Website:            utils.IfNotNilString(input.Website),
		Industry:           utils.IfNotNilString(input.Industry),
		SubIndustry:        utils.IfNotNilString(input.SubIndustry),
		IndustryGroup:      utils.IfNotNilString(input.IndustryGroup),
		IsPublic:           utils.IfNotNilBool(input.IsPublic),
		IsCustomer:         utils.IfNotNilBool(input.IsCustomer),
		Market:             mapper.MapMarketFromModel(input.Market),
		Employees:          utils.IfNotNilInt64(input.Employees),
		YearFounded:        input.YearFounded,
		LogoUrl:            utils.IfNotNilString(input.LogoURL),
		IconUrl:            utils.IfNotNilString(input.Icon),
		Headquarters:       utils.IfNotNilString(input.Headquarters),
		EmployeeGrowthRate: utils.IfNotNilString(input.EmployeeGrowthRate),
		SlackChannelId:     utils.IfNotNilString(input.SlackChannelID),
		SourceFields: &commonpb.SourceFields{
			Source:    string(neo4jentity.DataSourceOpenline),
			AppSource: utils.IfNotNilString(input.AppSource),
		},
		Note:       utils.IfNotNilString(input.Note),
		LeadSource: utils.IfNotNilString(input.LeadSource),
	}
	if input.Relationship != nil {
		upsertOrganizationRequest.Relationship = enummapper.MapRelationshipFromModel(*input.Relationship).String()
	}
	if input.Stage != nil {
		upsertOrganizationRequest.Stage = enummapper.MapStageFromModel(*input.Stage).String()
	}
	if input.Logo != nil {
		upsertOrganizationRequest.LogoUrl = *input.Logo
	}
	if input.Icon != nil {
		upsertOrganizationRequest.IconUrl = *input.Icon
	}
	if input.Notes != nil {
		upsertOrganizationRequest.Note = *input.Notes
	}
	if input.CustomID != nil {
		upsertOrganizationRequest.ReferenceId = *input.CustomID
	}
	if input.Public != nil {
		upsertOrganizationRequest.IsPublic = *input.Public
	}

	var err error
	ctx = commonTracing.InjectSpanContextIntoGrpcMetadata(ctx, span)
	response, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
		return r.Clients.OrganizationClient.UpsertOrganization(ctx, &upsertOrganizationRequest)
	})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to create organization")
		r.log.Errorf("Error from events processing %s", err.Error())
		return nil, nil
	}

	var findOrgErr error
	var organizationCreated = false
	for i := 1; i <= constants.MaxRetriesCheckDataInNeo4jAfterEventRequest; i++ {
		organizationCreated, findOrgErr = r.Services.OrganizationService.ExistsById(ctx, response.Id)
		if organizationCreated && findOrgErr == nil {
			span.LogFields(log.Bool("organizationSavedInGraphDB", true))
			break
		}
		time.Sleep(utils.BackOffIncrementalDelay(i))
	}
	if !organizationCreated {
		span.LogFields(log.Bool("organizationSavedInGraphDB", false))
	}

	if len(input.Domains) > 0 {
		for _, domain := range input.Domains {
			if domain != "" {
				_, err = utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
					return r.Clients.OrganizationClient.LinkDomainToOrganization(ctx, &organizationpb.LinkDomainToOrganizationGrpcRequest{
						Tenant:         common.GetTenantFromContext(ctx),
						LoggedInUserId: common.GetUserIdFromContext(ctx),
						OrganizationId: response.Id,
						Domain:         domain,
						AppSource:      utils.IfNotNilStringWithDefault(input.AppSource, constants.AppSourceCustomerOsApi),
					})
				})
				if err != nil {
					tracing.TraceErr(span, err)
					r.log.Errorf("Failed to link domain %s to organization %s", domain, response.Id)
				}
			}
		}
	}
	if len(input.CustomFields) > 0 {
		for _, field := range input.CustomFields {
			customFieldEntity := mapper.MapCustomFieldInputToEntity(field)
			var customFieldValue organizationpb.CustomFieldValue
			customFieldValue.StringValue = customFieldEntity.Value.Str
			customFieldValue.BoolValue = customFieldEntity.Value.Bool
			if customFieldEntity.Value.Time != nil {
				timestamppb.New(*customFieldEntity.Value.Time)
			}
			customFieldValue.IntegerValue = customFieldEntity.Value.Int
			customFieldValue.DecimalValue = customFieldEntity.Value.Float

			var customFieldDataType = organizationpb.CustomFieldDataType_TEXT
			if field.Datatype != nil {
				switch *field.Datatype {
				case model.CustomFieldDataTypeText:
					customFieldDataType = organizationpb.CustomFieldDataType_TEXT
				case model.CustomFieldDataTypeBool:
					customFieldDataType = organizationpb.CustomFieldDataType_BOOL
				case model.CustomFieldDataTypeDatetime:
					customFieldDataType = organizationpb.CustomFieldDataType_DATETIME
				case model.CustomFieldDataTypeInteger:
					customFieldDataType = organizationpb.CustomFieldDataType_INTEGER
				case model.CustomFieldDataTypeDecimal:
					customFieldDataType = organizationpb.CustomFieldDataType_DECIMAL
				}
			}
			_, err = utils.CallEventsPlatformGRPCWithRetry[*organizationpb.CustomFieldIdGrpcResponse](func() (*organizationpb.CustomFieldIdGrpcResponse, error) {
				return r.Clients.OrganizationClient.UpsertCustomFieldToOrganization(ctx, &organizationpb.CustomFieldForOrganizationGrpcRequest{
					Tenant:                common.GetTenantFromContext(ctx),
					OrganizationId:        response.Id,
					LoggedInUserId:        common.GetUserIdFromContext(ctx),
					CustomFieldName:       customFieldEntity.Name,
					CustomFieldDataType:   customFieldDataType,
					CustomFieldTemplateId: customFieldEntity.TemplateId,
					CustomFieldValue:      &customFieldValue,
					SourceFields: &commonpb.SourceFields{
						Source:    string(neo4jentity.DataSourceOpenline),
						AppSource: utils.IfNotNilStringWithDefault(input.AppSource, constants.AppSourceCustomerOsApi),
					},
				})
			})
			if err != nil {
				tracing.TraceErr(span, err)
				r.log.Errorf("Failed to upsert custom field %s to organization %s", *field.Name, response.Id)
			}
		}
	}

	time.Sleep(100 * time.Millisecond)

	organizationEntity, err := r.Services.OrganizationService.GetById(ctx, response.Id)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to fetch organization details")
		return &model.Organization{
			ID: response.Id,
		}, nil
	}

	return mapper.MapEntityToOrganization(organizationEntity), nil
}

// OrganizationUpdate is the resolver for the organization_Update field.
func (r *mutationResolver) OrganizationUpdate(ctx context.Context, input model.OrganizationUpdateInput) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationUpdate", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	tracing.LogObjectAsJson(span, "input", input)

	if input.ID == "" {
		tracing.TraceErr(span, errors.New("missing organization id"))
		graphql.AddErrorf(ctx, "Missing organization id")
		return nil, nil
	}

	_, err := r.Services.OrganizationService.GetById(ctx, input.ID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Organization not found")
		return &model.Organization{
			ID: input.ID,
		}, nil
	}
	fieldsMask := []organizationpb.OrganizationMaskField{}
	if utils.IfNotNilString(input.Name) != "" {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_NAME)
	}
	if input.ReferenceID != nil || input.CustomID != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_REFERENCE_ID)
	}
	if input.Description != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_DESCRIPTION)
	}
	if input.Website != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_WEBSITE)
	}
	if input.Industry != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_INDUSTRY)
	}
	if input.SubIndustry != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_SUB_INDUSTRY)
	}
	if input.IndustryGroup != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_INDUSTRY_GROUP)
	}
	if input.Market != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_MARKET)
	}
	if input.TargetAudience != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_TARGET_AUDIENCE)
	}
	if input.ValueProposition != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_VALUE_PROPOSITION)
	}
	if input.LastFundingAmount != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_LAST_FUNDING_AMOUNT)
	}
	if input.LastFundingRound != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_LAST_FUNDING_ROUND)
	}
	if input.YearFounded != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_YEAR_FOUNDED)
	}
	if input.Headquarters != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_HEADQUARTERS)
	}
	if input.LogoURL != nil || input.Logo != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_LOGO_URL)
	}
	if input.Icon != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_ICON_URL)
	}
	if input.EmployeeGrowthRate != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_EMPLOYEE_GROWTH_RATE)
	}
	if input.Note != nil || input.Notes != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_NOTE)
	}
	if input.SlackChannelID != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_SLACK_CHANNEL_ID)
	}
	if input.Public != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_IS_PUBLIC)
	}
	if input.IsCustomer != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_IS_CUSTOMER)
	}
	if input.Relationship != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_RELATIONSHIP)
	}
	if input.Stage != nil {
		fieldsMask = append(fieldsMask, organizationpb.OrganizationMaskField_ORGANIZATION_PROPERTY_STAGE)
	}
	if len(fieldsMask) == 0 {
		span.LogFields(log.String("result", "No fields to update"))
		organizationEntity, err := r.Services.OrganizationService.GetById(ctx, input.ID)
		if err != nil {
			tracing.TraceErr(span, err)
			graphql.AddErrorf(ctx, "Failed to fetch organization details")
			return &model.Organization{
				ID: input.ID,
			}, nil
		}
		return mapper.MapEntityToOrganization(organizationEntity), nil
	}

	upsertOrganizationRequest := organizationpb.UpsertOrganizationGrpcRequest{
		Tenant:             common.GetTenantFromContext(ctx),
		LoggedInUserId:     common.GetUserIdFromContext(ctx),
		Id:                 input.ID,
		FieldsMask:         fieldsMask,
		Name:               utils.IfNotNilString(input.Name),
		ReferenceId:        utils.IfNotNilString(input.ReferenceID),
		Description:        utils.IfNotNilString(input.Description),
		Website:            utils.IfNotNilString(input.Website),
		Industry:           utils.IfNotNilString(input.Industry),
		SubIndustry:        utils.IfNotNilString(input.SubIndustry),
		IndustryGroup:      utils.IfNotNilString(input.IndustryGroup),
		IsPublic:           utils.IfNotNilBool(input.IsPublic),
		IsCustomer:         utils.IfNotNilBool(input.IsCustomer),
		Market:             mapper.MapMarketFromModel(input.Market),
		Employees:          utils.IfNotNilInt64(input.Employees),
		TargetAudience:     utils.IfNotNilString(input.TargetAudience),
		ValueProposition:   utils.IfNotNilString(input.ValueProposition),
		LastFundingAmount:  utils.IfNotNilString(input.LastFundingAmount),
		LastFundingRound:   enummapper.MapFundingRoundFromModel(input.LastFundingRound),
		Note:               utils.IfNotNilString(input.Note),
		YearFounded:        input.YearFounded,
		LogoUrl:            utils.IfNotNilString(input.LogoURL),
		IconUrl:            utils.IfNotNilString(input.Icon),
		Headquarters:       utils.IfNotNilString(input.Headquarters),
		EmployeeGrowthRate: utils.IfNotNilString(input.EmployeeGrowthRate),
		SlackChannelId:     utils.IfNotNilString(input.SlackChannelID),
		SourceFields: &commonpb.SourceFields{
			Source: string(neo4jentity.DataSourceOpenline),
		},
	}
	if input.Relationship != nil {
		upsertOrganizationRequest.Relationship = enummapper.MapRelationshipFromModel(*input.Relationship).String()
	}
	if input.Stage != nil {
		upsertOrganizationRequest.Stage = enummapper.MapStageFromModel(*input.Stage).String()
	}
	if input.Logo != nil {
		upsertOrganizationRequest.LogoUrl = *input.Logo
	}
	if input.Icon != nil {
		upsertOrganizationRequest.IconUrl = *input.Icon
	}
	if input.Notes != nil {
		upsertOrganizationRequest.Note = *input.Notes
	}
	if input.CustomID != nil {
		upsertOrganizationRequest.ReferenceId = *input.CustomID
	}
	if input.Public != nil {
		upsertOrganizationRequest.IsPublic = *input.Public
	}

	ctx = commonTracing.InjectSpanContextIntoGrpcMetadata(ctx, span)
	response, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
		return r.Clients.OrganizationClient.UpsertOrganization(ctx, &upsertOrganizationRequest)
	})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to update organization")
		r.log.Errorf("Error from events processing %s", err.Error())
		return nil, nil
	}
	time.Sleep(100 * time.Millisecond)

	organizationEntity, err := r.Services.OrganizationService.GetById(ctx, response.Id)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to fetch organization details")
		return &model.Organization{
			ID: response.Id,
		}, nil
	}
	return mapper.MapEntityToOrganization(organizationEntity), nil
}

// OrganizationArchive is the resolver for the organization_Archive field.
func (r *mutationResolver) OrganizationArchive(ctx context.Context, id string) (*model.Result, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationArchive", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", id))

	if id == "" {
		tracing.TraceErr(span, errors.New("missing organization id"))
		graphql.AddErrorf(ctx, "Missing organization id")
		return nil, nil
	}

	err := r.Services.OrganizationService.Archive(ctx, id)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to archive organization %s", id)
		return &model.Result{
			Result: false,
		}, err
	}
	return &model.Result{
		Result: true,
	}, nil
}

// OrganizationArchiveAll is the resolver for the organization_ArchiveAll field.
func (r *mutationResolver) OrganizationArchiveAll(ctx context.Context, ids []string) (*model.Result, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationArchiveAll", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.Object("request.organizationIDs", ids))

	for _, id := range ids {
		err := r.Services.OrganizationService.Archive(ctx, id)
		if err != nil {
			tracing.TraceErr(span, err)
			graphql.AddErrorf(ctx, "Failed to archive organization %s", id)
			return &model.Result{
				Result: false,
			}, err
		}
	}
	return &model.Result{
		Result: true,
	}, nil
}

// OrganizationHide is the resolver for the organization_Hide field.
func (r *mutationResolver) OrganizationHide(ctx context.Context, id string) (string, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationHide", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.Object("organizationId", id))

	if id == "" {
		tracing.TraceErr(span, errors.New("missing organization id"))
		graphql.AddErrorf(ctx, "Missing organization id")
		return "", nil
	}

	ctx = commonTracing.InjectSpanContextIntoGrpcMetadata(ctx, span)
	response, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
		return r.Clients.OrganizationClient.HideOrganization(ctx, &organizationpb.OrganizationIdGrpcRequest{
			Tenant:         common.GetTenantFromContext(ctx),
			OrganizationId: id,
			LoggedInUserId: common.GetUserIdFromContext(ctx),
		})
	})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to hide organization %s", id)
		return response.Id, nil
	}

	return response.Id, nil
}

// OrganizationHideAll is the resolver for the organization_HideAll field.
func (r *mutationResolver) OrganizationHideAll(ctx context.Context, ids []string) (*model.Result, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationHideAll", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.Object("organizationIds", ids))

	ctx = commonTracing.InjectSpanContextIntoGrpcMetadata(ctx, span)
	for _, orgId := range ids {
		_, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
			return r.Clients.OrganizationClient.HideOrganization(ctx, &organizationpb.OrganizationIdGrpcRequest{
				Tenant:         common.GetTenantFromContext(ctx),
				OrganizationId: orgId,
				LoggedInUserId: common.GetUserIdFromContext(ctx),
			})
		})
		if err != nil {
			tracing.TraceErr(span, err)
			graphql.AddErrorf(ctx, "Failed to hide organization %s", orgId)
		}
	}

	return &model.Result{
		Result: true,
	}, nil
}

// OrganizationShow is the resolver for the organization_Show field.
func (r *mutationResolver) OrganizationShow(ctx context.Context, id string) (string, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationShow", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.Object("organizationId", id))

	ctx = commonTracing.InjectSpanContextIntoGrpcMetadata(ctx, span)
	response, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
		return r.Clients.OrganizationClient.ShowOrganization(ctx, &organizationpb.OrganizationIdGrpcRequest{
			Tenant:         common.GetTenantFromContext(ctx),
			OrganizationId: id,
			LoggedInUserId: common.GetUserIdFromContext(ctx),
		})
	})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to hide organization %s", id)
		return response.Id, nil
	}
	_, err = utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
		return r.Clients.OrganizationClient.RefreshLastTouchpoint(ctx, &organizationpb.OrganizationIdGrpcRequest{
			Tenant:         common.GetTenantFromContext(ctx),
			OrganizationId: id,
			LoggedInUserId: common.GetUserIdFromContext(ctx),
		})
	})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to refresh the last touchpoint %s", id)
		return response.Id, nil
	}

	return response.Id, nil
}

// OrganizationShowAll is the resolver for the organization_ShowAll field.
func (r *mutationResolver) OrganizationShowAll(ctx context.Context, ids []string) (*model.Result, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationShowAll", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.Object("organizationIds", ids))

	ctx = commonTracing.InjectSpanContextIntoGrpcMetadata(ctx, span)
	for _, orgId := range ids {
		_, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
			return r.Clients.OrganizationClient.ShowOrganization(ctx, &organizationpb.OrganizationIdGrpcRequest{
				Tenant:         common.GetTenantFromContext(ctx),
				OrganizationId: orgId,
				LoggedInUserId: common.GetUserIdFromContext(ctx),
			})
		})
		if err != nil {
			tracing.TraceErr(span, err)
			graphql.AddErrorf(ctx, "Failed to show organization %s", orgId)
		}
	}

	return &model.Result{
		Result: true,
	}, nil
}

// OrganizationMerge is the resolver for the organization_Merge field.
func (r *mutationResolver) OrganizationMerge(ctx context.Context, primaryOrganizationID string, mergedOrganizationIds []string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationMerge", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.primaryOrganizationID", primaryOrganizationID), log.Object("request.mergedOrganizationIds", mergedOrganizationIds))

	for _, mergedOrganizationID := range mergedOrganizationIds {
		err := r.Services.OrganizationService.Merge(ctx, primaryOrganizationID, mergedOrganizationID)
		if err != nil {
			tracing.TraceErr(span, err)
			graphql.AddErrorf(ctx, "Failed to merge organization %s into organization %s", mergedOrganizationID, primaryOrganizationID)
			return nil, err
		}
	}

	organizationEntityPtr, err := r.Services.OrganizationService.GetById(ctx, primaryOrganizationID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to get organization by id %s", primaryOrganizationID)
		return nil, err
	}
	return mapper.MapEntityToOrganization(organizationEntityPtr), nil
}

// OrganizationAddSubsidiary is the resolver for the organization_AddSubsidiary field.
func (r *mutationResolver) OrganizationAddSubsidiary(ctx context.Context, input model.LinkOrganizationsInput) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationAddSubsidiary", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	tracing.LogObjectAsJson(span, "input", input)

	err := r.Services.OrganizationService.AddSubsidiary(ctx, input.OrganizationID, input.SubsidiaryID, utils.IfNotNilString(input.Type))
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "failed to add subsidiary %s to organization %s", input.SubsidiaryID, input.OrganizationID)
		return nil, nil
	}
	organizationEntity, err := r.Services.OrganizationService.GetById(ctx, input.OrganizationID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "failed to fetch organization details: %s", input.OrganizationID)
		return nil, nil
	}
	return mapper.MapEntityToOrganization(organizationEntity), nil
}

// OrganizationRemoveSubsidiary is the resolver for the organization_RemoveSubsidiary field.
func (r *mutationResolver) OrganizationRemoveSubsidiary(ctx context.Context, organizationID string, subsidiaryID string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationRemoveSubsidiary", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", organizationID), log.String("request.subsidiaryID", subsidiaryID))

	err := r.Services.OrganizationService.RemoveSubsidiary(ctx, organizationID, subsidiaryID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to remove subsidiary %s from organization %s", subsidiaryID, organizationID)
		return nil, err
	}
	organizationEntity, err := r.Services.OrganizationService.GetById(ctx, organizationID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to fetch organization %s", organizationID)
		return nil, err
	}
	return mapper.MapEntityToOrganization(organizationEntity), nil
}

// OrganizationAddNewLocation is the resolver for the organization_AddNewLocation field.
func (r *mutationResolver) OrganizationAddNewLocation(ctx context.Context, organizationID string) (*model.Location, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationAddNewLocation", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", organizationID))

	locationEntity, err := r.Services.LocationService.CreateLocationForEntity(ctx, entity.ORGANIZATION, organizationID, entity.SourceFields{
		Source:        neo4jentity.DataSourceOpenline,
		SourceOfTruth: neo4jentity.DataSourceOpenline,
		AppSource:     constants.AppSourceCustomerOsApi,
	})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Error creating location for organization %s", organizationID)
		return nil, err
	}
	return mapper.MapEntityToLocation(locationEntity), nil
}

// OrganizationAddSocial is the resolver for the organization_AddSocial field.
func (r *mutationResolver) OrganizationAddSocial(ctx context.Context, organizationID string, input model.SocialInput) (*model.Social, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationAddSocial", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", organizationID))

	socialEntity, err := r.Services.SocialService.CreateSocialForEntity(ctx, entity.ORGANIZATION, organizationID, *mapper.MapSocialInputToEntity(&input))
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Error creating social for organization %s", organizationID)
		return nil, err
	}
	return mapper.MapEntityToSocial(socialEntity), nil
}

// OrganizationSetOwner is the resolver for the organization_SetOwner field.
func (r *mutationResolver) OrganizationSetOwner(ctx context.Context, organizationID string, userID string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationSetOwner", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", organizationID), log.String("request.userID", userID))

	organizationEntity, err := r.Services.OrganizationService.ReplaceOwner(ctx, organizationID, userID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to set owner %s for organization %s", userID, organizationID)
		return nil, nil
	}
	return mapper.MapEntityToOrganization(organizationEntity), nil
}

// OrganizationUnsetOwner is the resolver for the organization_UnsetOwner field.
func (r *mutationResolver) OrganizationUnsetOwner(ctx context.Context, organizationID string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationUnsetOwner", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", organizationID))

	organizationEntity, err := r.Services.OrganizationService.RemoveOwner(ctx, organizationID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to remove owner for organization %s", organizationID)
		return nil, nil
	}
	return mapper.MapEntityToOrganization(organizationEntity), nil
}

// OrganizationUpdateOnboardingStatus is the resolver for the organization_UpdateOnboardingStatus field.
func (r *mutationResolver) OrganizationUpdateOnboardingStatus(ctx context.Context, input model.OnboardingStatusInput) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationUpdateOnboardingStatus", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.SetTag(tracing.SpanTagEntityId, input.OrganizationID)
	span.LogFields(log.String("request.OrganizationId", input.OrganizationID), log.Object("request.Status", input.Status), log.String("request.Comments", utils.IfNotNilString(input.Comments)))

	grpcRequest := organizationpb.UpdateOnboardingStatusGrpcRequest{
		Tenant:         common.GetTenantFromContext(ctx),
		OrganizationId: input.OrganizationID,
		LoggedInUserId: common.GetUserIdFromContext(ctx),
		Comments:       utils.IfNotNilString(input.Comments),
		AppSource:      constants.AppSourceCustomerOsApi,
	}
	switch input.Status {
	case model.OnboardingStatusNotApplicable:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_NOT_APPLICABLE
	case model.OnboardingStatusNotStarted:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_NOT_STARTED
	case model.OnboardingStatusOnTrack:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_ON_TRACK
	case model.OnboardingStatusLate:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_LATE
	case model.OnboardingStatusStuck:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_STUCK
	case model.OnboardingStatusDone:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_DONE
	case model.OnboardingStatusSuccessful:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_SUCCESSFUL
	default:
		grpcRequest.OnboardingStatus = organizationpb.OnboardingStatus_ONBOARDING_STATUS_NOT_APPLICABLE
	}

	ctx = commonTracing.InjectSpanContextIntoGrpcMetadata(ctx, span)
	_, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
		return r.Clients.OrganizationClient.UpdateOnboardingStatus(ctx, &grpcRequest)
	})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to update onboarding status for organization %s", input.OrganizationID)
	}
	organizationEntity, err := r.Services.OrganizationService.GetById(ctx, input.OrganizationID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to fetch organization %s", input.OrganizationID)
		return nil, nil
	}
	return mapper.MapEntityToOrganization(organizationEntity), nil
}

// OrganizationUnlinkAllDomains is the resolver for the organization_UnlinkAllDomains field.
func (r *mutationResolver) OrganizationUnlinkAllDomains(ctx context.Context, organizationID string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "MutationResolver.OrganizationUnlinkAllDomains", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", organizationID))

	organizationEntity, err := r.Services.OrganizationService.GetById(ctx, organizationID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to fetch organization %s", organizationID)
		return nil, nil
	}
	outputOrganization := mapper.MapEntityToOrganization(organizationEntity)

	domainEntities, err := r.Services.DomainService.GetDomainsForOrganizations(ctx, []string{organizationID})
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to get domains for organization %s", organizationID)
		return outputOrganization, nil
	}
	if domainEntities != nil {
		for _, domainEntity := range *domainEntities {
			_, err := utils.CallEventsPlatformGRPCWithRetry[*organizationpb.OrganizationIdGrpcResponse](func() (*organizationpb.OrganizationIdGrpcResponse, error) {
				return r.Clients.OrganizationClient.UnlinkDomainFromOrganization(ctx, &organizationpb.UnLinkDomainFromOrganizationGrpcRequest{
					Tenant:         common.GetTenantFromContext(ctx),
					OrganizationId: organizationID,
					LoggedInUserId: common.GetUserIdFromContext(ctx),
					Domain:         domainEntity.Domain,
				})
			})
			if err != nil {
				tracing.TraceErr(span, err)
				graphql.AddErrorf(ctx, "Failed to unlink domain %s from organization %s", domainEntity.Domain, organizationID)
				r.log.Errorf("Failed to unlink domain %s from organization %s: %s", domainEntity.Domain, organizationID, err.Error())
			}
		}
	}

	return outputOrganization, nil
}

// Contracts is the resolver for the contracts field.
func (r *organizationResolver) Contracts(ctx context.Context, obj *model.Organization) ([]*model.Contract, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	contractEntities, err := dataloader.For(ctx).GetContractsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get contracts for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get contracts for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToContracts(contractEntities), nil
}

// CustomFields is the resolver for the customFields field.
func (r *organizationResolver) CustomFields(ctx context.Context, obj *model.Organization) ([]*model.CustomField, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "OrganizationResolver.CustomFields", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", obj.ID))

	var customFields []*model.CustomField
	entityType := &model.CustomFieldEntityType{
		ID:         obj.ID,
		EntityType: model.EntityTypeOrganization,
	}
	customFieldEntities, err := r.Services.CustomFieldService.GetCustomFields(ctx, entityType)
	for _, v := range mapper.MapEntitiesToCustomFields(customFieldEntities) {
		customFields = append(customFields, v)
	}
	return customFields, err
}

// Domains is the resolver for the domains field.
func (r *organizationResolver) Domains(ctx context.Context, obj *model.Organization) ([]string, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	domainEntities, err := dataloader.For(ctx).GetDomainsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get domains for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get domains for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToDomainNames(domainEntities), nil
}

// Locations is the resolver for the locations field.
func (r *organizationResolver) Locations(ctx context.Context, obj *model.Organization) ([]*model.Location, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	locationEntities, err := dataloader.For(ctx).GetLocationsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get locations for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get locations for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToLocations(locationEntities), err
}

// Owner is the resolver for the owner field.
func (r *organizationResolver) Owner(ctx context.Context, obj *model.Organization) (*model.User, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	userEntityNillable, err := dataloader.For(ctx).GetUserOwnerForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Error fetching user owner for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Error fetching user owner for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntityToUser(userEntityNillable), nil
}

// ParentCompanies is the resolver for the parentCompanies field.
func (r *organizationResolver) ParentCompanies(ctx context.Context, obj *model.Organization) ([]*model.LinkedOrganization, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	organizationEntities, err := dataloader.For(ctx).GetSubsidiariesOfForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to fetch parent organizations for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to fetch parent organizations for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToLinkedOrganizations(organizationEntities), nil
}

// SocialMedia is the resolver for the socialMedia field.
func (r *organizationResolver) SocialMedia(ctx context.Context, obj *model.Organization) ([]*model.Social, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	socialEntities, err := dataloader.For(ctx).GetSocialsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get socials for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get socials for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToSocials(socialEntities), err
}

// Subsidiaries is the resolver for the subsidiaries field.
func (r *organizationResolver) Subsidiaries(ctx context.Context, obj *model.Organization) ([]*model.LinkedOrganization, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	organizationEntities, err := dataloader.For(ctx).GetSubsidiariesForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to fetch subsidiary organizations for orgnization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to fetch subsidiary organizations for orgnization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToLinkedOrganizations(organizationEntities), nil
}

// Tags is the resolver for the tags field.
func (r *organizationResolver) Tags(ctx context.Context, obj *model.Organization) ([]*model.Tag, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	tagEntities, err := dataloader.For(ctx).GetTagsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get tags for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get tags for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToTags(tagEntities), nil
}

// TimelineEvents is the resolver for the timelineEvents field.
func (r *organizationResolver) TimelineEvents(ctx context.Context, obj *model.Organization, from *time.Time, size int, timelineEventTypes []model.TimelineEventType) ([]model.TimelineEvent, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "OrganizationResolver.TimelineEvents", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", obj.ID), log.Int("request.size", size), log.Object("request.timelineEventTypes", timelineEventTypes))
	if from != nil {
		span.LogFields(log.Object("request.from", *from))
	}

	timelineEvents, err := r.Services.TimelineEventService.GetTimelineEventsForOrganization(ctx, obj.ID, from, size, timelineEventTypes)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "failed to get timeline events for organization %s", obj.ID)
		return nil, err
	}
	return mapper.MapEntitiesToTimelineEvents(timelineEvents), nil
}

// Contacts is the resolver for the contacts field.
func (r *organizationResolver) Contacts(ctx context.Context, obj *model.Organization, pagination *model.Pagination, where *model.Filter, sort []*model.SortBy) (*model.ContactsPage, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "OrganizationResolver.Contacts", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", obj.ID))

	if pagination == nil {
		pagination = &model.Pagination{Page: 0, Limit: 0}
	}
	paginatedResult, err := r.Services.ContactService.GetContactsForOrganization(ctx, obj.ID, pagination.Page, pagination.Limit, where, sort)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Could not fetch contacts for organization %s", obj.ID)
		return nil, err
	}
	return &model.ContactsPage{
		Content:       mapper.MapEntitiesToContacts(paginatedResult.Rows.(*entity.ContactEntities)),
		TotalPages:    paginatedResult.TotalPages,
		TotalElements: paginatedResult.TotalRows,
	}, err
}

// JobRoles is the resolver for the jobRoles field.
func (r *organizationResolver) JobRoles(ctx context.Context, obj *model.Organization) ([]*model.JobRole, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	jobRoleEntities, err := dataloader.For(ctx).GetJobRolesForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get job roles for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get job roles for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToJobRoles(jobRoleEntities), err
}

// Emails is the resolver for the emails field.
func (r *organizationResolver) Emails(ctx context.Context, obj *model.Organization) ([]*model.Email, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	emailEntities, err := dataloader.For(ctx).GetEmailsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get emails for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get emails for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToEmails(emailEntities), nil
}

// PhoneNumbers is the resolver for the phoneNumbers field.
func (r *organizationResolver) PhoneNumbers(ctx context.Context, obj *model.Organization) ([]*model.PhoneNumber, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	phoneNumberEntities, err := dataloader.For(ctx).GetPhoneNumbersForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get phone numbers for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get phone numbers for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToPhoneNumbers(phoneNumberEntities), nil
}

// SuggestedMergeTo is the resolver for the suggestedMergeTo field.
func (r *organizationResolver) SuggestedMergeTo(ctx context.Context, obj *model.Organization) ([]*model.SuggestedMergeOrganization, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	organizationEntities, err := dataloader.For(ctx).GetSuggestedMergeToForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to fetch suggested merge to organizations for input org id %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to fetch suggested merge to organizations for input org id %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToSuggestedMergeOrganizations(organizationEntities), nil
}

// FieldSets is the resolver for the fieldSets field.
func (r *organizationResolver) FieldSets(ctx context.Context, obj *model.Organization) ([]*model.FieldSet, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "OrganizationResolver.FieldSets", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", obj.ID))

	entityType := &model.CustomFieldEntityType{ID: obj.ID, EntityType: model.EntityTypeOrganization}
	fieldSetEntities, err := r.Services.FieldSetService.FindAll(ctx, entityType)
	return mapper.MapEntitiesToFieldSets(fieldSetEntities), err
}

// EntityTemplate is the resolver for the entityTemplate field.
func (r *organizationResolver) EntityTemplate(ctx context.Context, obj *model.Organization) (*model.EntityTemplate, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "OrganizationResolver.EntityTemplate", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", obj.ID))

	entityType := &model.CustomFieldEntityType{ID: obj.ID, EntityType: model.EntityTypeOrganization}
	templateEntity, err := r.Services.EntityTemplateService.FindLinked(ctx, entityType)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to get contact template for contact %s", obj.ID)
		return nil, err
	}
	if templateEntity == nil {
		return nil, nil
	}
	return mapper.MapEntityToEntityTemplate(templateEntity), err
}

// TimelineEventsTotalCount is the resolver for the timelineEventsTotalCount field.
func (r *organizationResolver) TimelineEventsTotalCount(ctx context.Context, obj *model.Organization, timelineEventTypes []model.TimelineEventType) (int64, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "OrganizationResolver.TimelineEventsTotalCount", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", obj.ID), log.Object("request.timelineEventTypes", timelineEventTypes))

	count, err := r.Services.TimelineEventService.GetTimelineEventsTotalCountForOrganization(ctx, obj.ID, timelineEventTypes)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "failed to get timeline events total count for organization %s", obj.ID)
		return int64(0), err
	}
	return count, nil
}

// ExternalLinks is the resolver for the externalLinks field.
func (r *organizationResolver) ExternalLinks(ctx context.Context, obj *model.Organization) ([]*model.ExternalSystem, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	entities, err := dataloader.For(ctx).GetExternalSystemsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get external system for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get external system for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToExternalSystems(entities), nil
}

// IssueSummaryByStatus is the resolver for the issueSummaryByStatus field.
func (r *organizationResolver) IssueSummaryByStatus(ctx context.Context, obj *model.Organization) ([]*model.IssueSummaryByStatus, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "OrganizationResolver.IssueSummaryByStatus", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", obj.ID))

	issueCountByStatus, err := r.Services.IssueService.GetIssueSummaryByStatusForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to get issue summary by status for organization %s", obj.ID)
		return nil, err
	}
	issueSummaryByStatus := make([]*model.IssueSummaryByStatus, 0)
	for key, value := range issueCountByStatus {
		issueSummaryByStatus = append(issueSummaryByStatus, &model.IssueSummaryByStatus{
			Status: key,
			Count:  value,
		})
	}
	return issueSummaryByStatus, nil
}

// Orders is the resolver for the orders field.
func (r *organizationResolver) Orders(ctx context.Context, obj *model.Organization) ([]*model.Order, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	entities, err := dataloader.For(ctx).GetOrdersForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get orders for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get orders for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToOrders(entities), err
}

// ContactCount is the resolver for the contactCount field.
func (r *organizationResolver) ContactCount(ctx context.Context, obj *model.Organization) (int64, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	contactCount, err := dataloader.For(ctx).GetContactCountForOrganization(ctx, obj.Metadata.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("error fetching contact count for organization %s: %s", obj.Metadata.ID, err.Error())
		graphql.AddErrorf(ctx, "Error fetching contact count for organization %s", obj.Metadata.ID)
		return 0, nil
	}
	return contactCount, nil
}

// InboundCommsCount is the resolver for the inboundCommsCount field.
func (r *organizationResolver) InboundCommsCount(ctx context.Context, obj *model.Organization) (int64, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	inboundCommsCount, err := dataloader.For(ctx).GetInboundCommsCountForOrganization(ctx, obj.Metadata.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("error fetching inbound comms count for organization %s: %s", obj.Metadata.ID, err.Error())
		graphql.AddErrorf(ctx, "Error fetching inbound comms count for organization %s", obj.Metadata.ID)
		return 0, nil
	}
	return inboundCommsCount, nil
}

// OutboundCommsCount is the resolver for the outboundCommsCount field.
func (r *organizationResolver) OutboundCommsCount(ctx context.Context, obj *model.Organization) (int64, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	inboundCommsCount, err := dataloader.For(ctx).GetOutboundCommsCountForOrganization(ctx, obj.Metadata.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("error fetching outbound comms count for organization %s: %s", obj.Metadata.ID, err.Error())
		graphql.AddErrorf(ctx, "Error fetching outbound comms count for organization %s", obj.Metadata.ID)
		return 0, nil
	}
	return inboundCommsCount, nil
}

// Socials is the resolver for the socials field.
func (r *organizationResolver) Socials(ctx context.Context, obj *model.Organization) ([]*model.Social, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	socialEntities, err := dataloader.For(ctx).GetSocialsForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to get socials for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to get socials for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToSocials(socialEntities), err
}

// LastTouchPointTimelineEvent is the resolver for the lastTouchPointTimelineEvent field.
func (r *organizationResolver) LastTouchPointTimelineEvent(ctx context.Context, obj *model.Organization) (model.TimelineEvent, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	if obj.LastTouchPointTimelineEventID == nil {
		return nil, nil
	}

	timelineEventNillable, err := dataloader.For(ctx).GetTimelineEventForTimelineEventId(ctx, *obj.LastTouchPointTimelineEventID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Error fetching last touchpoint timeline event for organization %s: %s", *obj.LastTouchPointTimelineEventID, err.Error())
		graphql.AddErrorf(ctx, "Error fetching last touchpoint timeline event for organization %s", *obj.LastTouchPointTimelineEventID)
		return nil, err
	}
	return mapper.MapEntityToTimelineEvent(timelineEventNillable), nil
}

// SubsidiaryOf is the resolver for the subsidiaryOf field.
func (r *organizationResolver) SubsidiaryOf(ctx context.Context, obj *model.Organization) ([]*model.LinkedOrganization, error) {
	ctx = tracing.EnrichCtxWithSpanCtxForGraphQL(ctx, graphql.GetOperationContext(ctx))

	organizationEntities, err := dataloader.For(ctx).GetSubsidiariesOfForOrganization(ctx, obj.ID)
	if err != nil {
		tracing.TraceErr(opentracing.SpanFromContext(ctx), err)
		r.log.Errorf("Failed to fetch parent organizations for organization %s: %s", obj.ID, err.Error())
		graphql.AddErrorf(ctx, "Failed to fetch parent organizations for organization %s", obj.ID)
		return nil, nil
	}
	return mapper.MapEntitiesToLinkedOrganizations(organizationEntities), nil
}

// Organizations is the resolver for the organizations field.
func (r *queryResolver) Organizations(ctx context.Context, pagination *model.Pagination, where *model.Filter, sort []*model.SortBy) (*model.OrganizationPage, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "QueryResolver.Organizations", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)

	if pagination == nil {
		pagination = &model.Pagination{Page: 0, Limit: 0}
	}
	span.LogFields(log.Int("request.pagination.page", pagination.Page), log.Int("request.pagination.limit", pagination.Limit))
	if where != nil {
		tracing.LogObjectAsJson(span, "request.where", *where)
	}
	if sort != nil {
		tracing.LogObjectAsJson(span, "request.sort", sort)
	}

	paginatedResult, err := r.Services.OrganizationService.FindAll(ctx, pagination.Page, pagination.Limit, where, sort)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Could not fetch organizations")
		return nil, err
	}
	return &model.OrganizationPage{
		Content:       mapper.MapEntitiesToOrganizations(paginatedResult.Rows.(*neo4jentity.OrganizationEntities)),
		TotalPages:    paginatedResult.TotalPages,
		TotalElements: paginatedResult.TotalRows,
	}, err
}

// Organization is the resolver for the organization field.
func (r *queryResolver) Organization(ctx context.Context, id string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "QueryResolver.Organization", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.organizationID", id))

	if id == "" {
		tracing.TraceErr(span, errors.New("missing organization id"))
		graphql.AddErrorf(ctx, "Missing organization id")
		return nil, nil
	}

	organizationEntityPtr, err := r.Services.OrganizationService.GetById(ctx, id)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Failed to get organization by id %s", id)
		return nil, err
	}
	return mapper.MapEntityToOrganization(organizationEntityPtr), nil
}

// OrganizationByCustomerOsID is the resolver for the organization_ByCustomerOsId field.
func (r *queryResolver) OrganizationByCustomerOsID(ctx context.Context, customerOsID string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "QueryResolver.OrganizationByCustomerOsID", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.customerOsID", customerOsID))

	if customerOsID == "" {
		tracing.TraceErr(span, errors.New("missing customerOsId"))
		graphql.AddErrorf(ctx, "Missing customerOsId")
		return nil, nil
	}

	organizationEntityPtr, err := r.Services.OrganizationService.GetByCustomerOsId(ctx, customerOsID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Error getting organization not found by customerOsId %s", customerOsID)
		return nil, nil
	}
	if organizationEntityPtr == nil {
		err = errors.New("organization not found")
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Organization not found by customerOsId %s", customerOsID)
		return nil, nil
	}
	return mapper.MapEntityToOrganization(organizationEntityPtr), nil
}

// OrganizationByCustomID is the resolver for the organization_ByCustomId field.
func (r *queryResolver) OrganizationByCustomID(ctx context.Context, customID string) (*model.Organization, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "QueryResolver.OrganizationByCustomID", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)
	span.LogFields(log.String("request.customID", customID))

	if customID == "" {
		tracing.TraceErr(span, errors.New("missing customID"))
		graphql.AddErrorf(ctx, "Missing customID")
		return nil, nil
	}

	organizationEntityPtr, err := r.Services.OrganizationService.GetByReferenceId(ctx, customID)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Error getting organization not found by customId %s", customID)
		return nil, nil
	}
	if organizationEntityPtr == nil {
		err = errors.New("organization not found")
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Organization not found by customId %s", customID)
		return nil, nil
	}
	return mapper.MapEntityToOrganization(organizationEntityPtr), nil
}

// OrganizationDistinctOwners is the resolver for the organization_DistinctOwners field.
func (r *queryResolver) OrganizationDistinctOwners(ctx context.Context) ([]*model.User, error) {
	ctx, span := tracing.StartGraphQLTracerSpan(ctx, "QueryResolver.OrganizationDistinctOwners", graphql.GetOperationContext(ctx))
	defer span.Finish()
	tracing.SetDefaultResolverSpanTags(ctx, span)

	userEntities, err := r.Services.UserService.GetDistinctOrganizationOwners(ctx)
	if err != nil {
		tracing.TraceErr(span, err)
		graphql.AddErrorf(ctx, "Error fetching organization owners")
		return nil, nil
	}
	return mapper.MapEntitiesToUsers(userEntities), nil
}

// LastTouchpoint returns generated.LastTouchpointResolver implementation.
func (r *Resolver) LastTouchpoint() generated.LastTouchpointResolver {
	return &lastTouchpointResolver{r}
}

// Organization returns generated.OrganizationResolver implementation.
func (r *Resolver) Organization() generated.OrganizationResolver { return &organizationResolver{r} }

type lastTouchpointResolver struct{ *Resolver }
type organizationResolver struct{ *Resolver }