usecases

type AccountDependencies ¶

type AccountDependencies struct {
	CredentialStore CredentialUpdater
	TokenStore      TokenStore
	AlertDeleter    AlertDeleter
	WatchlistStore  WatchlistStore
	TrailingStops   TrailingStopManager
	PaperEngine     PaperEngine
	UserStore       AdminUserStore
	Sessions        SessionTerminator
}

AccountDependencies groups stores needed for account deletion.

type AddToWatchlistUseCase ¶

type AddToWatchlistUseCase struct {
	// contains filtered or unexported fields
}

AddToWatchlistUseCase adds an instrument to a watchlist.

func NewAddToWatchlistUseCase(store WatchlistStore, logger *slog.Logger) *AddToWatchlistUseCase

func (uc *AddToWatchlistUseCase) Execute(ctx context.Context, cmd cqrs.AddToWatchlistCommand) error

func (uc *AddToWatchlistUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *AddToWatchlistUseCase) SetEventStore(s EventAppender)

type AdminActivateUserUseCase ¶

type AdminActivateUserUseCase struct {
	// contains filtered or unexported fields
}

AdminActivateUserUseCase reactivates a user account.

func NewAdminActivateUserUseCase(store AdminUserWriter, logger *slog.Logger) *AdminActivateUserUseCase

func (uc *AdminActivateUserUseCase) Execute(ctx context.Context, cmd cqrs.AdminActivateUserCommand) error

type AdminChangeRoleResult ¶

type AdminChangeRoleResult struct {
	Email   string `json:"email"`
	OldRole string `json:"old_role"`
	NewRole string `json:"new_role"`
}

AdminChangeRoleResult holds the role change result.

type AdminChangeRoleUseCase ¶

type AdminChangeRoleUseCase struct {
	// contains filtered or unexported fields
}

AdminChangeRoleUseCase changes a user's role.

func NewAdminChangeRoleUseCase(store AdminUserStore, logger *slog.Logger) *AdminChangeRoleUseCase

func (uc *AdminChangeRoleUseCase) Execute(ctx context.Context, cmd cqrs.AdminChangeRoleCommand) (*AdminChangeRoleResult, error)

type AdminDeleteRegistryUseCase ¶

type AdminDeleteRegistryUseCase struct {
	// contains filtered or unexported fields
}

AdminDeleteRegistryUseCase removes a registry entry.

func NewAdminDeleteRegistryUseCase(r RegistryAdminWriter, logger *slog.Logger) *AdminDeleteRegistryUseCase

func (uc *AdminDeleteRegistryUseCase) Execute(_ context.Context, cmd cqrs.AdminDeleteRegistryCommand) error

type AdminFreezeGlobalUseCase ¶

type AdminFreezeGlobalUseCase struct {
	// contains filtered or unexported fields
}

AdminFreezeGlobalUseCase freezes all trading globally.

func NewAdminFreezeGlobalUseCase(rg RiskGuardService, logger *slog.Logger) *AdminFreezeGlobalUseCase

func (uc *AdminFreezeGlobalUseCase) Execute(ctx context.Context, cmd cqrs.AdminFreezeGlobalCommand) error

type AdminFreezeUserUseCase ¶

type AdminFreezeUserUseCase struct {
	// contains filtered or unexported fields
}

AdminFreezeUserUseCase freezes a user's trading.

func NewAdminFreezeUserUseCase(rg RiskGuardService, logger *slog.Logger) *AdminFreezeUserUseCase

func (uc *AdminFreezeUserUseCase) Execute(ctx context.Context, cmd cqrs.AdminFreezeUserCommand) error

type AdminGetRiskStatusResult ¶

type AdminGetRiskStatusResult struct {
	TargetEmail     string               `json:"target_email"`
	GloballyFrozen  bool                 `json:"globally_frozen"`
	UserStatus      riskguard.UserStatus `json:"user_status"`
	EffectiveLimits riskguard.UserLimits `json:"effective_limits"`
	OrderHeadroom   float64              `json:"order_headroom"`
}

AdminGetRiskStatusResult holds a user's risk status.

type AdminGetRiskStatusUseCase ¶

type AdminGetRiskStatusUseCase struct {
	// contains filtered or unexported fields
}

AdminGetRiskStatusUseCase retrieves a user's risk status.

func NewAdminGetRiskStatusUseCase(rg RiskGuardService, logger *slog.Logger) *AdminGetRiskStatusUseCase

func (uc *AdminGetRiskStatusUseCase) Execute(ctx context.Context, query cqrs.AdminGetRiskStatusQuery) (*AdminGetRiskStatusResult, error)

type AdminGetUserResult ¶

type AdminGetUserResult struct {
	User            *users.User           `json:"user"`
	RiskStatus      *riskguard.UserStatus `json:"risk_status,omitempty"`
	EffectiveLimits *riskguard.UserLimits `json:"effective_limits,omitempty"`
}

AdminGetUserResult holds detailed user information.

type AdminGetUserUseCase ¶

type AdminGetUserUseCase struct {
	// contains filtered or unexported fields
}

AdminGetUserUseCase retrieves detailed user information.

func NewAdminGetUserUseCase(store AdminUserReader, rg RiskGuardService, logger *slog.Logger) *AdminGetUserUseCase

func (uc *AdminGetUserUseCase) Execute(ctx context.Context, query cqrs.AdminGetUserQuery) (*AdminGetUserResult, error)

type AdminInviteFamilyMemberResult ¶

type AdminInviteFamilyMemberResult struct {
	InvitationID string    `json:"invitation_id"`
	InvitedEmail string    `json:"invited_email"`
	ExpiresAt    time.Time `json:"expires_at"`
	SlotsUsed    int       `json:"slots_used"`
	SlotsMax     int       `json:"slots_max"`
}

AdminInviteFamilyMemberResult holds the outcome of a successful invite.

type AdminInviteFamilyMemberUseCase ¶

type AdminInviteFamilyMemberUseCase struct {
	// contains filtered or unexported fields
}

AdminInviteFamilyMemberUseCase creates a family invitation after enforcing slot limits via FamilyService.CanInvite.

