edge_cleanup.go

// Code generated by ent, DO NOT EDIT.

package generated

import (
	"context"

	"entgo.io/ent/privacy"
	"github.com/datumforge/datum/internal/ent/generated/documentdata"
	"github.com/datumforge/datum/internal/ent/generated/emailverificationtoken"
	"github.com/datumforge/datum/internal/ent/generated/group"
	"github.com/datumforge/datum/internal/ent/generated/groupmembership"
	"github.com/datumforge/datum/internal/ent/generated/groupsetting"
	"github.com/datumforge/datum/internal/ent/generated/integration"
	"github.com/datumforge/datum/internal/ent/generated/invite"
	"github.com/datumforge/datum/internal/ent/generated/organization"
	"github.com/datumforge/datum/internal/ent/generated/organizationsetting"
	"github.com/datumforge/datum/internal/ent/generated/orgmembership"
	"github.com/datumforge/datum/internal/ent/generated/passwordresettoken"
	"github.com/datumforge/datum/internal/ent/generated/personalaccesstoken"
	"github.com/datumforge/datum/internal/ent/generated/subscriber"
	"github.com/datumforge/datum/internal/ent/generated/template"
	"github.com/datumforge/datum/internal/ent/generated/tfasetting"
	"github.com/datumforge/datum/internal/ent/generated/user"
	"github.com/datumforge/datum/internal/ent/generated/usersetting"
	"github.com/datumforge/datum/internal/ent/generated/webauthn"
	"github.com/datumforge/datum/internal/ent/generated/webhook"
)

func APITokenEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup apitoken edge"))

	return nil
}

func DocumentDataEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup documentdata edge"))

	return nil
}

func DocumentDataHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup documentdatahistory edge"))

	return nil
}

func EmailVerificationTokenEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup emailverificationtoken edge"))

	return nil
}

func EntitlementEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup entitlement edge"))

	return nil
}

func EntitlementHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup entitlementhistory edge"))

	return nil
}

func EventEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup event edge"))

	return nil
}

func EventHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup eventhistory edge"))

	return nil
}

func FeatureEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup feature edge"))

	return nil
}

func FeatureHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup featurehistory edge"))

	return nil
}

func FileEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup file edge"))

	return nil
}

func FileHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup filehistory edge"))

	return nil
}

func GroupEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup group edge"))

	if exists, err := FromContext(ctx).GroupSetting.Query().Where((groupsetting.HasGroupWith(group.ID(id)))).Exist(ctx); err == nil && exists {
		if groupsettingCount, err := FromContext(ctx).GroupSetting.Delete().Where(groupsetting.HasGroupWith(group.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting groupsetting", "count", groupsettingCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).GroupMembership.Query().Where((groupmembership.HasGroupWith(group.ID(id)))).Exist(ctx); err == nil && exists {
		if groupmembershipCount, err := FromContext(ctx).GroupMembership.Delete().Where(groupmembership.HasGroupWith(group.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting groupmembership", "count", groupmembershipCount, "err", err)
			return err
		}
	}

	return nil
}

func GroupHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup grouphistory edge"))

	return nil
}

func GroupMembershipEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup groupmembership edge"))

	return nil
}

func GroupMembershipHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup groupmembershiphistory edge"))

	return nil
}

func GroupSettingEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup groupsetting edge"))

	return nil
}

func GroupSettingHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup groupsettinghistory edge"))

	return nil
}

func HushEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup hush edge"))

	return nil
}

func HushHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup hushhistory edge"))

	return nil
}

func IntegrationEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup integration edge"))

	return nil
}

func IntegrationHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup integrationhistory edge"))

	return nil
}

func InviteEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup invite edge"))

	return nil
}

func OauthProviderEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup oauthprovider edge"))

	return nil
}

func OauthProviderHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup oauthproviderhistory edge"))

	return nil
}

func OhAuthTooTokenEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup ohauthtootoken edge"))

	return nil
}

func OrgMembershipEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup orgmembership edge"))

	return nil
}

func OrgMembershipHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup orgmembershiphistory edge"))

	return nil
}

func OrganizationEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup organization edge"))

	if exists, err := FromContext(ctx).Organization.Query().Where(organization.HasParentWith(organization.ID(id))).Exist(ctx); err == nil && exists {
		if organizationCount, err := FromContext(ctx).Organization.Delete().Where(organization.HasParentWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting child organization", "count", organizationCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).Group.Query().Where((group.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if groupCount, err := FromContext(ctx).Group.Delete().Where(group.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting group", "count", groupCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).Template.Query().Where((template.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if templateCount, err := FromContext(ctx).Template.Delete().Where(template.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting template", "count", templateCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).Integration.Query().Where((integration.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if integrationCount, err := FromContext(ctx).Integration.Delete().Where(integration.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting integration", "count", integrationCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).OrganizationSetting.Query().Where((organizationsetting.HasOrganizationWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if organizationsettingCount, err := FromContext(ctx).OrganizationSetting.Delete().Where(organizationsetting.HasOrganizationWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting organizationsetting", "count", organizationsettingCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).Invite.Query().Where((invite.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if inviteCount, err := FromContext(ctx).Invite.Delete().Where(invite.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting invite", "count", inviteCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).Subscriber.Query().Where((subscriber.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if subscriberCount, err := FromContext(ctx).Subscriber.Delete().Where(subscriber.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting subscriber", "count", subscriberCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).Webhook.Query().Where((webhook.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if webhookCount, err := FromContext(ctx).Webhook.Delete().Where(webhook.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting webhook", "count", webhookCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).OrgMembership.Query().Where((orgmembership.HasOrganizationWith(organization.ID(id)))).Exist(ctx); err == nil && exists {
		if orgmembershipCount, err := FromContext(ctx).OrgMembership.Delete().Where(orgmembership.HasOrganizationWith(organization.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting orgmembership", "count", orgmembershipCount, "err", err)
			return err
		}
	}

	return nil
}

func OrganizationHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup organizationhistory edge"))

	return nil
}

func OrganizationSettingEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup organizationsetting edge"))

	return nil
}

func OrganizationSettingHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup organizationsettinghistory edge"))

	return nil
}

func PasswordResetTokenEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup passwordresettoken edge"))

	return nil
}

func PersonalAccessTokenEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup personalaccesstoken edge"))

	return nil
}

func SubscriberEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup subscriber edge"))

	return nil
}

func TFASettingEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup tfasetting edge"))

	return nil
}

func TemplateEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup template edge"))

	if exists, err := FromContext(ctx).DocumentData.Query().Where((documentdata.HasTemplateWith(template.ID(id)))).Exist(ctx); err == nil && exists {
		if documentdataCount, err := FromContext(ctx).DocumentData.Delete().Where(documentdata.HasTemplateWith(template.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting documentdata", "count", documentdataCount, "err", err)
			return err
		}
	}

	return nil
}

func TemplateHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup templatehistory edge"))

	return nil
}

func UserEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup user edge"))

	if exists, err := FromContext(ctx).PersonalAccessToken.Query().Where((personalaccesstoken.HasOwnerWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if personalaccesstokenCount, err := FromContext(ctx).PersonalAccessToken.Delete().Where(personalaccesstoken.HasOwnerWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting personalaccesstoken", "count", personalaccesstokenCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).TFASetting.Query().Where((tfasetting.HasOwnerWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if tfasettingCount, err := FromContext(ctx).TFASetting.Delete().Where(tfasetting.HasOwnerWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting tfasetting", "count", tfasettingCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).UserSetting.Query().Where((usersetting.HasUserWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if usersettingCount, err := FromContext(ctx).UserSetting.Delete().Where(usersetting.HasUserWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting usersetting", "count", usersettingCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).EmailVerificationToken.Query().Where((emailverificationtoken.HasOwnerWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if emailverificationtokenCount, err := FromContext(ctx).EmailVerificationToken.Delete().Where(emailverificationtoken.HasOwnerWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting emailverificationtoken", "count", emailverificationtokenCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).PasswordResetToken.Query().Where((passwordresettoken.HasOwnerWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if passwordresettokenCount, err := FromContext(ctx).PasswordResetToken.Delete().Where(passwordresettoken.HasOwnerWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting passwordresettoken", "count", passwordresettokenCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).Webauthn.Query().Where((webauthn.HasOwnerWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if webauthnCount, err := FromContext(ctx).Webauthn.Delete().Where(webauthn.HasOwnerWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting webauthn", "count", webauthnCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).OrgMembership.Query().Where((orgmembership.HasUserWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if orgmembershipCount, err := FromContext(ctx).OrgMembership.Delete().Where(orgmembership.HasUserWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting orgmembership", "count", orgmembershipCount, "err", err)
			return err
		}
	}

	if exists, err := FromContext(ctx).GroupMembership.Query().Where((groupmembership.HasUserWith(user.ID(id)))).Exist(ctx); err == nil && exists {
		if groupmembershipCount, err := FromContext(ctx).GroupMembership.Delete().Where(groupmembership.HasUserWith(user.ID(id))).Exec(ctx); err != nil {
			FromContext(ctx).Logger.Debugw("deleting groupmembership", "count", groupmembershipCount, "err", err)
			return err
		}
	}

	return nil
}

func UserHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup userhistory edge"))

	return nil
}

func UserSettingEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup usersetting edge"))

	return nil
}

func UserSettingHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup usersettinghistory edge"))

	return nil
}

func WebauthnEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup webauthn edge"))

	return nil
}

func WebhookEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup webhook edge"))

	return nil
}

func WebhookHistoryEdgeCleanup(ctx context.Context, id string) error {
	// If a user has access to delete the object, they have access to delete all edges
	ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup webhookhistory edge"))

	return nil
}