Prescriptoo Docs

Appearance

usecase ​

go
import "github.com/prescriptoo/prescriptoo-api/services/doctor/internal/usecase"

Package usecase defines documentation-first doctor workflows and their future contracts.

Index ​

Variables ​

go
var (
    // ErrInvalidProfilePatch indicates an empty or invalid professional update.
    ErrInvalidProfilePatch = errors.New("invalid doctor profile update")
    // ErrProfileConflict indicates a duplicate license or conflicting profile update.
    ErrProfileConflict = errors.New("doctor profile update conflict")
)

go
var (
    // ErrInvalidRegistration indicates invalid identity or professional details.
    ErrInvalidRegistration = errors.New("invalid doctor registration details")
    // ErrRegistrationConflict indicates a duplicate doctor profile or license.
    ErrRegistrationConflict = errors.New("doctor profile already exists")
)

ErrNotImplemented marks an operation whose business behavior has not been implemented.

go
var ErrNotImplemented = errors.New("doctor operation is not implemented")

func LetterheadPolicy ​

go
func LetterheadPolicy() *bluemonday.Policy

LetterheadPolicy is the reviewed allowlist shared by saved prescriptions and pad settings. It permits no attributes, links, images or styles, so nothing external can load.

func ValidateProfessionalIDs ​

go
func ValidateProfessionalIDs(specialityID string, lists ...[]string) error

ValidateProfessionalIDs checks canonical identifiers, cardinality and duplicates.

type CancelDoctorJoinRequestInput ​

CancelDoctorJoinRequestInput contains the cancel doctor join request request parameters.

go
type CancelDoctorJoinRequestInput struct {
    Authorization string
    RequestID     string
}

type CancelDoctorJoinRequestUseCase ​

CancelDoctorJoinRequestUseCase defines the unimplemented cancel doctor join request operation.

go
type CancelDoctorJoinRequestUseCase struct{}

func NewCancelDoctorJoinRequestUseCase ​

go
func NewCancelDoctorJoinRequestUseCase() *CancelDoctorJoinRequestUseCase

NewCancelDoctorJoinRequestUseCase creates the documentation-first cancel doctor join request use case.

func (*CancelDoctorJoinRequestUseCase) Execute ​

go
func (uc *CancelDoctorJoinRequestUseCase) Execute(_ context.Context, _ CancelDoctorJoinRequestInput) (*organizationpublic.DoctorJoinRequest, error)

Execute returns ErrNotImplemented until the operation is implemented.

type ClinicalListChiefComplaintUseCase ​

ClinicalListChiefComplaintUseCase requires an active doctor before reading global choices.

go
type ClinicalListChiefComplaintUseCase struct {
    Verify  *VerifyAuthUseCase
    Service ports.DoctorClinicalService
}

func (ClinicalListChiefComplaintUseCase) Execute ​

go
func (uc ClinicalListChiefComplaintUseCase) Execute(ctx context.Context, authorization string, input c.SuggestionQuery) ([]c.ChiefComplaint, error)

Execute authenticates the current persistent doctor session and delegates the query.

func (ClinicalListChiefComplaintUseCase) Page ​

go
func (uc ClinicalListChiefComplaintUseCase) Page(ctx context.Context, in ClinicalPageInput) (c.Page[c.ChiefComplaint], error)

Page authenticates the Doctor before querying real, active catalogue rows.

type ClinicalListHistorySuggestionUseCase ​

ClinicalListHistorySuggestionUseCase requires an active doctor before reading global choices.

go
type ClinicalListHistorySuggestionUseCase struct {
    Verify  *VerifyAuthUseCase
    Service ports.DoctorClinicalService
}

func (ClinicalListHistorySuggestionUseCase) Execute ​

go
func (uc ClinicalListHistorySuggestionUseCase) Execute(ctx context.Context, authorization string, input c.HistorySuggestionQuery) ([]c.HistorySuggestion, error)

Execute authenticates the current persistent doctor session and delegates the query.

func (ClinicalListHistorySuggestionUseCase) Page ​

go
func (uc ClinicalListHistorySuggestionUseCase) Page(ctx context.Context, in ClinicalPageInput) (c.Page[c.HistorySuggestion], error)

Page authenticates the Doctor before querying real, active catalogue rows.

type ClinicalPageInput ​

ClinicalPageInput contains credentials and catalogue filters; no organization scope is needed.