func NewAdminInviteFamilyMemberUseCase(
	family FamilyProvider,
	invitations FamilyInvitationWriter,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *AdminInviteFamilyMemberUseCase

func (uc *AdminInviteFamilyMemberUseCase) Execute(ctx context.Context, cmd cqrs.AdminInviteFamilyMemberCommand) (*AdminInviteFamilyMemberResult, error)

type AdminListFamilyResult ¶

type AdminListFamilyResult struct {
	AdminEmail  string                  `json:"admin_email"`
	MaxUsers    int                     `json:"max_users"`
	Total       int                     `json:"total"`
	From        int                     `json:"from"`
	Limit       int                     `json:"limit"`
	MemberCount int                     `json:"member_count"`
	Members     []FamilyMemberEntry     `json:"members"`
	Pending     []FamilyInvitationEntry `json:"pending"`
}

AdminListFamilyResult holds the paginated family listing + pending invites.

type AdminListFamilyUseCase ¶

type AdminListFamilyUseCase struct {
	// contains filtered or unexported fields
}

AdminListFamilyUseCase returns the admin's family members and pending invitations.

func NewAdminListFamilyUseCase(
	family FamilyProvider,
	invitations FamilyInvitationReader,
	logger *slog.Logger,
) *AdminListFamilyUseCase

func (uc *AdminListFamilyUseCase) Execute(ctx context.Context, query cqrs.AdminListFamilyQuery) (*AdminListFamilyResult, error)

type AdminListUsersResult ¶

type AdminListUsersResult struct {
	Total int           `json:"total"`
	From  int           `json:"from"`
	Limit int           `json:"limit"`
	Users []*users.User `json:"users"`
}

AdminListUsersResult holds the paginated user list.

type AdminListUsersUseCase ¶

type AdminListUsersUseCase struct {
	// contains filtered or unexported fields
}

AdminListUsersUseCase retrieves a paginated list of users.

func NewAdminListUsersUseCase(store AdminUserReader, logger *slog.Logger) *AdminListUsersUseCase

func (uc *AdminListUsersUseCase) Execute(ctx context.Context, query cqrs.AdminListUsersQuery) (*AdminListUsersResult, error)

type AdminRegisterAppUseCase ¶

type AdminRegisterAppUseCase struct {
	// contains filtered or unexported fields
}

AdminRegisterAppUseCase persists a new key-registry entry created from the admin dashboard.

func NewAdminRegisterAppUseCase(r RegistryAdminWriter, logger *slog.Logger) *AdminRegisterAppUseCase

func (uc *AdminRegisterAppUseCase) Execute(_ context.Context, cmd cqrs.AdminRegisterAppCommand) error

type AdminRemoveFamilyMemberResult ¶

type AdminRemoveFamilyMemberResult struct {
	RemovedEmail string `json:"removed_email"`
}

AdminRemoveFamilyMemberResult holds the outcome of a remove call.

type AdminRemoveFamilyMemberUseCase ¶

type AdminRemoveFamilyMemberUseCase struct {
	// contains filtered or unexported fields
}

AdminRemoveFamilyMemberUseCase unlinks a family member via FamilyService.

func NewAdminRemoveFamilyMemberUseCase(
	family FamilyProvider,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *AdminRemoveFamilyMemberUseCase

func (uc *AdminRemoveFamilyMemberUseCase) Execute(ctx context.Context, cmd cqrs.AdminRemoveFamilyMemberCommand) (*AdminRemoveFamilyMemberResult, error)

type AdminSuspendUserResult ¶

type AdminSuspendUserResult struct {
	Status             string `json:"status"`
	Email              string `json:"email"`
	SessionsTerminated int    `json:"sessions_terminated"`
}

AdminSuspendUserResult holds the suspension result.

type AdminSuspendUserUseCase ¶

type AdminSuspendUserUseCase struct {
	// contains filtered or unexported fields
}

AdminSuspendUserUseCase suspends a user account.

func NewAdminSuspendUserUseCase(
	store AdminUserStore,
	rg RiskGuardService,
	sessions SessionTerminator,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *AdminSuspendUserUseCase

func (uc *AdminSuspendUserUseCase) Execute(ctx context.Context, cmd cqrs.AdminSuspendUserCommand) (*AdminSuspendUserResult, error)

type AdminUnfreezeGlobalUseCase ¶

type AdminUnfreezeGlobalUseCase struct {
	// contains filtered or unexported fields
}

AdminUnfreezeGlobalUseCase unfreezes global trading.

func NewAdminUnfreezeGlobalUseCase(rg RiskGuardService, logger *slog.Logger) *AdminUnfreezeGlobalUseCase

func (uc *AdminUnfreezeGlobalUseCase) Execute(ctx context.Context, cmd cqrs.AdminUnfreezeGlobalCommand) error

type AdminUnfreezeUserUseCase ¶

type AdminUnfreezeUserUseCase struct {
	// contains filtered or unexported fields
}

AdminUnfreezeUserUseCase unfreezes a user's trading.

func NewAdminUnfreezeUserUseCase(rg RiskGuardService, logger *slog.Logger) *AdminUnfreezeUserUseCase

func (uc *AdminUnfreezeUserUseCase) Execute(ctx context.Context, cmd cqrs.AdminUnfreezeUserCommand) error

type AdminUpdateRegistryUseCase ¶

type AdminUpdateRegistryUseCase struct {
	// contains filtered or unexported fields
}

AdminUpdateRegistryUseCase mutates an existing registry entry's assignment, label, or status.

func NewAdminUpdateRegistryUseCase(r RegistryAdminWriter, logger *slog.Logger) *AdminUpdateRegistryUseCase

func (uc *AdminUpdateRegistryUseCase) Execute(_ context.Context, cmd cqrs.AdminUpdateRegistryCommand) error

type AdminUserReader ¶

type AdminUserReader interface {
	List() []*users.User
	Get(email string) (*users.User, bool)
	Count() int
}

AdminUserReader provides read-only access to user data (ISP-narrowed).

F2 close-out (Phase B/D): renamed from usecases.UserReader to disambiguate from kc.UserReader (10-method canonical) — the usecases version is a 3-method narrow subset for admin tooling only. Per the redundancy audit's empirical finding: same name, different signatures = future-maintainer confusion. *kc.Manager (and kc.UserStoreInterface implementations) satisfy this narrow port structurally — no adapter layer needed.

UserAuthChecker was deleted (was dead code — declared but never referenced as a field type or function parameter; only embedded in the unused UserStore composite via UserAuthChecker.IsAdmin which no admin use case actually called).

type AdminUserStore ¶

type AdminUserStore interface {
	AdminUserReader
	AdminUserWriter
}

AdminUserStore is the composite interface for admin use cases that need both reads and writes. Prefer AdminUserReader or AdminUserWriter directly when possible (Interface Segregation Principle).

F2 close-out: renamed from usecases.UserStore. UserAuthChecker embedding removed — no admin use case calls IsAdmin/HasPassword/ VerifyPassword on the composite (they route through riskguard / session-svc instead).

type AdminUserWriter ¶

type AdminUserWriter interface {
	UpdateStatus(email, status string) error
	UpdateRole(email, role string) error
	Create(u *users.User) error
}

AdminUserWriter provides write operations on user data (ISP-narrowed).

F2 close-out: renamed from usecases.UserWriter (was a 3-method narrow subset of kc.UserWriter's 8). Same rename rationale as AdminUserReader — disambiguate from the wide kc canonical.

type AlertDeleter ¶

type AlertDeleter interface {
	DeleteByEmail(email string)
}

AlertDeleter abstracts alert deletion for account cleanup.

type AlertExporter ¶

type AlertExporter interface {
	ExportAlerts(email string) ([]any, error)
}

AlertExporter retrieves alerts for the user.

type AlertLister ¶

type AlertLister interface {
	ListActive(email string) []AlertSummary
}

AlertLister abstracts reading active alerts for a user.

type AlertReader ¶

type AlertReader interface {
	List(email string) []*alerts.Alert
	Delete(email, alertID string) error
}

AlertReader abstracts alert read/delete operations for use cases.

type AlertStore ¶

type AlertStore interface {
	Add(email, tradingsymbol, exchange string, instrumentToken uint32, targetPrice float64, direction alerts.Direction) (string, error)
	AddWithReferencePrice(email, tradingsymbol, exchange string, instrumentToken uint32, targetPrice float64, direction alerts.Direction, referencePrice float64) (string, error)
}

AlertStore is the interface needed by CreateAlertUseCase. It matches the subset of kc.AlertStoreInterface used here.

type AlertSummary ¶

type AlertSummary struct {
	Tradingsymbol string
	Exchange      string
	Direction     string
	TargetPrice   float64
	Triggered     bool
}

AlertSummary is a minimal alert representation for the trading context.

type BrokerResolver ¶

type BrokerResolver interface {
	GetBrokerForEmail(email string) (broker.Client, error)
}

BrokerResolver resolves a broker.Client for a given user email.

CONTRACT ¶

Signature:

GetBrokerForEmail(email string) (broker.Client, error)

Return semantics:

(client, nil) — successful resolution. The returned client is
  ready to use. Implementations MAY return the same client
  instance for repeated calls (cache hits) or a fresh instance
  per call (cold construction); use cases MUST NOT assume
  identity across invocations.

(nil, err)   — resolution failed. The error MUST be non-nil and
  the client MUST be nil. Use cases wrap and propagate; they do
  NOT retry at the port level. Common error shapes today:
    - "no Kite access token for {email}" — user not authed
    - broker-factory construction failure
    - downstream credential-store lookup error

Email argument:

The port DOES NOT mandate an email-validity check. Implementations
differ:
  - *kc.SessionService.GetBrokerForEmail (production) — looks up
    the email first in the active-session map (in-memory hit) and
    falls back to credential-store + token-store reconstruction.
    Returns an error when no token is cached for the email.
  - *mcp.sessionBrokerResolver.GetBrokerForEmail (mcp pre-dispatch)
    — IGNORES the email and returns its pre-resolved client. Used
    only by ToolHandler.WithTokenRefresh for the cheap profile-
    probe outside the bus; bus-routed handlers always reach the
    SessionService impl above.
  - test mocks (kc/usecases/mocks_test.go mockBrokerResolver) —
    pass the email through; behaviour follows the test fixture's
    configured client/error pair.

Use cases that need email-shape validation (non-empty, well-formed)
MUST validate before calling GetBrokerForEmail. The port itself
is pass-through.

Thread-safety:

Implementations MUST be safe for concurrent calls from multiple
goroutines. The bus dispatches commands and queries from the MCP
tool layer's per-request goroutines; a use case constructed once
at startup (Wave D's eventual end-state) sees its resolver hit
from N concurrent request paths simultaneously. Production
implementations honor this via internal mutex / sync.Map; test
mocks should as well if exercised under -race.

Lifetime:

The resolver is constructed once per Manager (production) or per
test fixture, and lives for the Manager's lifetime. Use cases
hold the interface value, not a pointer-to-interface — replacing
the resolver implementation requires reconstructing the use case.
(Wave D Slice D-final wires this through Wire/fx providers; until
then, manager_init.go is the construction site.)

"No broker for this ctx" sentinel:

The port has no sentinel — it is email-keyed, not ctx-keyed. After
Wave D Slice D7, ctx no longer carries a per-request broker; every
bus-routed use case receives m.sessionSvc as its BrokerResolver
at construction time and reaches the broker via the SessionService
in-memory active-session map (cost: one in-memory map lookup per
dispatch, ~100 ns; see .research/wave-d-resolver-refactor-plan.md
§5). The previous WithBroker / pinnedBrokerResolver / resolverFromContext
machinery has been removed (commit at end of Wave D Phase 1).

IMPLEMENTATIONS

Production:
  - *kc.SessionService           (kc/session_service.go:541)
  - *mcp.sessionBrokerResolver   (mcp/post_tools.go:19, used by
                                   WithTokenRefresh and similar
                                   pre-dispatch session probes;
                                   out of scope for Wave D Phase 1)

Tests:
  - mockBrokerResolver           (kc/usecases/mocks_test.go:62)
  - brokerResolverTestImpl       (kc/usecases/ports_test.go,
                                   test-only, mirrors the
                                   "ignore-email" shape for
                                   contract coverage)

type BuildOptionsStrategyCommand ¶

type BuildOptionsStrategyCommand struct {
	Email      string
	Strategy   string // bull_call_spread, bear_put_spread, ..., butterfly
	Underlying string // NIFTY, BANKNIFTY, RELIANCE, ...
	Expiry     string // YYYY-MM-DD
	Strike1    float64
	Strike2    float64
	Strike3    float64
	Strike4    float64
	LotSize    int // 0 = auto-detect via OptionInstrumentLookup.DefaultLotSize
	Lots       int // 0 or negative coerced to 1
}

BuildOptionsStrategyCommand is the input shape for the use case. Mirrors the URL/MCP-arg surface of options_payoff_builder.

func ValidateOptionsStrategyCommand(cmd BuildOptionsStrategyCommand) (BuildOptionsStrategyCommand, error)

type BuildOptionsStrategyUseCase ¶

type BuildOptionsStrategyUseCase struct {
	// contains filtered or unexported fields
}

BuildOptionsStrategyUseCase orchestrates the full options-strategy build: validate input → expand legs by strategy name → resolve instruments → fetch LTPs → compute P&L formulas → return populated StrategyResponse.

Refactor invariant (Phase (a)): output JSON shape matches the pre-refactor mcp/trade strategyResponse so consumers (dashboard payoff page, MCP tool handler) work unchanged after the data-flow swap. The MCP tool handler becomes a thin arg-parse + use-case-call shell; the dashboard endpoint also calls the same use case.

func NewBuildOptionsStrategyUseCase(resolver BrokerResolver, instruments OptionInstrumentLookup, logger *slog.Logger) *BuildOptionsStrategyUseCase

func (uc *BuildOptionsStrategyUseCase) Execute(ctx context.Context, cmd BuildOptionsStrategyCommand) (*StrategyResponse, error)

type CacheKiteAccessTokenUseCase ¶

type CacheKiteAccessTokenUseCase struct {
	// contains filtered or unexported fields
}

CacheKiteAccessTokenUseCase writes the Kite access token to the per-user token cache. Always lowercases the email.

func NewCacheKiteAccessTokenUseCase(t KiteTokenWriter, logger *slog.Logger) *CacheKiteAccessTokenUseCase

func (uc *CacheKiteAccessTokenUseCase) Execute(_ context.Context, cmd cqrs.CacheKiteAccessTokenCommand) error

type CancelMFOrderUseCase ¶

type CancelMFOrderUseCase struct {
	// contains filtered or unexported fields
}

CancelMFOrderUseCase cancels a pending mutual fund order.

func NewCancelMFOrderUseCase(resolver BrokerResolver, logger *slog.Logger) *CancelMFOrderUseCase

func (uc *CancelMFOrderUseCase) Execute(ctx context.Context, cmd cqrs.CancelMFOrderCommand) (broker.MFOrderResponse, error)

func (uc *CancelMFOrderUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *CancelMFOrderUseCase) SetEventStore(s EventAppender)

type CancelMFSIPUseCase ¶

type CancelMFSIPUseCase struct {
	// contains filtered or unexported fields
}

CancelMFSIPUseCase cancels an existing mutual fund SIP.

func NewCancelMFSIPUseCase(resolver BrokerResolver, logger *slog.Logger) *CancelMFSIPUseCase

func (uc *CancelMFSIPUseCase) Execute(ctx context.Context, cmd cqrs.CancelMFSIPCommand) (broker.MFSIPResponse, error)

func (uc *CancelMFSIPUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *CancelMFSIPUseCase) SetEventStore(s EventAppender)

type CancelOrderUseCase ¶

type CancelOrderUseCase struct {
	// contains filtered or unexported fields
}

CancelOrderUseCase orchestrates order cancellation: broker API call -> domain event dispatch. Riskguard is not applied to cancels (cancelling reduces risk, not increases it).

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewCancelOrderUseCase(
	resolver BrokerResolver,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *CancelOrderUseCase

func (uc *CancelOrderUseCase) Execute(ctx context.Context, cmd cqrs.CancelOrderCommand) (broker.OrderResponse, error)

func (uc *CancelOrderUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *CancelOrderUseCase) SetEventStore(s EventAppender)

type CancelTrailingStopUseCase ¶

type CancelTrailingStopUseCase struct {
	// contains filtered or unexported fields
}

CancelTrailingStopUseCase deactivates a trailing stop.

func NewCancelTrailingStopUseCase(manager TrailingStopManager, logger *slog.Logger) *CancelTrailingStopUseCase

func (uc *CancelTrailingStopUseCase) Execute(ctx context.Context, cmd cqrs.CancelTrailingStopCommand) error

func (uc *CancelTrailingStopUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *CancelTrailingStopUseCase) SetEventStore(s EventAppender)

type ClearSessionDataUseCase ¶

type ClearSessionDataUseCase struct {
	// contains filtered or unexported fields
}

ClearSessionDataUseCase clears the Kite session data attached to an MCP session without terminating the session itself. Owns the persistence step — the handler in kc/manager_commands_setup.go invokes Execute, and mcp/ tool handlers must not reach past the bus to call ClearSessionData directly (Round-5 Phase B contract for sessions).

func NewClearSessionDataUseCase(sessions SessionDataClearer, logger *slog.Logger) *ClearSessionDataUseCase

func (uc *ClearSessionDataUseCase) Execute(ctx context.Context, cmd cqrs.ClearSessionDataCommand) error

func (uc *ClearSessionDataUseCase) SetEventStore(s EventAppender)

type CloseAllPositionsUseCase ¶

type CloseAllPositionsUseCase struct {
	// contains filtered or unexported fields
}

CloseAllPositionsUseCase exits all open positions by placing opposite MARKET orders. Pipeline: fetch positions -> filter -> riskguard per-order -> place orders -> events.

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewCloseAllPositionsUseCase(
	resolver BrokerResolver,
	guard *riskguard.Guard,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *CloseAllPositionsUseCase

func (uc *CloseAllPositionsUseCase) Execute(ctx context.Context, email, productFilter string) (*CloseAllResult, error)

func (uc *CloseAllPositionsUseCase) ExecuteCommand(ctx context.Context, cmd cqrs.CloseAllPositionsCommand) (*CloseAllResult, error)

func (uc *CloseAllPositionsUseCase) SetEventDispatcher(d *domain.EventDispatcher)

type CloseAllResult ¶

type CloseAllResult struct {
	SuccessCount  int                `json:"success_count"`
	ErrorCount    int                `json:"error_count"`
	Total         int                `json:"total"`
	ProductFilter string             `json:"product_filter"`
	Results       []CloseEntryResult `json:"results"`
}

CloseAllResult contains the outcome of closing all positions.

type CloseEntryResult ¶

type CloseEntryResult struct {
	Tradingsymbol string `json:"tradingsymbol"`
	Exchange      string `json:"exchange"`
	Quantity      int    `json:"quantity"`
	Direction     string `json:"direction"`
	OrderID       string `json:"order_id,omitempty"`
	Error         string `json:"error,omitempty"`
}

CloseEntryResult holds the outcome for a single position close attempt.

type ClosePositionResult ¶

type ClosePositionResult struct {
	OrderID     string  `json:"order_id"`
	Instrument  string  `json:"instrument"`
	Quantity    int     `json:"quantity"`
	Direction   string  `json:"direction"`
	Product     string  `json:"product"`
	PositionPnL float64 `json:"position_pnl"`
}

ClosePositionResult contains the outcome of closing a position.

type ClosePositionUseCase ¶

type ClosePositionUseCase struct {
	// contains filtered or unexported fields
}

ClosePositionUseCase closes a single position by placing an opposite MARKET order. Pipeline: find position -> riskguard check -> place opposite order -> domain event.

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewClosePositionUseCase(
	resolver BrokerResolver,
	guard *riskguard.Guard,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *ClosePositionUseCase

func (uc *ClosePositionUseCase) Execute(ctx context.Context, email, exchange, symbol, productFilter string) (*ClosePositionResult, error)

func (uc *ClosePositionUseCase) ExecuteCommand(ctx context.Context, cmd cqrs.ClosePositionCommand) (*ClosePositionResult, error)

func (uc *ClosePositionUseCase) SetEventDispatcher(d *domain.EventDispatcher)

type CompositeAlertStore ¶

type CompositeAlertStore interface {
	AddComposite(email, name string, logic domain.CompositeLogic, conds []domain.CompositeCondition) (string, error)
}

CompositeAlertStore is the subset of kc.AlertStoreInterface needed to create composite alerts. Scoped narrowly per Interface Segregation.

type ConsentExporter ¶

type ConsentExporter interface {
	ExportConsentLog(emailHash string) ([]any, error)
}

ConsentExporter retrieves the full consent_log history.

type ConsentWithdrawer ¶

type ConsentWithdrawer interface {
	MarkWithdrawnByEmailHash(emailHash string, withdrawnAt time.Time,
		noticeVersion, reason, ipAddress, userAgent string) (int64, error)
}

ConsentWithdrawer is the narrow port the use case needs from the audit consent store. The store hashes nothing — the use case passes the already-hashed email + the operational fields.

type ConvertPositionUseCase ¶

type ConvertPositionUseCase struct {
	// contains filtered or unexported fields
}

ConvertPositionUseCase converts a position from one product type to another.

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewConvertPositionUseCase(resolver BrokerResolver, logger *slog.Logger) *ConvertPositionUseCase

func (uc *ConvertPositionUseCase) Execute(ctx context.Context, cmd cqrs.ConvertPositionCommand) (bool, error)

func (uc *ConvertPositionUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *ConvertPositionUseCase) SetEventStore(s EventAppender)

type CreateAlertUseCase ¶

type CreateAlertUseCase struct {
	// contains filtered or unexported fields
}

CreateAlertUseCase creates a new price alert for a user.

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewCreateAlertUseCase(
	store AlertStore,
	instruments InstrumentResolver,
	logger *slog.Logger,
) *CreateAlertUseCase

func (uc *CreateAlertUseCase) Execute(ctx context.Context, cmd cqrs.CreateAlertCommand) (string, error)

func (uc *CreateAlertUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *CreateAlertUseCase) SetEventStore(s EventAppender)

type CreateCompositeAlertUseCase ¶

type CreateCompositeAlertUseCase struct {
	// contains filtered or unexported fields
}

CreateCompositeAlertUseCase creates a composite alert for a user.

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewCreateCompositeAlertUseCase(
	store CompositeAlertStore,
	instruments InstrumentResolver,
	logger *slog.Logger,
) *CreateCompositeAlertUseCase

func (uc *CreateCompositeAlertUseCase) Execute(ctx context.Context, cmd cqrs.CreateCompositeAlertCommand) (string, error)

func (uc *CreateCompositeAlertUseCase) SetEventStore(s EventAppender)

type CreateWatchlistResult ¶

type CreateWatchlistResult struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

CreateWatchlistResult holds the result of creating a watchlist.

type CreateWatchlistUseCase ¶

type CreateWatchlistUseCase struct {
	// contains filtered or unexported fields
}

CreateWatchlistUseCase creates a new named watchlist.

func NewCreateWatchlistUseCase(store WatchlistStore, logger *slog.Logger) *CreateWatchlistUseCase

func (uc *CreateWatchlistUseCase) Execute(ctx context.Context, cmd cqrs.CreateWatchlistCommand) (*CreateWatchlistResult, error)

func (uc *CreateWatchlistUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *CreateWatchlistUseCase) SetEventStore(s EventAppender)

type CredentialSetter ¶

type CredentialSetter interface {
	Set(email string, entry any)
}

CredentialSetter abstracts credential persistence for updating credentials.

type CredentialUpdater ¶

type CredentialUpdater interface {
	Delete(email string)
	Set(email, apiKey, apiSecret string)
	Has(email string) bool
}

CredentialUpdater abstracts credential persistence for account use cases. Delete removes a user's credentials (used by DeleteMyAccount). Set installs/updates a user's credentials (used by UpdateMyCredentials). The apiKey/apiSecret pair is passed as primitive strings — the use case should not import kc internal types (circular dependency risk with kc → usecases). Has reports whether an entry already exists for the email — needed by UpdateMyCredentials to tell first-time registration (CredentialRegistered event) from replacement (CredentialRotated event). Implementations wrap the kc.KiteCredentialStore.Set call behind this port.

type DataExport ¶

type DataExport struct {
	GeneratedAtUTC time.Time `json:"generated_at_utc"`
	Email          string    `json:"email"`
	EmailHash      string    `json:"email_hash"`
	RetentionFrom  time.Time `json:"retention_from_utc"`

	ToolCalls    DataExportSection `json:"tool_calls"`
	Alerts       DataExportSection `json:"alerts"`
	Watchlists   DataExportSection `json:"watchlists"`
	PaperTrades  DataExportSection `json:"paper_trades"`
	Sessions     DataExportSection `json:"sessions"`
	Credentials  DataExportSection `json:"credentials"`
	Consent      DataExportSection `json:"consent_log"`
	DomainEvents DataExportSection `json:"domain_events"`
}

DataExport is the canonical export shape returned to the user. JSON keys are stable and lower_snake_case so external automation can rely on them across versions.

type DataExportPorts ¶

type DataExportPorts struct {
	ToolCalls    ToolCallExporter
	Alerts       AlertExporter
	Watchlists   WatchlistExporter
	PaperTrades  PaperTradeExporter
	Sessions     SessionExporter
	Consent      ConsentExporter
	DomainEvents DomainEventExporter
	Hasher       EmailHasher // reused from consent_usecases.go
}

DataExportPorts groups all eight port types in one struct so the use-case constructor signature stays manageable. Any field may be nil — the corresponding section will be reported as unavailable.

type DataExportSection ¶

type DataExportSection struct {
	Rows  []any  `json:"rows,omitempty"`
	Count int    `json:"count"`
	Note  string `json:"note,omitempty"`
}

DataExportSection wraps a section's rows + an optional unavailability note. Unavailable sections retain their key in the output JSON so downstream automated tooling sees a stable schema regardless of which stores are wired.

type DeleteAlertUseCase ¶

type DeleteAlertUseCase struct {
	// contains filtered or unexported fields
}

DeleteAlertUseCase deletes a specific alert.

func NewDeleteAlertUseCase(store AlertReader, logger *slog.Logger) *DeleteAlertUseCase

func (uc *DeleteAlertUseCase) Execute(ctx context.Context, cmd cqrs.DeleteAlertCommand) error

func (uc *DeleteAlertUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *DeleteAlertUseCase) SetEventStore(s EventAppender)

type DeleteGTTUseCase ¶

type DeleteGTTUseCase struct {
	// contains filtered or unexported fields
}

DeleteGTTUseCase orchestrates GTT order deletion.

func NewDeleteGTTUseCase(resolver BrokerResolver, logger *slog.Logger) *DeleteGTTUseCase

func (uc *DeleteGTTUseCase) Execute(ctx context.Context, cmd cqrs.DeleteGTTCommand) (broker.GTTResponse, error)

func (uc *DeleteGTTUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *DeleteGTTUseCase) SetEventStore(s EventAppender)

type DeleteMyAccountUseCase ¶

type DeleteMyAccountUseCase struct {
	// contains filtered or unexported fields
}

DeleteMyAccountUseCase permanently deletes a user's account and all data.

func NewDeleteMyAccountUseCase(deps AccountDependencies, logger *slog.Logger) *DeleteMyAccountUseCase

func (uc *DeleteMyAccountUseCase) Execute(ctx context.Context, cmd cqrs.DeleteMyAccountCommand) error

func (uc *DeleteMyAccountUseCase) SetEventStore(s EventAppender)

type DeleteNativeAlertUseCase ¶

type DeleteNativeAlertUseCase struct {
	// contains filtered or unexported fields
}

DeleteNativeAlertUseCase deletes one or more native alerts.

func NewDeleteNativeAlertUseCase(logger *slog.Logger) *DeleteNativeAlertUseCase

func (uc *DeleteNativeAlertUseCase) Execute(ctx context.Context, client NativeAlertClient, cmd cqrs.DeleteNativeAlertCommand) error

func (uc *DeleteNativeAlertUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *DeleteNativeAlertUseCase) SetEventStore(s EventAppender)

type DeleteOAuthClientUseCase ¶

type DeleteOAuthClientUseCase struct {
	// contains filtered or unexported fields
}

DeleteOAuthClientUseCase deletes an OAuth dynamic-client registration.

func NewDeleteOAuthClientUseCase(s OAuthClientStore, logger *slog.Logger) *DeleteOAuthClientUseCase

func (uc *DeleteOAuthClientUseCase) Execute(_ context.Context, cmd cqrs.DeleteOAuthClientCommand) error

type DeleteWatchlistResult ¶

type DeleteWatchlistResult struct {
	Name      string `json:"name"`
	ItemCount int    `json:"item_count"`
}

DeleteWatchlistResult holds the result of deleting a watchlist.

type DeleteWatchlistUseCase ¶

type DeleteWatchlistUseCase struct {
	// contains filtered or unexported fields
}

DeleteWatchlistUseCase deletes a watchlist and all its items.

func NewDeleteWatchlistUseCase(store WatchlistStore, logger *slog.Logger) *DeleteWatchlistUseCase

func (uc *DeleteWatchlistUseCase) Execute(ctx context.Context, cmd cqrs.DeleteWatchlistCommand) (*DeleteWatchlistResult, error)

func (uc *DeleteWatchlistUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *DeleteWatchlistUseCase) SetEventStore(s EventAppender)

type DomainEventExporter ¶

type DomainEventExporter interface {
	ExportDomainEvents(emailHash string, since time.Time) ([]any, error)
}

DomainEventExporter retrieves domain events keyed by email_hash.

type EmailHasher ¶

type EmailHasher interface {
	HashEmail(email string) string
}

EmailHasher abstracts the SHA-256 hashing helper. Defined as a port so the use case stays free of an audit-package import (audit imports ports → cycle); the manager wires this to audit.HashEmail.

type EventAppender ¶

type EventAppender interface {
	Append(events ...eventsourcing.StoredEvent) error
	AppendToOutbox(evt eventsourcing.StoredEvent) error
	NextSequence(aggregateID string) (int64, error)
}

EventAppender is a narrow port over eventsourcing.EventStore that the use cases use to write domain events to the audit log. The full store exposes LoadEvents / LoadEventsSince which are read-model concerns; the use case only needs to append and ask for the next sequence number. kc/eventsourcing.EventStore satisfies this natively.

AppendToOutbox is the durability-first variant for hot mutation paths (place_order, modify_order, cancel_order, create_alert) where audit loss after the broker side-effect is unacceptable. The implementation writes to a small staging table; an async pump drains it into the canonical domain_events table. Crash recovery is automatic on the next process restart. Use cases that don't need this guarantee call Append directly. See kc/eventsourcing/outbox.go for full design.

type EventDispatcherPort ¶

type EventDispatcherPort interface {
	Dispatch(event domain.Event)
}

EventDispatcherPort is the narrow dispatcher port for emitting ConsentWithdrawnEvent. nil-safe — the use case skips dispatch when no dispatcher is wired (DevMode, tests).

type ExportMyDataUseCase ¶

type ExportMyDataUseCase struct {
	// contains filtered or unexported fields
}

ExportMyDataUseCase orchestrates the §11 portability dump. Any per-section error is captured into that section's Note so a partial-data store doesn't fail the whole export. Hard errors (validation, missing hasher) return up the stack.

func NewExportMyDataUseCase(ports DataExportPorts, logger *slog.Logger) *ExportMyDataUseCase

func (uc *ExportMyDataUseCase) Execute(ctx context.Context, cmd cqrs.ExportMyDataCommand) (*DataExport, error)

func (uc *ExportMyDataUseCase) SetClock(now func() time.Time)

type FamilyInvitationEntry ¶

type FamilyInvitationEntry struct {
	ID           string    `json:"id"`
	InvitedEmail string    `json:"invited_email"`
	Status       string    `json:"status"`
	ExpiresAt    time.Time `json:"expires_at"`
}

FamilyInvitationEntry is one pending invitation row in the listing.

type FamilyInvitationReader ¶

type FamilyInvitationReader interface {
	ListByAdmin(adminEmail string) []*users.FamilyInvitation
}

FamilyInvitationReader reads pending invitations for an admin.

type FamilyInvitationWriter ¶

type FamilyInvitationWriter interface {
	Create(inv *users.FamilyInvitation) error
}

FamilyInvitationWriter persists newly created family invitations.

type FamilyMemberEntry ¶

type FamilyMemberEntry struct {
	Email     string    `json:"email"`
	Role      string    `json:"role"`
	Status    string    `json:"status"`
	LastLogin time.Time `json:"last_login,omitempty"`
}

FamilyMemberEntry is one member row in the listing.

type FamilyProvider ¶

type FamilyProvider interface {
	ListMembers(adminEmail string) []*users.User
	CanInvite(adminEmail string) (ok bool, current int, max int)
	MaxUsers(adminEmail string) int
	RemoveMember(adminEmail, memberEmail string) error
}

FamilyProvider is the narrow interface the family use cases need from the kc.FamilyService. Defined here so usecases remain decoupled from the kc package (no import cycle).

type GetActivityForWidgetUseCase ¶

type GetActivityForWidgetUseCase struct {
	// contains filtered or unexported fields
}

GetActivityForWidgetUseCase fetches recent audit entries with stats for the activity widget.

func NewGetActivityForWidgetUseCase(store WidgetAuditStore, logger *slog.Logger) *GetActivityForWidgetUseCase

func (uc *GetActivityForWidgetUseCase) Execute(ctx context.Context, query cqrs.GetWidgetActivityQuery) (*WidgetActivityResult, error)

type GetAlertsForWidgetUseCase ¶

type GetAlertsForWidgetUseCase struct {
	// contains filtered or unexported fields
}

GetAlertsForWidgetUseCase fetches alerts enriched with current LTP for the alerts widget.

func NewGetAlertsForWidgetUseCase(resolver BrokerResolver, store WidgetAlertStore, logger *slog.Logger) *GetAlertsForWidgetUseCase

func (uc *GetAlertsForWidgetUseCase) Execute(ctx context.Context, query cqrs.GetWidgetAlertsQuery) (*WidgetAlertsResult, error)

type GetBasketMarginsUseCase ¶

type GetBasketMarginsUseCase struct {
	// contains filtered or unexported fields
}

GetBasketMarginsUseCase calculates combined margin for a basket of orders.

func NewGetBasketMarginsUseCase(resolver BrokerResolver, logger *slog.Logger) *GetBasketMarginsUseCase

func (uc *GetBasketMarginsUseCase) Execute(ctx context.Context, query cqrs.GetBasketMarginsQuery) (any, error)

type GetGTTsUseCase ¶

type GetGTTsUseCase struct {
	// contains filtered or unexported fields
}

GetGTTsUseCase retrieves all GTT orders for a user.

func NewGetGTTsUseCase(resolver BrokerResolver, logger *slog.Logger) *GetGTTsUseCase

func (uc *GetGTTsUseCase) Execute(ctx context.Context, query cqrs.GetGTTsQuery) ([]broker.GTTOrder, error)

type GetHistoricalDataUseCase ¶

type GetHistoricalDataUseCase struct {
	// contains filtered or unexported fields
}

GetHistoricalDataUseCase retrieves historical candle data for an instrument.

func NewGetHistoricalDataUseCase(resolver BrokerResolver, logger *slog.Logger) *GetHistoricalDataUseCase

func (uc *GetHistoricalDataUseCase) Execute(ctx context.Context, email string, query cqrs.GetHistoricalDataQuery) ([]broker.HistoricalCandle, error)

type GetLTPUseCase ¶

type GetLTPUseCase struct {
	// contains filtered or unexported fields
}

GetLTPUseCase retrieves the last traded price for instruments.

func NewGetLTPUseCase(resolver BrokerResolver, logger *slog.Logger) *GetLTPUseCase

func (uc *GetLTPUseCase) Execute(ctx context.Context, email string, query cqrs.GetLTPQuery) (map[string]broker.LTP, error)

type GetMFHoldingsUseCase ¶

type GetMFHoldingsUseCase struct {
	// contains filtered or unexported fields
}

GetMFHoldingsUseCase retrieves all mutual fund holdings.

func NewGetMFHoldingsUseCase(resolver BrokerResolver, logger *slog.Logger) *GetMFHoldingsUseCase

func (uc *GetMFHoldingsUseCase) Execute(ctx context.Context, query cqrs.GetMFHoldingsQuery) ([]broker.MFHolding, error)

type GetMFOrdersUseCase ¶

type GetMFOrdersUseCase struct {
	// contains filtered or unexported fields
}

GetMFOrdersUseCase retrieves all mutual fund orders.

func NewGetMFOrdersUseCase(resolver BrokerResolver, logger *slog.Logger) *GetMFOrdersUseCase

func (uc *GetMFOrdersUseCase) Execute(ctx context.Context, query cqrs.GetMFOrdersQuery) ([]broker.MFOrder, error)

type GetMFSIPsUseCase ¶

type GetMFSIPsUseCase struct {
	// contains filtered or unexported fields
}

GetMFSIPsUseCase retrieves all mutual fund SIPs.

func NewGetMFSIPsUseCase(resolver BrokerResolver, logger *slog.Logger) *GetMFSIPsUseCase

func (uc *GetMFSIPsUseCase) Execute(ctx context.Context, query cqrs.GetMFSIPsQuery) ([]broker.MFSIP, error)

type GetMarginsUseCase ¶

type GetMarginsUseCase struct {
	// contains filtered or unexported fields
}

GetMarginsUseCase retrieves the user's account margins.

func NewGetMarginsUseCase(resolver BrokerResolver, logger *slog.Logger) *GetMarginsUseCase

func (uc *GetMarginsUseCase) Execute(ctx context.Context, query cqrs.GetMarginsQuery) (broker.Margins, error)

type GetNativeAlertHistoryUseCase ¶

type GetNativeAlertHistoryUseCase struct {
	// contains filtered or unexported fields
}

GetNativeAlertHistoryUseCase retrieves trigger history for a native alert.

func NewGetNativeAlertHistoryUseCase(logger *slog.Logger) *GetNativeAlertHistoryUseCase

func (uc *GetNativeAlertHistoryUseCase) Execute(ctx context.Context, client NativeAlertClient, query cqrs.GetNativeAlertHistoryQuery) (any, error)

type GetOHLCUseCase ¶

type GetOHLCUseCase struct {
	// contains filtered or unexported fields
}

GetOHLCUseCase retrieves OHLC data for instruments.

func NewGetOHLCUseCase(resolver BrokerResolver, logger *slog.Logger) *GetOHLCUseCase

func (uc *GetOHLCUseCase) Execute(ctx context.Context, email string, query cqrs.GetOHLCQuery) (map[string]broker.OHLC, error)

type GetOrderChargesUseCase ¶

type GetOrderChargesUseCase struct {
	// contains filtered or unexported fields
}

GetOrderChargesUseCase calculates brokerage, taxes, and charges for orders.

func NewGetOrderChargesUseCase(resolver BrokerResolver, logger *slog.Logger) *GetOrderChargesUseCase

func (uc *GetOrderChargesUseCase) Execute(ctx context.Context, query cqrs.GetOrderChargesQuery) (any, error)

type GetOrderHistoryUseCase ¶

type GetOrderHistoryUseCase struct {
	// contains filtered or unexported fields
}

GetOrderHistoryUseCase retrieves the state history of a specific order.

func NewGetOrderHistoryUseCase(resolver BrokerResolver, logger *slog.Logger) *GetOrderHistoryUseCase

func (uc *GetOrderHistoryUseCase) Execute(ctx context.Context, query cqrs.GetOrderHistoryQuery) ([]broker.Order, error)

type GetOrderMarginsUseCase ¶

type GetOrderMarginsUseCase struct {
	// contains filtered or unexported fields
}

GetOrderMarginsUseCase calculates margin required for orders.

func NewGetOrderMarginsUseCase(resolver BrokerResolver, logger *slog.Logger) *GetOrderMarginsUseCase

func (uc *GetOrderMarginsUseCase) Execute(ctx context.Context, query cqrs.GetOrderMarginsQuery) (any, error)

type GetOrderTradesUseCase ¶

type GetOrderTradesUseCase struct {
	// contains filtered or unexported fields
}

GetOrderTradesUseCase retrieves executed trades for a specific order.

func NewGetOrderTradesUseCase(resolver BrokerResolver, logger *slog.Logger) *GetOrderTradesUseCase

func (uc *GetOrderTradesUseCase) Execute(ctx context.Context, query cqrs.GetOrderTradesQuery) ([]broker.Trade, error)

type GetOrdersForWidgetUseCase ¶

type GetOrdersForWidgetUseCase struct {
	// contains filtered or unexported fields
}

GetOrdersForWidgetUseCase fetches audit-tracked orders enriched with broker status for the orders widget.

func NewGetOrdersForWidgetUseCase(resolver BrokerResolver, store WidgetAuditStore, logger *slog.Logger) *GetOrdersForWidgetUseCase

func (uc *GetOrdersForWidgetUseCase) Execute(ctx context.Context, query cqrs.GetWidgetOrdersQuery) (*WidgetOrdersResult, error)

type GetOrdersUseCase ¶

type GetOrdersUseCase struct {
	// contains filtered or unexported fields
}

GetOrdersUseCase retrieves all orders for the current trading day.

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewGetOrdersUseCase(resolver BrokerResolver, logger *slog.Logger) *GetOrdersUseCase

func (uc *GetOrdersUseCase) Execute(ctx context.Context, query cqrs.GetOrdersQuery) ([]broker.Order, error)

type GetPnLJournalUseCase ¶

type GetPnLJournalUseCase struct {
	// contains filtered or unexported fields
}

GetPnLJournalUseCase retrieves P&L journal data.

func NewGetPnLJournalUseCase(service PnLService, logger *slog.Logger) *GetPnLJournalUseCase

func (uc *GetPnLJournalUseCase) Execute(ctx context.Context, query cqrs.GetPnLJournalQuery) (*alerts.PnLJournalResult, error)

type GetPortfolioForWidgetUseCase ¶

type GetPortfolioForWidgetUseCase struct {
	// contains filtered or unexported fields
}

GetPortfolioForWidgetUseCase fetches holdings + positions in parallel and formats them for the portfolio widget.

func NewGetPortfolioForWidgetUseCase(resolver BrokerResolver, logger *slog.Logger) *GetPortfolioForWidgetUseCase

func (uc *GetPortfolioForWidgetUseCase) Execute(ctx context.Context, query cqrs.GetWidgetPortfolioQuery) (*WidgetPortfolioResult, error)

type GetPortfolioUseCase ¶

type GetPortfolioUseCase struct {
	// contains filtered or unexported fields
}

GetPortfolioUseCase retrieves a user's full portfolio (holdings + positions).

Wave D Phase 3 Package 5 (Logger sweep): logger is the kc/logger.Logger port; constructor takes *slog.Logger and converts via logport.NewSlog.

func NewGetPortfolioUseCase(resolver BrokerResolver, logger *slog.Logger) *GetPortfolioUseCase

func (uc *GetPortfolioUseCase) Execute(ctx context.Context, query cqrs.GetPortfolioQuery) (*PortfolioResult, error)

type GetProfileUseCase ¶

type GetProfileUseCase struct {
	// contains filtered or unexported fields
}

GetProfileUseCase retrieves the user's broker profile.

func NewGetProfileUseCase(resolver BrokerResolver, logger *slog.Logger) *GetProfileUseCase

func (uc *GetProfileUseCase) Execute(ctx context.Context, query cqrs.GetProfileQuery) (broker.Profile, error)

type GetQuotesUseCase ¶

type GetQuotesUseCase struct {
	// contains filtered or unexported fields
}

GetQuotesUseCase retrieves full market quotes for instruments.

func NewGetQuotesUseCase(resolver BrokerResolver, logger *slog.Logger) *GetQuotesUseCase

func (uc *GetQuotesUseCase) Execute(ctx context.Context, email string, query cqrs.GetQuotesQuery) (map[string]broker.Quote, error)

type GetTradesUseCase ¶

type GetTradesUseCase struct {
	// contains filtered or unexported fields
}

GetTradesUseCase retrieves all executed trades for the current trading day.

func NewGetTradesUseCase(resolver BrokerResolver, logger *slog.Logger) *GetTradesUseCase

func (uc *GetTradesUseCase) Execute(ctx context.Context, query cqrs.GetTradesQuery) ([]broker.Trade, error)

type GetWatchlistUseCase ¶

type GetWatchlistUseCase struct {
	// contains filtered or unexported fields
}

GetWatchlistUseCase retrieves items in a watchlist.

func NewGetWatchlistUseCase(store WatchlistStore, logger *slog.Logger) *GetWatchlistUseCase

func (uc *GetWatchlistUseCase) Execute(ctx context.Context, query cqrs.GetWatchlistQuery) ([]*watchlist.WatchlistItem, error)

type InstrumentResolver ¶

type InstrumentResolver interface {
	GetInstrumentToken(exchange, tradingsymbol string) (uint32, error)
}

InstrumentResolver looks up instrument tokens by exchange and symbol.

type InvalidateTokenUseCase ¶

type InvalidateTokenUseCase struct {
	// contains filtered or unexported fields
}

InvalidateTokenUseCase clears a user's cached Kite access token without touching credentials. Used by the login flow when a cached token is detected as expired against the live Kite API, and by administrative actions (forced re-auth after role change, credential rotation).

Added in Round-5 Phase B to replace direct manager.TokenStore().Delete(email) calls scattered across mcp/setup_tools.go — every cached-token clear now flows through the CommandBus, giving a uniform audit/observability layer for credential lifecycle events.

func NewInvalidateTokenUseCase(tokenStore TokenStore, logger *slog.Logger) *InvalidateTokenUseCase

func (uc *InvalidateTokenUseCase) Execute(ctx context.Context, cmd cqrs.InvalidateTokenCommand) error

type KiteCredentialWriter ¶

type KiteCredentialWriter interface {
	SetCredentials(email, apiKey, apiSecret string)
}

KiteCredentialWriter persists per-user Kite API key/secret pairs.

type KiteTokenWriter ¶

type KiteTokenWriter interface {
	SetToken(email, accessToken, userID, userName string)
}

KiteTokenWriter persists Kite access tokens.

type ListAlertsUseCase ¶

type ListAlertsUseCase struct {
	// contains filtered or unexported fields
}

ListAlertsUseCase retrieves all alerts for a user.

func NewListAlertsUseCase(store AlertReader, logger *slog.Logger) *ListAlertsUseCase

func (uc *ListAlertsUseCase) Execute(ctx context.Context, query cqrs.GetAlertsQuery) ([]*alerts.Alert, error)

type ListNativeAlertsUseCase ¶

type ListNativeAlertsUseCase struct {
	// contains filtered or unexported fields
}

ListNativeAlertsUseCase lists all native alerts.

func NewListNativeAlertsUseCase(logger *slog.Logger) *ListNativeAlertsUseCase

func (uc *ListNativeAlertsUseCase) Execute(ctx context.Context, client NativeAlertClient, query cqrs.ListNativeAlertsQuery) (any, error)

type ListTrailingStopsUseCase ¶

type ListTrailingStopsUseCase struct {
	// contains filtered or unexported fields
}

ListTrailingStopsUseCase retrieves all trailing stops for a user.

func NewListTrailingStopsUseCase(manager TrailingStopManager, logger *slog.Logger) *ListTrailingStopsUseCase

func (uc *ListTrailingStopsUseCase) Execute(ctx context.Context, query cqrs.ListTrailingStopsQuery) ([]*alerts.TrailingStop, error)

type ListWatchlistsUseCase ¶

type ListWatchlistsUseCase struct {
	// contains filtered or unexported fields
}

ListWatchlistsUseCase retrieves all watchlists for a user.

func NewListWatchlistsUseCase(store WatchlistStore, logger *slog.Logger) *ListWatchlistsUseCase

func (uc *ListWatchlistsUseCase) Execute(ctx context.Context, query cqrs.ListWatchlistsQuery) ([]WatchlistInfo, error)

type LoginResult ¶

type LoginResult struct {
	URL string `json:"url"`
}

LoginResult is what LoginUseCase.Execute returns after a successful validation + URL generation. The tool handler is responsible for presentation (the warning banner, markdown link formatting, etc.) and for infrastructure side-effects like opening the browser.

type LoginUseCase ¶

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

LoginUseCase validates login command parameters and, given a SessionLoginURLProvider, generates the Kite login URL.

func NewLoginUseCase(urls SessionLoginURLProvider, logger *slog.Logger) *LoginUseCase

func (uc *LoginUseCase) Execute(ctx context.Context, cmd cqrs.LoginCommand) (*LoginResult, error)

func (uc *LoginUseCase) Validate(_ context.Context, cmd cqrs.LoginCommand) error

type LotSizeLookup ¶

type LotSizeLookup interface {
	Get(exchange, tradingsymbol string) (lotSize int, tickSize float64, ok bool)
}

LotSizeLookup looks up lot size and tick size for an instrument. Narrow port so the use case does not pull in the full instruments.Manager surface just to check divisibility and tick alignment. Returning ok=false means "metadata unavailable" — the use case treats that as a silent skip rather than a failure, so off-hours or bootstrap paths where instruments aren't loaded keep working.

F5 rename (Phase B/D close-out): was usecases.InstrumentLookup. The old name collided with kc/telegram.InstrumentLookup (different signature: GetByID returning instruments.Instrument) — same name, different contracts. LotSizeLookup captures the actual semantic role of this port: lot/tick-size validation for the order pipeline. Sibling type usecases.InstrumentResolver (token resolution for alerts) stays as-is.

type MetricsAuditReader ¶

type MetricsAuditReader interface {
	GetGlobalStats(since time.Time) (*audit.Stats, error)
	GetToolMetrics(since time.Time) ([]audit.ToolMetric, error)
	GetTopErrorUsers(since time.Time, limit int) ([]audit.UserErrorCount, error)
}

MetricsAuditReader provides read-only query access for audit metrics (ISP-narrowed for observability use cases).

F2 close-out (Phase B/D): renamed from usecases.AuditReader to disambiguate from kc.AuditReader (9-method canonical including per-user List/ListOrders/GetOrderAttribution/GetStats/GetToolCounts/ VerifyChain). The usecases version surfaces only the global-metrics subset that ServerMetricsUseCase actually queries — narrowing keeps the use case's port surface to exactly what it needs.

AuditWriter and AuditStore (the composite) were deleted as part of F2 — both were declared but never referenced as field types or function parameters anywhere in kc/usecases. Pure dead code from an earlier ISP cleanup that didn't follow through to consumers.

*kc.audit.Store satisfies this narrow port structurally — see kc/interfaces.go:127-133 for the wider canonical's matching methods.

type ModifyGTTUseCase ¶

type ModifyGTTUseCase struct {
	// contains filtered or unexported fields
}

ModifyGTTUseCase orchestrates GTT order modification.

func NewModifyGTTUseCase(resolver BrokerResolver, logger *slog.Logger) *ModifyGTTUseCase

func (uc *ModifyGTTUseCase) Execute(ctx context.Context, cmd cqrs.ModifyGTTCommand) (broker.GTTResponse, error)

func (uc *ModifyGTTUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *ModifyGTTUseCase) SetEventStore(s EventAppender)

type ModifyNativeAlertUseCase ¶

type ModifyNativeAlertUseCase struct {
	// contains filtered or unexported fields
}

ModifyNativeAlertUseCase modifies an existing native alert.

func NewModifyNativeAlertUseCase(logger *slog.Logger) *ModifyNativeAlertUseCase

func (uc *ModifyNativeAlertUseCase) Execute(ctx context.Context, client NativeAlertClient, cmd cqrs.ModifyNativeAlertCommand) (any, error)

func (uc *ModifyNativeAlertUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *ModifyNativeAlertUseCase) SetEventStore(s EventAppender)

type ModifyOrderUseCase ¶

type ModifyOrderUseCase struct {
	// contains filtered or unexported fields
}

ModifyOrderUseCase orchestrates the order modification pipeline: riskguard check -> broker API call -> domain event dispatch.

Wave D Phase 3 Package 5 (Logger sweep): logger is typed as the kc/logger.Logger port. NewModifyOrderUseCase takes *slog.Logger for caller compatibility and converts via logport.NewSlog. Execute uses ctx; helpers use context.Background().

func NewModifyOrderUseCase(
	resolver BrokerResolver,
	guard *riskguard.Guard,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *ModifyOrderUseCase

func (uc *ModifyOrderUseCase) Execute(ctx context.Context, cmd cqrs.ModifyOrderCommand) (broker.OrderResponse, error)

func (uc *ModifyOrderUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *ModifyOrderUseCase) SetEventStore(s EventAppender)

type NativeAlertClient ¶

type NativeAlertClient interface {
	CreateAlert(params any) (any, error)
	ModifyAlert(uuid string, params any) (any, error)
	DeleteAlerts(uuids ...string) error
	GetAlerts(filters map[string]string) (any, error)
	GetAlertHistory(uuid string) (any, error)
}

NativeAlertClient abstracts the Kite alert API for use cases.

type OAuthClientStore ¶

type OAuthClientStore interface {
	SaveClient(clientID, clientSecret, redirectURIsJSON, clientName string, createdAt time.Time, isKiteKey bool) error
	DeleteClient(clientID string) error
}

OAuthClientStore persists OAuth dynamic-client registrations.

type OpenDashboardUseCase ¶

type OpenDashboardUseCase struct {
	// contains filtered or unexported fields
}

OpenDashboardUseCase validates dashboard page requests.

func NewOpenDashboardUseCase(logger *slog.Logger) *OpenDashboardUseCase

func (uc *OpenDashboardUseCase) Validate(_ context.Context, query cqrs.OpenDashboardQuery) error

type OptionInstrument ¶

type OptionInstrument struct {
	Tradingsymbol string
	Underlying    string // e.g. "NIFTY"
	OptionType    string // "CE" or "PE"
	Strike        float64
	Expiry        string // YYYY-MM-DD prefix match
	LotSize       int
}

OptionInstrument is the slim instrument projection that the options strategy use case needs: enough to resolve a tradingsymbol from (underlying, type, strike, expiry) and to know the lot size.

Mirrors fields from kc/instruments.Instrument but kept local to kc/usecases to avoid cross-module coupling — the adapter that implements OptionInstrumentLookup against the real instruments.Manager is wired at composition root (app/wire.go) where both packages are already imported.

type OptionInstrumentLookup ¶

type OptionInstrumentLookup interface {
	FindOption(underlying, optionType string, strike float64, expiry string) (OptionInstrument, bool)
	DefaultLotSize(underlying string) (int, bool)
}

OptionInstrumentLookup is the narrow port the use case needs for option-instrument resolution. Two methods cover the strategy build:

• FindOption: get the tradingsymbol + lot size for a (underlying, type, strike, expiry) tuple
• DefaultLotSize: get a fallback lot size when the user hasn't overridden it (uses the first matching option for the underlying)

F5 rename precedent: same package already has LotSizeLookup (lot/tick metadata) and InstrumentResolver (token resolution). This is a third narrow port for option-specific lookup; intentionally distinct from the others to keep the use case dependencies narrow.

type PaperEngine ¶

type PaperEngine interface {
	Enable(email string, initialCash float64) error
	Disable(email string) error
	Reset(email string) error
	Status(email string) (map[string]any, error)
}

PaperEngine abstracts the paper trading engine for use cases.

type PaperTradeExporter ¶

type PaperTradeExporter interface {
	ExportPaperTrades(email string) ([]any, error)
}

PaperTradeExporter retrieves paper-trading state for the user.

type PaperTradingResetUseCase ¶

type PaperTradingResetUseCase struct {
	// contains filtered or unexported fields
}

PaperTradingResetUseCase resets the virtual portfolio.

func NewPaperTradingResetUseCase(engine PaperEngine, logger *slog.Logger) *PaperTradingResetUseCase

func (uc *PaperTradingResetUseCase) Execute(ctx context.Context, cmd cqrs.PaperTradingResetCommand) error

func (uc *PaperTradingResetUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *PaperTradingResetUseCase) SetEventStore(s EventAppender)

type PaperTradingStatusUseCase ¶

type PaperTradingStatusUseCase struct {
	// contains filtered or unexported fields
}

PaperTradingStatusUseCase retrieves paper trading status.

func NewPaperTradingStatusUseCase(engine PaperEngine, logger *slog.Logger) *PaperTradingStatusUseCase

func (uc *PaperTradingStatusUseCase) Execute(ctx context.Context, query cqrs.PaperTradingStatusQuery) (map[string]any, error)

type PaperTradingToggleUseCase ¶

type PaperTradingToggleUseCase struct {
	// contains filtered or unexported fields
}

PaperTradingToggleUseCase enables or disables paper trading mode.

func NewPaperTradingToggleUseCase(engine PaperEngine, logger *slog.Logger) *PaperTradingToggleUseCase

func (uc *PaperTradingToggleUseCase) Execute(ctx context.Context, cmd cqrs.PaperTradingToggleCommand) (string, error)

func (uc *PaperTradingToggleUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *PaperTradingToggleUseCase) SetEventStore(s EventAppender)

type PlaceGTTUseCase ¶

type PlaceGTTUseCase struct {
	// contains filtered or unexported fields
}

PlaceGTTUseCase orchestrates GTT order placement.

func NewPlaceGTTUseCase(resolver BrokerResolver, logger *slog.Logger) *PlaceGTTUseCase

func (uc *PlaceGTTUseCase) Execute(ctx context.Context, cmd cqrs.PlaceGTTCommand) (broker.GTTResponse, error)

func (uc *PlaceGTTUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *PlaceGTTUseCase) SetEventStore(s EventAppender)

type PlaceMFOrderUseCase ¶

type PlaceMFOrderUseCase struct {
	// contains filtered or unexported fields
}

PlaceMFOrderUseCase places a mutual fund order.

func NewPlaceMFOrderUseCase(resolver BrokerResolver, logger *slog.Logger) *PlaceMFOrderUseCase

func (uc *PlaceMFOrderUseCase) Execute(ctx context.Context, cmd cqrs.PlaceMFOrderCommand) (broker.MFOrderResponse, error)

func (uc *PlaceMFOrderUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *PlaceMFOrderUseCase) SetEventStore(s EventAppender)

type PlaceMFSIPUseCase ¶

type PlaceMFSIPUseCase struct {
	// contains filtered or unexported fields
}

PlaceMFSIPUseCase places a new mutual fund SIP.

func NewPlaceMFSIPUseCase(resolver BrokerResolver, logger *slog.Logger) *PlaceMFSIPUseCase

func (uc *PlaceMFSIPUseCase) Execute(ctx context.Context, cmd cqrs.PlaceMFSIPCommand) (broker.MFSIPResponse, error)

func (uc *PlaceMFSIPUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *PlaceMFSIPUseCase) SetEventStore(s EventAppender)

type PlaceNativeAlertUseCase ¶

type PlaceNativeAlertUseCase struct {
	// contains filtered or unexported fields
}

PlaceNativeAlertUseCase creates a server-side alert at Zerodha.

func NewPlaceNativeAlertUseCase(logger *slog.Logger) *PlaceNativeAlertUseCase

func (uc *PlaceNativeAlertUseCase) Execute(ctx context.Context, client NativeAlertClient, cmd cqrs.PlaceNativeAlertCommand) (any, error)

func (uc *PlaceNativeAlertUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *PlaceNativeAlertUseCase) SetEventStore(s EventAppender)

type PlaceOrderUseCase ¶

type PlaceOrderUseCase struct {
	// contains filtered or unexported fields
}

PlaceOrderUseCase orchestrates the full order placement pipeline: riskguard check -> broker API call -> domain event dispatch.

Wave D Phase 3 Package 5 (Logger sweep): logger is typed as the kc/logger.Logger port. NewPlaceOrderUseCase takes *slog.Logger for caller compatibility (kc/manager_init.go) and converts at the boundary via logport.NewSlog. Internal log calls in Execute use the passed ctx; helpers without ctx use context.Background().

func NewPlaceOrderUseCase(
	resolver BrokerResolver,
	guard *riskguard.Guard,
	events *domain.EventDispatcher,
	logger *slog.Logger,
) *PlaceOrderUseCase

func (uc *PlaceOrderUseCase) Execute(ctx context.Context, cmd cqrs.PlaceOrderCommand) (string, error)

func (uc *PlaceOrderUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *PlaceOrderUseCase) SetEventStore(s EventAppender)

func (uc *PlaceOrderUseCase) SetLotSizeLookup(l LotSizeLookup)

type PnLService ¶

type PnLService interface {
	GetJournal(email, fromDate, toDate string) (*alerts.PnLJournalResult, error)
}

PnLService abstracts P&L snapshot retrieval for use cases.

type PortfolioResult ¶

type PortfolioResult struct {
	Holdings  []broker.Holding `json:"holdings"`
	Positions broker.Positions `json:"positions"`
}

PortfolioResult contains the combined holdings and positions for a user.

type PreTradeCheckUseCase ¶

type PreTradeCheckUseCase struct {
	// contains filtered or unexported fields
}

PreTradeCheckUseCase performs pre-trade validation by gathering data from the broker.

func NewPreTradeCheckUseCase(resolver BrokerResolver, logger *slog.Logger) *PreTradeCheckUseCase

func (uc *PreTradeCheckUseCase) Execute(ctx context.Context, query cqrs.PreTradeCheckQuery) (*PreTradeData, error)

type PreTradeData ¶

type PreTradeData struct {
	LTP          map[string]broker.LTP `json:"ltp,omitempty"`
	Margins      *broker.Margins       `json:"margins,omitempty"`
	Positions    *broker.Positions     `json:"positions,omitempty"`
	Holdings     []broker.Holding      `json:"holdings,omitempty"`
	OrderMargins any                   `json:"order_margins,omitempty"`
	Errors       map[string]string     `json:"errors,omitempty"`
}

PreTradeData holds the raw data collected from parallel API calls.

type ProvisionUserOnLoginUseCase ¶

type ProvisionUserOnLoginUseCase struct {
	// contains filtered or unexported fields
}

ProvisionUserOnLoginUseCase upserts a user record on first login (or updates the LastLogin timestamp on subsequent logins) and backfills the Kite UID if it was previously empty. Suspended/offboarded users return an error so the caller can fail the login.

func NewProvisionUserOnLoginUseCase(p UserProvisioner, logger *slog.Logger) *ProvisionUserOnLoginUseCase

func (uc *ProvisionUserOnLoginUseCase) Execute(_ context.Context, cmd cqrs.ProvisionUserOnLoginCommand) error

type RegistryAdminWriter ¶

type RegistryAdminWriter interface {
	Register(id, apiKey, apiSecret, assignedTo, label, status, source, registeredBy string) error
	Update(id, assignedTo, label, status string) error
	Delete(id string) error
}

RegistryAdminWriter abstracts admin-side registry mutations.

type RegistrySync ¶

type RegistrySync interface {
	GetByEmail(email string) (apiKey string, found bool)
	GetByAPIKeyAnyStatus(apiKey string) (assignedTo string, found bool)
	MarkStatus(apiKey, status string)
	Register(id, apiKey, apiSecret, assignedTo, label, status, source, registeredBy string) error
	Update(apiKey, newAssignedTo, label, status string) error
	UpdateLastUsedAt(apiKey string)
}

RegistrySync is the port for SyncRegistryAfterLogin. Mirrors the few methods kiteExchangerAdapter calls on kc/registry.Store — narrow enough to test with a fake.

Update is keyed by APIKey here (not by registry-internal ID) because the use case identifies rows by APIKey at this layer. The adapter is responsible for translating APIKey → ID.

type RemoveFromWatchlistUseCase ¶

type RemoveFromWatchlistUseCase struct {
	// contains filtered or unexported fields
}

RemoveFromWatchlistUseCase removes an instrument from a watchlist.

func NewRemoveFromWatchlistUseCase(store WatchlistStore, logger *slog.Logger) *RemoveFromWatchlistUseCase

func (uc *RemoveFromWatchlistUseCase) Execute(ctx context.Context, cmd cqrs.RemoveFromWatchlistCommand) error

func (uc *RemoveFromWatchlistUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *RemoveFromWatchlistUseCase) SetEventStore(s EventAppender)

type RevokeCredentialsUseCase ¶

type RevokeCredentialsUseCase struct {
	// contains filtered or unexported fields
}

RevokeCredentialsUseCase deletes a user's Kite credentials and clears their cached access token. Narrower than DeleteMyAccountUseCase — it does not touch alerts, watchlists, trailing stops, paper trading, or the user's "offboarded" status. Use when the intent is "cut access to Kite" while preserving the rest of the account.

Added for Phase B-Audit task #25 so kc/ops dashboard/admin credential revoke paths can route through the bus without semantically expanding DeleteMyAccountCommand.

func NewRevokeCredentialsUseCase(credentialStore CredentialUpdater, tokenStore TokenStore, logger *slog.Logger) *RevokeCredentialsUseCase

func (uc *RevokeCredentialsUseCase) Execute(ctx context.Context, cmd cqrs.RevokeCredentialsCommand) error

func (uc *RevokeCredentialsUseCase) SetEventStore(s EventAppender)

type RiskGuardService ¶

type RiskGuardService interface {
	GetUserStatus(email string) riskguard.UserStatus
	GetEffectiveLimits(email string) riskguard.UserLimits
	GetGlobalFreezeStatus() riskguard.GlobalFreezeStatus
	IsGloballyFrozen() bool
	Freeze(email, by, reason string)
	Unfreeze(email string)
	FreezeGlobal(by, reason string)
	UnfreezeGlobal()
}

RiskGuardService abstracts riskguard for admin use cases.

type SagaError ¶

type SagaError struct {
	// FailedStep is the Name of the step whose Action returned the
	// triggering error.
	FailedStep string
	// Cause is the error returned by FailedStep's Action.
	Cause error
	// CompensationErrors collects any errors raised while running
	// Compensate on the steps that ran before FailedStep. Empty
	// slice when rollback ran cleanly.
	CompensationErrors []error
}

SagaError aggregates errors from a failed Saga: the original Action error that triggered rollback (Cause), and any errors raised during Compensate calls (CompensationErrors). Both are surfaced so callers can distinguish "rollback succeeded cleanly" from "rollback was itself partial".

func (e *SagaError) Error() string

func (e *SagaError) Unwrap() error

type SagaStep ¶

type SagaStep struct {
	// Name identifies the step in logs and the SagaError. Required.
	Name string
	// Action runs the forward operation. May return an error to
	// trigger rollback of all completed prior steps. Required.
	Action func(ctx context.Context) error
	// Compensate undoes the forward Action. May be nil for steps
	// without a meaningful compensation. Errors are logged but do
	// NOT block subsequent compensations.
	Compensate func(ctx context.Context) error
	// ContinueOnError — if true, an error from Action is logged but
	// does NOT trigger rollback; the saga continues to the next step.
	// Use for steps whose failure is acceptable (best-effort cleanups
	// in DeleteMyAccount: paper-engine reset, watchlist deletion).
	ContinueOnError bool
}

SagaStep is one unit of a multi-step business operation that may need to be rolled back if a later step fails. Each step has a forward Action (run during normal execution) and an optional Compensate (run during rollback, in reverse order).

Compensate is BEST-EFFORT: it is called for any step whose Action ran to completion (with or without success — see ContinueOnError). If Compensate itself returns an error, the error is logged and the next compensation runs anyway. This matches the BASE-style saga semantics described in Garcia-Molina & Salem (1987) and Microsoft's saga pattern guidance — full distributed-transaction ACID is NOT a goal here.

Compensate may be nil for steps that are idempotent or whose effects are intentionally not rolled back (e.g., audit-log appends — auditors want to see the failed attempt).

type SaveOAuthClientUseCase ¶

type SaveOAuthClientUseCase struct {
	// contains filtered or unexported fields
}

SaveOAuthClientUseCase persists an OAuth dynamic-client registration.

func NewSaveOAuthClientUseCase(s OAuthClientStore, logger *slog.Logger) *SaveOAuthClientUseCase

func (uc *SaveOAuthClientUseCase) Execute(_ context.Context, cmd cqrs.SaveOAuthClientCommand) error

type ServerMetricsResult ¶

type ServerMetricsResult struct {
	Period        string                 `json:"period"`
	Stats         *audit.Stats           `json:"stats"`
	ToolMetrics   []audit.ToolMetric     `json:"tool_metrics"`
	TopErrorUsers []audit.UserErrorCount `json:"top_error_users,omitempty"`
}

ServerMetricsResult holds the structured result of a server metrics query.

type ServerMetricsUseCase ¶

type ServerMetricsUseCase struct {
	// contains filtered or unexported fields
}

ServerMetricsUseCase retrieves server observability metrics.

func NewServerMetricsUseCase(store MetricsAuditReader, logger *slog.Logger) *ServerMetricsUseCase

func (uc *ServerMetricsUseCase) Execute(ctx context.Context, query cqrs.ServerMetricsQuery) (*ServerMetricsResult, error)

type SessionDataClearer ¶

type SessionDataClearer interface {
	ClearSessionData(sessionID string) error
}

SessionDataClearer abstracts the session-data clearing operation. Narrow port (one method) so the use case does not pull in the full ports.SessionPort surface just to perform a single lifecycle write. The kc package's SessionService satisfies this natively via its ClearSessionData method, so no adapter is required at the wiring site.

type SessionExporter ¶

type SessionExporter interface {
	ExportSessions(email string) ([]any, error)
	ExportCredentials(email string) ([]any, error)
}

SessionExporter retrieves session/credential metadata. Credentials must already be encrypted-at-rest; the export ships the encrypted blob.

type SessionLoginURLProvider ¶

type SessionLoginURLProvider interface {
	SessionLoginURL(mcpSessionID string) (string, error)
}

SessionLoginURLProvider is the narrow port LoginUseCase needs from the Manager to generate a Kite login URL for a given MCP session. Keeping the dependency narrow matches the batch C adapter pattern and lets the use case own the full validation+URL-generation flow without pulling in Manager internals.

type SessionTerminator ¶

type SessionTerminator interface {
	TerminateByEmail(email string) int
}

SessionTerminator abstracts session termination.

type SetTrailingStopUseCase ¶

type SetTrailingStopUseCase struct {
	// contains filtered or unexported fields
}

SetTrailingStopUseCase creates a new trailing stop-loss.

func NewSetTrailingStopUseCase(manager TrailingStopManager, logger *slog.Logger) *SetTrailingStopUseCase

func (uc *SetTrailingStopUseCase) Execute(ctx context.Context, cmd cqrs.SetTrailingStopCommand) (string, error)

func (uc *SetTrailingStopUseCase) SetEventDispatcher(d *domain.EventDispatcher)

func (uc *SetTrailingStopUseCase) SetEventStore(s EventAppender)

type SetupTelegramUseCase ¶

type SetupTelegramUseCase struct {
	// contains filtered or unexported fields
}

SetupTelegramUseCase registers a user's Telegram chat ID for notifications.

func NewSetupTelegramUseCase(store TelegramStore, logger *slog.Logger) *SetupTelegramUseCase

func (uc *SetupTelegramUseCase) Execute(ctx context.Context, cmd cqrs.SetupTelegramCommand) error

func (uc *SetupTelegramUseCase) SetEventDispatcher(d *domain.EventDispatcher)

type StartTickerUseCase ¶

type StartTickerUseCase struct {
	// contains filtered or unexported fields
}

StartTickerUseCase starts a WebSocket ticker.

func NewStartTickerUseCase(ticker TickerService, logger *slog.Logger) *StartTickerUseCase

func (uc *StartTickerUseCase) Execute(ctx context.Context, cmd cqrs.StartTickerCommand) error

type StopTickerUseCase ¶

type StopTickerUseCase struct {
	// contains filtered or unexported fields
}

StopTickerUseCase stops a WebSocket ticker.

func NewStopTickerUseCase(ticker TickerService, logger *slog.Logger) *StopTickerUseCase

func (uc *StopTickerUseCase) Execute(ctx context.Context, cmd cqrs.StopTickerCommand) error

type StoreUserKiteCredentialsUseCase ¶

type StoreUserKiteCredentialsUseCase struct {
	// contains filtered or unexported fields
}

StoreUserKiteCredentialsUseCase writes per-user API key/secret to the credential store after a successful bring-your-own-keys login.

func NewStoreUserKiteCredentialsUseCase(c KiteCredentialWriter, logger *slog.Logger) *StoreUserKiteCredentialsUseCase

func (uc *StoreUserKiteCredentialsUseCase) Execute(_ context.Context, cmd cqrs.StoreUserKiteCredentialsCommand) error

type StrategyLeg ¶

type StrategyLeg struct {
	TradingSymbol string  `json:"tradingsymbol"`
	OptionType    string  `json:"option_type"` // CE or PE
	Strike        float64 `json:"strike"`
	Action        string  `json:"action"` // BUY or SELL
	Lots          int     `json:"lots"`
	Quantity      int     `json:"quantity"`
	Premium       float64 `json:"premium"` // per-share LTP
	TotalPremium  float64 `json:"total_premium"`
}

StrategyLeg is the per-leg projection of an options strategy. JSON tags match the original mcp/trade/strategyLeg shape so the existing MCP tool handler + dashboard data path stay wire-compatible after the refactor (commit 1408871's payoffStrategyLeg consumes this same JSON shape).

type StrategyResponse ¶

type StrategyResponse struct {
	Strategy     string        `json:"strategy"`
	Underlying   string        `json:"underlying"`
	Expiry       string        `json:"expiry"`
	Legs         []StrategyLeg `json:"legs"`
	NetPremium   float64       `json:"net_premium"`
	MaxProfit    string        `json:"max_profit"`
	MaxLoss      string        `json:"max_loss"`
	MaxProfitAmt float64       `json:"max_profit_amt"`
	MaxLossAmt   float64       `json:"max_loss_amt"`
	Breakevens   []float64     `json:"breakevens"`
	RiskReward   string        `json:"risk_reward_ratio"`
	LotSize      int           `json:"lot_size"`
	TotalLots    int           `json:"total_lots"`
}

StrategyResponse is the use case output. JSON tags match the original mcp/trade/strategyResponse shape (wire-compat invariant).

type SubscribeInstrumentsUseCase ¶

type SubscribeInstrumentsUseCase struct {
	// contains filtered or unexported fields
}

SubscribeInstrumentsUseCase subscribes to instrument tick data.

func NewSubscribeInstrumentsUseCase(ticker TickerService, logger *slog.Logger) *SubscribeInstrumentsUseCase

func (uc *SubscribeInstrumentsUseCase) Execute(ctx context.Context, cmd cqrs.SubscribeInstrumentsCommand) error

type SyncRegistryAfterLoginUseCase ¶

type SyncRegistryAfterLoginUseCase struct {
	// contains filtered or unexported fields
}

SyncRegistryAfterLoginUseCase mirrors kiteExchangerAdapter.ExchangeWith Credentials' registry-side bookkeeping behind a port, dispatched as a command. Three behaviors:

1. AutoRegister=true + APIKey not in registry → new self_provisioned entry
2. AutoRegister=true + APIKey already exists with a different owner → reassign
3. Always: stamp LastUsedAt on the current APIKey if non-empty

If the user previously had a different APIKey, that prior entry is marked Replaced so audit trails show the rotation.

func NewSyncRegistryAfterLoginUseCase(r RegistrySync, logger *slog.Logger) *SyncRegistryAfterLoginUseCase

func (uc *SyncRegistryAfterLoginUseCase) Execute(ctx context.Context, cmd cqrs.SyncRegistryAfterLoginCommand) error

type TelegramStore ¶

type TelegramStore interface {
	SetTelegramChatID(email string, chatID int64)
	GetTelegramChatID(email string) (int64, bool)
}

TelegramStore abstracts Telegram chat ID persistence.

type TickerService ¶

type TickerService interface {
	Start(email, apiKey, accessToken string) error
	Stop(email string) error
	Subscribe(email string, tokens []uint32, mode ticker.Mode) error
	Unsubscribe(email string, tokens []uint32) error
	GetStatus(email string) (*ticker.Status, error)
	IsRunning(email string) bool
}

TickerService abstracts the WebSocket ticker for use cases.

type TickerStatusUseCase ¶

type TickerStatusUseCase struct {
	// contains filtered or unexported fields
}

TickerStatusUseCase retrieves ticker status.

func NewTickerStatusUseCase(ticker TickerService, logger *slog.Logger) *TickerStatusUseCase

func (uc *TickerStatusUseCase) Execute(ctx context.Context, query cqrs.TickerStatusQuery) (*ticker.Status, error)

type TokenStore ¶

type TokenStore interface {
	Delete(email string)
}

TokenStore abstracts token persistence for account use cases.

type ToolCallExporter ¶

type ToolCallExporter interface {
	ExportToolCalls(email string, since time.Time) ([]any, error)
}

ToolCallExporter retrieves tool_call rows for the user.

type TradingContextResult ¶

type TradingContextResult struct {
	Margins   *broker.Margins   `json:"margins,omitempty"`
	Positions *broker.Positions `json:"positions,omitempty"`
	Orders    []broker.Order    `json:"orders,omitempty"`
	Holdings  []broker.Holding  `json:"holdings,omitempty"`
	Errors    map[string]string `json:"errors,omitempty"`
}

TradingContextResult holds the unified trading context snapshot.

type TradingContextUseCase ¶

type TradingContextUseCase struct {
	// contains filtered or unexported fields
}

TradingContextUseCase retrieves a unified trading context snapshot.

func NewTradingContextUseCase(resolver BrokerResolver, logger *slog.Logger) *TradingContextUseCase

func (uc *TradingContextUseCase) Execute(ctx context.Context, query cqrs.TradingContextQuery) (*TradingContextResult, error)

type TrailingStopManager ¶

type TrailingStopManager interface {
	Add(ts *alerts.TrailingStop) (string, error)
	List(email string) []*alerts.TrailingStop
	Cancel(email, id string) error
	CancelByEmail(email string)
}

TrailingStopManager abstracts trailing stop persistence for use cases.

type UnsubscribeInstrumentsUseCase ¶

type UnsubscribeInstrumentsUseCase struct {
	// contains filtered or unexported fields
}

UnsubscribeInstrumentsUseCase removes instrument subscriptions.

func NewUnsubscribeInstrumentsUseCase(ticker TickerService, logger *slog.Logger) *UnsubscribeInstrumentsUseCase

func (uc *UnsubscribeInstrumentsUseCase) Execute(ctx context.Context, cmd cqrs.UnsubscribeInstrumentsCommand) error

type UpdateMyCredentialsUseCase ¶

type UpdateMyCredentialsUseCase struct {
	// contains filtered or unexported fields
}

UpdateMyCredentialsUseCase updates a user's Kite API credentials.

Round-5 Phase B note: this use case now OWNS the persistence step. The previous version was validation-only and the MCP tool handler called CredentialStore.Set + TokenStore.Delete separately — a CQRS bypass that left the command dispatched without the corresponding write. The command bus is now the single write entry point for credentials.

func NewUpdateMyCredentialsUseCase(credStore CredentialUpdater, tokenStore TokenStore, logger *slog.Logger) *UpdateMyCredentialsUseCase

func (uc *UpdateMyCredentialsUseCase) Execute(ctx context.Context, cmd cqrs.UpdateMyCredentialsCommand) error

func (uc *UpdateMyCredentialsUseCase) SetEventStore(s EventAppender)

type UserProvisioner ¶

type UserProvisioner interface {
	GetStatus(email string) string
	EnsureUser(email, kiteUID, displayName, onboardedBy string) UserRecord
	UpdateLastLogin(email string)
	UpdateKiteUID(email, kiteUID string)
}

UserProvisioner is the narrow port the ProvisionUserOnLogin use case needs. Implementations adapt kc/users.Store. EnsureUser is an upsert that returns the canonical record (or nil if the store is misconfigured); the use case uses the returned record to decide whether to backfill the Kite UID.

type UserRecord ¶

type UserRecord interface {
	GetKiteUID() string
}

UserRecord exposes only the fields the bridge use case needs to decide follow-up writes — keeps usecases.UserProvisioner free of the full kc/users.User struct which would create an import cycle.

type WatchlistExporter ¶

type WatchlistExporter interface {
	ExportWatchlists(email string) ([]any, error)
}

WatchlistExporter retrieves watchlists + items for the user.

type WatchlistInfo ¶

type WatchlistInfo struct {
	ID        string `json:"id"`
	Name      string `json:"name"`
	ItemCount int    `json:"item_count"`
	UpdatedAt string `json:"updated_at"`
}

WatchlistInfo holds summary information about a watchlist.

type WatchlistStore ¶

type WatchlistStore interface {
	CreateWatchlist(email, name string) (string, error)
	DeleteWatchlist(email, watchlistID string) error
	DeleteByEmail(email string)
	ListWatchlists(email string) []*watchlist.Watchlist
	FindWatchlistByName(email, name string) *watchlist.Watchlist
	ItemCount(watchlistID string) int
	AddItem(email, watchlistID string, item *watchlist.WatchlistItem) error
	RemoveItem(email, watchlistID, itemID string) error
	GetItems(watchlistID string) []*watchlist.WatchlistItem
	FindItemBySymbol(watchlistID, exchange, tradingsymbol string) *watchlist.WatchlistItem
}

WatchlistStore abstracts watchlist persistence for use cases.

type WidgetActivityResult ¶

type WidgetActivityResult struct {
	Entries    []*audit.ToolCall `json:"entries"`
	Stats      *audit.Stats      `json:"stats"`
	ToolCounts map[string]int    `json:"tool_counts"`
}

WidgetActivityResult is the activity widget data.

type WidgetAlertItem ¶

type WidgetAlertItem struct {
	ID             string  `json:"id"`
	Symbol         string  `json:"tradingsymbol"`
	Exchange       string  `json:"exchange"`
	Direction      string  `json:"direction"`
	TargetPrice    float64 `json:"target_price"`
	CurrentPrice   float64 `json:"current_price,omitempty"`
	DistancePct    float64 `json:"distance_pct,omitempty"`
	CreatedAt      string  `json:"created_at"`
	TriggeredAt    string  `json:"triggered_at,omitempty"`
	TriggeredPrice float64 `json:"triggered_price,omitempty"`
}

WidgetAlertItem is an alert formatted for the alerts widget.

type WidgetAlertStore ¶

type WidgetAlertStore interface {
	List(email string) []*alerts.Alert
}

WidgetAlertStore abstracts alert read operations for widget use cases.

type WidgetAlertsResult ¶

type WidgetAlertsResult struct {
	Active         []WidgetAlertItem `json:"active"`
	Triggered      []WidgetAlertItem `json:"triggered"`
	ActiveCount    int               `json:"active_count"`
	TriggeredCount int               `json:"triggered_count"`
}

WidgetAlertsResult is the alerts widget data.

type WidgetAuditStore ¶

type WidgetAuditStore interface {
	List(email string, opts audit.ListOptions) ([]*audit.ToolCall, int, error)
	GetStats(email string, since time.Time, category string, errorsOnly bool) (*audit.Stats, error)
	GetToolCounts(email string, since time.Time, category string, errorsOnly bool) (map[string]int, error)
	ListOrders(email string, since time.Time) ([]*audit.ToolCall, error)
}

WidgetAuditStore abstracts the audit store methods needed by widget use cases.

type WidgetBrokerClient ¶

type WidgetBrokerClient interface {
	GetHoldings() ([]broker.Holding, error)
	GetPositions() (broker.Positions, error)
	GetOrders() ([]broker.Order, error)
	GetLTP(instruments ...string) (map[string]broker.LTP, error)
}

WidgetBrokerClient abstracts the broker methods needed by widget use cases.

type WidgetHoldingItem ¶

type WidgetHoldingItem struct {
	Symbol    string  `json:"tradingsymbol"`
	Exchange  string  `json:"exchange"`
	Quantity  int     `json:"quantity"`
	AvgPrice  float64 `json:"average_price"`
	LastPrice float64 `json:"last_price"`
	PnL       float64 `json:"pnl"`
	DayChgPct float64 `json:"day_change_percentage"`
}

WidgetHoldingItem is a holding formatted for widget display.

type WidgetOrderEntry ¶

type WidgetOrderEntry struct {
	OrderID        string  `json:"order_id"`
	Symbol         string  `json:"tradingsymbol"`
	Exchange       string  `json:"exchange"`
	Side           string  `json:"transaction_type"`
	OrderType      string  `json:"order_type"`
	Quantity       float64 `json:"quantity"`
	FilledQuantity float64 `json:"filled_quantity"`
	Price          float64 `json:"price"`
	AveragePrice   float64 `json:"average_price"`
	Status         string  `json:"status"`
	PlacedAt       string  `json:"placed_at"`
}

WidgetOrderEntry is an order formatted for the orders widget.

type WidgetOrdersResult ¶

type WidgetOrdersResult struct {
	Orders  []WidgetOrderEntry `json:"orders"`
	Summary map[string]any     `json:"summary"`
}

WidgetOrdersResult is the orders widget data.

type WidgetPortfolioResult ¶

type WidgetPortfolioResult struct {
	Holdings  []WidgetHoldingItem  `json:"holdings"`
	Positions []WidgetPositionItem `json:"positions"`
	Summary   map[string]any       `json:"summary"`
}

WidgetPortfolioResult is the portfolio widget data.

type WidgetPositionItem ¶

type WidgetPositionItem struct {
	Symbol    string  `json:"tradingsymbol"`
	Exchange  string  `json:"exchange"`
	Quantity  int     `json:"quantity"`
	AvgPrice  float64 `json:"average_price"`
	LastPrice float64 `json:"last_price"`
	PnL       float64 `json:"pnl"`
	Product   string  `json:"product"`
}

WidgetPositionItem is a position formatted for widget display.

type WithdrawConsentResult ¶

type WithdrawConsentResult struct {
	EmailHash       string `json:"email_hash"`
	GrantsWithdrawn int64  `json:"grants_withdrawn"`
}

WithdrawConsentResult carries the outcome of a successful Execute. GrantsWithdrawn is the count of active-grant rows that got stamped. Zero is a normal outcome (user had nothing to withdraw); the caller can decide whether to surface it.

type WithdrawConsentUseCase ¶

type WithdrawConsentUseCase struct {
	// contains filtered or unexported fields
}

WithdrawConsentUseCase orchestrates DPDP §6(4) consent withdrawal: validate input, hash email, stamp consent_log, dispatch event.

func NewWithdrawConsentUseCase(
	w ConsentWithdrawer,
	h EmailHasher,
	d EventDispatcherPort,
	logger *slog.Logger,
) *WithdrawConsentUseCase

func (uc *WithdrawConsentUseCase) Execute(ctx context.Context, cmd cqrs.WithdrawConsentCommand) (*WithdrawConsentResult, error)

func (uc *WithdrawConsentUseCase) SetClock(now func() time.Time)