go
type ClinicalPageInput struct {
    Authorization string
    Query         c.ScopedSuggestionQuery
}

type CreateDoctorJoinRequestInput ​

CreateDoctorJoinRequestInput contains the create doctor join request request parameters.

go
type CreateDoctorJoinRequestInput struct {
    Authorization string
    Params        CreateJoinRequestParams
}

type CreateDoctorJoinRequestUseCase ​

CreateDoctorJoinRequestUseCase defines the unimplemented create doctor join request operation.

go
type CreateDoctorJoinRequestUseCase struct{}

func NewCreateDoctorJoinRequestUseCase ​

go
func NewCreateDoctorJoinRequestUseCase() *CreateDoctorJoinRequestUseCase

NewCreateDoctorJoinRequestUseCase creates the documentation-first create doctor join request use case.

func (*CreateDoctorJoinRequestUseCase) Execute ​

go
func (uc *CreateDoctorJoinRequestUseCase) Execute(_ context.Context, _ CreateDoctorJoinRequestInput) (*organizationpublic.DoctorJoinRequest, error)

Execute returns ErrNotImplemented until the operation is implemented.

type CreateJoinRequestParams ​

CreateJoinRequestParams identifies the organization the authenticated doctor wants to join.

go
type CreateJoinRequestParams struct {
    OrganizationID string `json:"organization_id" minLength:"1"`
}

type CreatePatientInput ​

CreatePatientInput keeps HTTP credentials separate from verified service inputs.

go
type CreatePatientInput struct {
    Authorization, IdempotencyKey string
    Params                        types.CreatePatientParams
}

type CreatePatientUseCase ​

CreatePatientUseCase authenticates the acting user before invoking the patient service.

go
type CreatePatientUseCase struct {
    Identity types.IIdentityService
    Patients ports.PatientService
}

func (*CreatePatientUseCase) Execute ​

go
func (uc *CreatePatientUseCase) Execute(ctx context.Context, in CreatePatientInput) (*types.Patient, error)

Execute authenticates and executes the doctor patient operation.

type DiscoverOrganizationsInput ​

DiscoverOrganizationsInput contains the discover organizations request parameters.

go
type DiscoverOrganizationsInput struct {
    Authorization string
    Limit         int
    Cursor        string
}

type DiscoverOrganizationsUseCase ​

DiscoverOrganizationsUseCase authenticates doctors before reading organization summaries.

go
type DiscoverOrganizationsUseCase struct {
    // contains filtered or unexported fields
}

func NewDiscoverOrganizationsUseCase ​

go
func NewDiscoverOrganizationsUseCase(verify *VerifyAuthUseCase, organizations ports.DoctorOrganizationService) *DiscoverOrganizationsUseCase

NewDiscoverOrganizationsUseCase wires authentication and organization-owned discovery.

func (*DiscoverOrganizationsUseCase) Execute ​

go
func (uc *DiscoverOrganizationsUseCase) Execute(ctx context.Context, input DiscoverOrganizationsInput) (*types.DoctorOrganizationPage, error)

Execute lists active organizations without requiring an existing affiliation.

type DoctorOrganization ​

DoctorOrganization combines a doctor affiliation with its organization discovery summary.

go
type DoctorOrganization struct {
    Organization organizationpublic.OrganizationSummary `json:"organization"`
    Affiliation  organizationpublic.DoctorAffiliation   `json:"affiliation"`
}

type FinalPrescriptionUseCases ​

FinalPrescriptionUseCases verify the Doctor session before invoking real immutable-document capabilities.

go
type FinalPrescriptionUseCases struct {
    Verify  *VerifyAuthUseCase
    Service ports.FinalPrescriptionService
}

func (FinalPrescriptionUseCases) Get ​

go
func (uc FinalPrescriptionUseCases) Get(ctx context.Context, authorization string, in c.FinalPrescriptionReadInput) (*c.FinalPrescriptionRecord, error)

Get authenticates before a scoped archived-document read.

func (FinalPrescriptionUseCases) List ​

go
func (uc FinalPrescriptionUseCases) List(ctx context.Context, authorization string, in c.FinalPrescriptionListInput) (*c.FinalPrescriptionPage, error)

List authenticates before scoped summary browsing.

func (FinalPrescriptionUseCases) Save ​

go
func (uc FinalPrescriptionUseCases) Save(ctx context.Context, authorization string, in c.SaveFinalPrescriptionInput) (*c.FinalPrescriptionMetadata, error)

Save authenticates before attributing a final save to the verified author.

type GetPadSettingsInput ​

GetPadSettingsInput carries credentials only; ownership comes from the verified session.

go
type GetPadSettingsInput struct{ Authorization string }

type GetPadSettingsUseCase ​

GetPadSettingsUseCase reads the authenticated Doctor's saved pad design.

go
type GetPadSettingsUseCase struct {
    Verify *VerifyAuthUseCase
    Store  PadSettingsStore
}

func (GetPadSettingsUseCase) Execute ​

go
func (uc GetPadSettingsUseCase) Execute(ctx context.Context, in GetPadSettingsInput) (*domain.PadSettings, error)

Execute returns nil without an error when no design has been saved.

type GetPatientInput ​

GetPatientInput keeps HTTP credentials separate from verified service inputs.

go
type GetPatientInput struct{ Authorization, PatientID string }

type GetPatientUseCase ​

GetPatientUseCase authenticates the acting user before invoking the patient service.

go
type GetPatientUseCase struct {
    Identity types.IIdentityService
    Patients ports.PatientService
}

func (*GetPatientUseCase) Execute ​

go
func (uc *GetPatientUseCase) Execute(ctx context.Context, in GetPatientInput) (*types.Patient, error)

Execute authenticates and executes the doctor patient operation.

type ListAssignedOrganizationsInput ​

ListAssignedOrganizationsInput carries credentials, never a client-selected doctor ID.

go
type ListAssignedOrganizationsInput struct{ Authorization string }

type ListAssignedOrganizationsUseCase ​

ListAssignedOrganizationsUseCase authenticates the doctor before loading actual assignments.

go
type ListAssignedOrganizationsUseCase struct {
    Verify        *VerifyAuthUseCase
    Organizations ports.DoctorOrganizationService
}

func (ListAssignedOrganizationsUseCase) Execute ​

go
func (uc ListAssignedOrganizationsUseCase) Execute(ctx context.Context, in ListAssignedOrganizationsInput) ([]types.DoctorOrganizationAssignment, error)

Execute returns all active affiliations to active organizations for the verified profile.

type ListMyDoctorJoinRequestsInput ​

ListMyDoctorJoinRequestsInput contains the list my doctor join requests request parameters.

go
type ListMyDoctorJoinRequestsInput struct {
    Authorization string
    Limit         int
    Cursor        string
}

type ListMyDoctorJoinRequestsUseCase ​

ListMyDoctorJoinRequestsUseCase defines the unimplemented list my doctor join requests operation.

go
type ListMyDoctorJoinRequestsUseCase struct{}

func NewListMyDoctorJoinRequestsUseCase ​

go
func NewListMyDoctorJoinRequestsUseCase() *ListMyDoctorJoinRequestsUseCase

NewListMyDoctorJoinRequestsUseCase creates the documentation-first list my doctor join requests use case.

func (*ListMyDoctorJoinRequestsUseCase) Execute ​

go
func (uc *ListMyDoctorJoinRequestsUseCase) Execute(_ context.Context, _ ListMyDoctorJoinRequestsInput) (*Page[organizationpublic.DoctorJoinRequest], error)

Execute returns ErrNotImplemented until the operation is implemented.

type ListMyDoctorOrganizationsInput ​

ListMyDoctorOrganizationsInput contains the list my doctor organizations request parameters.

go
type ListMyDoctorOrganizationsInput struct {
    Authorization string
    Limit         int
    Cursor        string
}

type ListMyDoctorOrganizationsUseCase ​

ListMyDoctorOrganizationsUseCase defines the unimplemented list my doctor organizations operation.

go
type ListMyDoctorOrganizationsUseCase struct{}

func NewListMyDoctorOrganizationsUseCase ​

go
func NewListMyDoctorOrganizationsUseCase() *ListMyDoctorOrganizationsUseCase

NewListMyDoctorOrganizationsUseCase creates the documentation-first list my doctor organizations use case.

func (*ListMyDoctorOrganizationsUseCase) Execute ​

go
func (uc *ListMyDoctorOrganizationsUseCase) Execute(_ context.Context, _ ListMyDoctorOrganizationsInput) (*Page[DoctorOrganization], error)

Execute returns ErrNotImplemented until the operation is implemented.

type ListMyVerificationsInput ​

ListMyVerificationsInput contains the documentation-first request parameters.

go
type ListMyVerificationsInput struct {
    Authorization string
    Limit         int
    Cursor        string
    Status        string
}

type ListMyVerificationsUseCase ​

ListMyVerificationsUseCase defines the unimplemented list my doctor verifications operation.

go
type ListMyVerificationsUseCase struct{}

func NewListMyVerificationsUseCase ​

go
func NewListMyVerificationsUseCase() *ListMyVerificationsUseCase

NewListMyVerificationsUseCase creates the documentation-first operation.

func (*ListMyVerificationsUseCase) Execute ​

go
func (uc *ListMyVerificationsUseCase) Execute(_ context.Context, _ ListMyVerificationsInput) (*adminpublic.VerificationPage, error)

Execute returns a stub error without authentication, persistence or state changes.

type ListPatientsInput ​

ListPatientsInput keeps HTTP credentials separate from verified service inputs.

go
type ListPatientsInput struct {
    Authorization, OrganizationID, Query, Cursor string
    Limit                                        int
}

type ListPatientsUseCase ​

ListPatientsUseCase authenticates the acting user before invoking the patient service.

go
type ListPatientsUseCase struct {
    Identity types.IIdentityService
    Patients ports.PatientService
}

func (*ListPatientsUseCase) Execute ​

go
func (uc *ListPatientsUseCase) Execute(ctx context.Context, in ListPatientsInput) (*types.PatientPage, error)

Execute authenticates and executes the doctor patient operation.

type LoginInput ​

LoginInput carries credentials and trusted session metadata.

go
type LoginInput struct{ Email, Password, IPAddress, UserAgent string }

type LoginUseCase ​

LoginUseCase authenticates an active identity with a doctor profile.

go
type LoginUseCase struct {
    // contains filtered or unexported fields
}

func NewLoginUseCase ​

go
func NewLoginUseCase(authentication identitypublic.AuthenticationService, profiles ports.ProfileRepository) *LoginUseCase

NewLoginUseCase wires Identity authentication and doctor profile lookup.

func (*LoginUseCase) Execute ​

go
func (uc *LoginUseCase) Execute(ctx context.Context, input LoginInput) (*identitypublic.TokenPair, error)

Execute checks doctor eligibility before Identity creates credentials or a session.

type PadSettingsFieldError ​

PadSettingsFieldError identifies the first invalid field of a settings resource.

go
type PadSettingsFieldError struct{ Field, Message string }

func (*PadSettingsFieldError) Error ​

go
func (e *PadSettingsFieldError) Error() string

type PadSettingsStore ​

PadSettingsStore persists the account-scoped pad design. Get returns nil without an error when absent. Save is atomic: a nil expected revision creates only when absent, otherwise it updates only the stored revision. Both mismatches return domain.ErrPadSettingsConflict.

go
type PadSettingsStore interface {
    Get(ctx context.Context, userID string) (*domain.PadSettings, error)
    Save(ctx context.Context, doctorID, userID string, expectedRevision *int64, resourceVersion int, value domain.PadSettingsValue) (*domain.PadSettings, error)
}

type Page ​

Page is a cursor-paginated doctor API result.

go
type Page[T any] struct {
    Items      []T    `json:"items"`
    NextCursor string `json:"next_cursor,omitempty"`
}

type PatchMyDoctorProfileInput ​

PatchMyDoctorProfileInput edits the authenticated doctor's professional details.

go
type PatchMyDoctorProfileInput struct {
    Authorization string
    Params        PatchMyDoctorProfileParams
}

type PatchMyDoctorProfileParams ​

PatchMyDoctorProfileParams preserves omitted fields and replaces supplied selections.

go
type PatchMyDoctorProfileParams struct {
    LicenseNumber     *string   `json:"license_number,omitempty" nullable:"false" minLength:"1" maxLength:"255" pattern:"\\S"`
    SpecialityID      *string   `json:"speciality_id,omitempty" nullable:"false" format:"uuid"`
    SpecializationIDs *[]string `json:"specialization_ids,omitempty" nullable:"false" maxItems:"30" uniqueItems:"true"`
}

type PatchMyDoctorProfileUseCase ​

PatchMyDoctorProfileUseCase authorizes and persists self-service profile edits.

go
type PatchMyDoctorProfileUseCase struct {
    Verify *VerifyAuthUseCase
    Writer ProfilePatchWriter
}

func NewPatchMyDoctorProfileUseCase ​

go
func NewPatchMyDoctorProfileUseCase() *PatchMyDoctorProfileUseCase

NewPatchMyDoctorProfileUseCase creates a fail-closed operation awaiting providers.

func (*PatchMyDoctorProfileUseCase) Execute ​

go
func (uc *PatchMyDoctorProfileUseCase) Execute(ctx context.Context, input PatchMyDoctorProfileInput) (*doctorpublic.Profile, error)

Execute derives ownership from the verified session, never caller-selected IDs.

type PatchPatientInput ​

PatchPatientInput keeps HTTP credentials separate from verified service inputs.

go
type PatchPatientInput struct {
    Authorization, PatientID string
    Params                   types.PatchPatientParams
}

type PatchPatientUseCase ​

PatchPatientUseCase authenticates the acting user before invoking the patient service.

go
type PatchPatientUseCase struct {
    Identity types.IIdentityService
    Patients ports.PatientService
}

func (*PatchPatientUseCase) Execute ​

go
func (uc *PatchPatientUseCase) Execute(ctx context.Context, in PatchPatientInput) (*types.Patient, error)

Execute authenticates and executes the doctor patient operation.

type PreviewDoctorInvitationInput ​

PreviewDoctorInvitationInput contains the preview doctor invitation request parameters.

go
type PreviewDoctorInvitationInput struct {
    Token string
}

type PreviewDoctorInvitationUseCase ​

PreviewDoctorInvitationUseCase defines the unimplemented preview doctor invitation operation.

go
type PreviewDoctorInvitationUseCase struct{}

func NewPreviewDoctorInvitationUseCase ​

go
func NewPreviewDoctorInvitationUseCase() *PreviewDoctorInvitationUseCase

NewPreviewDoctorInvitationUseCase creates the documentation-first preview doctor invitation use case.

func (*PreviewDoctorInvitationUseCase) Execute ​

go
func (uc *PreviewDoctorInvitationUseCase) Execute(_ context.Context, _ PreviewDoctorInvitationInput) (*organizationpublic.InvitationPreview, error)

Execute returns ErrNotImplemented until the operation is implemented.

type ProfessionalSelectionWriter ​

ProfessionalSelectionWriter saves all selections in one transaction.

go
type ProfessionalSelectionWriter interface {
    ReplaceProfessionalSelections(context.Context, string, ProfessionalSelections) error
}

type ProfessionalSelections ​

ProfessionalSelections replaces all professional catalog selections atomically.

go
type ProfessionalSelections struct {
    QualificationIDs  []string `json:"qualification_ids" nullable:"false" maxItems:"30" uniqueItems:"true"`
    SpecialityID      string   `json:"speciality_id" format:"uuid"`
    SpecializationIDs []string `json:"specialization_ids" nullable:"false" maxItems:"30" uniqueItems:"true"`
}

type ProfilePatchWriter ​

ProfilePatchWriter atomically edits only supplied fields on the owned profile.

go
type ProfilePatchWriter interface {
    PatchProfile(context.Context, string, string, PatchMyDoctorProfileParams) (*domain.Profile, error)
}

type RegisterDoctorInput ​

RegisterDoctorInput contains the register doctor request parameters.

go
type RegisterDoctorInput struct {
    Params RegistrationParams
}

type RegisterDoctorUseCase ​

RegisterDoctorUseCase validates public signup and delegates atomic persistence.

go
type RegisterDoctorUseCase struct {
    // contains filtered or unexported fields
}

func NewRegisterDoctorUseCase ​

go
func NewRegisterDoctorUseCase(writer RegistrationWriter) *RegisterDoctorUseCase

NewRegisterDoctorUseCase wires the registration persistence capability.

func (*RegisterDoctorUseCase) Execute ​

go
func (uc *RegisterDoctorUseCase) Execute(ctx context.Context, input RegisterDoctorInput) (*RegistrationResult, error)

Execute creates an active account and professional profile without credentials.

type RegistrationParams ​

RegistrationParams contains identity and professional details for new doctor registration.

go
type RegistrationParams struct {
    Name              string   `json:"name" minLength:"1" maxLength:"255"`
    Email             string   `json:"email" format:"email" minLength:"1" maxLength:"255"`
    Password          string   `json:"password" minLength:"8" maxLength:"128" writeOnly:"true"`
    LicenseNumber     string   `json:"license_number" minLength:"1" maxLength:"255"`
    SpecialityID      string   `json:"speciality_id" format:"uuid"`
    SpecializationIDs []string `json:"specialization_ids,omitempty" nullable:"false" maxItems:"30" uniqueItems:"true"`
    InvitationToken   string   `json:"invitation_token,omitempty" maxLength:"512" writeOnly:"true" doc:"Optional organization invitation token. Omit or leave empty to register without joining an organization."`
}

type RegistrationResult ​

RegistrationResult contains the doctor profile and optional directly assigned affiliation; login is separate.

go
type RegistrationResult struct {
    Doctor      doctorpublic.Profile                  `json:"doctor"`
    Affiliation *organizationpublic.DoctorAffiliation `json:"affiliation,omitempty"`
}

type RegistrationWriter ​

RegistrationWriter atomically persists all records required for onboarding.

go
type RegistrationWriter interface {
    Register(context.Context, RegistrationParams) (*RegistrationResult, error)
}

type SavePadSettingsInput ​

SavePadSettingsInput replaces the complete design guarded by an optimistic revision.

go
type SavePadSettingsInput struct {
    Authorization    string
    ExpectedRevision *int64
    ResourceVersion  int
    Value            domain.PadSettingsValue
}

type SavePadSettingsUseCase ​

SavePadSettingsUseCase validates, sanitizes and atomically stores the authenticated Doctor's pad design.

go
type SavePadSettingsUseCase struct {
    Verify *VerifyAuthUseCase
    Store  PadSettingsStore
}

func (SavePadSettingsUseCase) Execute ​

go
func (uc SavePadSettingsUseCase) Execute(ctx context.Context, in SavePadSettingsInput) (*domain.PadSettings, error)

Execute authenticates before validation so unauthenticated callers learn nothing about the rules.

type SelectProfessionalDetails ​

SelectProfessionalDetails authorizes ownership using the persistent doctor session.

go
type SelectProfessionalDetails struct {
    Verify *VerifyAuthUseCase
    Writer ProfessionalSelectionWriter
}

func (*SelectProfessionalDetails) Execute ​

go
func (uc *SelectProfessionalDetails) Execute(ctx context.Context, header string, input ProfessionalSelections) (*VerifiedDoctor, error)

Execute saves only the authenticated doctor's selections.

type VerifiedDoctor ​

VerifiedDoctor contains safe identity details and the caller's professional profile.

go
type VerifiedDoctor struct {
    Identity *identitypublic.Account
    Doctor   *doctorpublic.Profile
}

type VerifyAuthInput ​

VerifyAuthInput carries the complete bearer Authorization header.

go
type VerifyAuthInput struct{ Authorization string }

type VerifyAuthUseCase ​

VerifyAuthUseCase validates a persistent session, active identity and doctor profile.

go
type VerifyAuthUseCase struct {
    // contains filtered or unexported fields
}

func NewVerifyAuthUseCase ​

go
func NewVerifyAuthUseCase(identity types.IIdentityService, accounts identitypublic.AccountReader, profiles ports.ProfileRepository) *VerifyAuthUseCase

NewVerifyAuthUseCase wires identity validation and doctor profile lookup.

func (*VerifyAuthUseCase) Execute ​

go
func (uc *VerifyAuthUseCase) Execute(ctx context.Context, input VerifyAuthInput) (*VerifiedDoctor, error)

Execute returns the authenticated doctor's current identity and professional details.

type ViewDiscoverableOrganizationInput ​

ViewDiscoverableOrganizationInput contains the view discoverable organization request parameters.

go
type ViewDiscoverableOrganizationInput struct {
    Authorization  string
    OrganizationID string
}

type ViewDiscoverableOrganizationUseCase ​

ViewDiscoverableOrganizationUseCase defines the unimplemented view discoverable organization operation.

go
type ViewDiscoverableOrganizationUseCase struct{}

func NewViewDiscoverableOrganizationUseCase ​

go
func NewViewDiscoverableOrganizationUseCase() *ViewDiscoverableOrganizationUseCase

NewViewDiscoverableOrganizationUseCase creates the documentation-first view discoverable organization use case.

func (*ViewDiscoverableOrganizationUseCase) Execute ​

go
func (uc *ViewDiscoverableOrganizationUseCase) Execute(_ context.Context, _ ViewDiscoverableOrganizationInput) (*organizationpublic.OrganizationSummary, error)

Execute returns ErrNotImplemented until the operation is implemented.

Generated by gomarkdoc

Documentation follows the source. Planned contracts are marked explicitly.