efrilmandClaude Opus 5.5
8370851ed2
Adds the 6-digit customer PIN that approves every action moving EnakPoint or EnakCoin on the customer's request (docs/prd-point-coin.md K8, F11, Q16, Q17, PC-301). Migration 000093 adds the PIN columns to customers and the customer_security_events table. PIN data is read and written only through CustomerPinRepository, never the Customer entity, so the hash cannot reach a customer response. Only a bcrypt hash is stored. - /customer/pin: status, OTP (pin_setup, pin_reset), create, change, reset. The OTP must be for that purpose and sent to the customer's own number; the existing OTP validation checks neither. A new PIN is checked (6 digits, confirmed, not one digit, not a run up or down, not the birth date as DDMMYY or YYMMDD) before the OTP is spent. - Five wrong attempts in a row lock the PIN for 30 minutes; the counter is incremented in one statement so attempts at the same time all count, and a lock that ran out starts a new series. A locked PIN is refused even when right. The customer is told by WhatsApp, as there is no push channel to customers yet; only the attempt that reached the limit alerts. - A reset through OTP lifts the lock and holds outgoing transfers for 24 hours; paying and exchanging still work, and a held transfer costs no attempt. - VerifyPin(ctx, customer, pin, action) for the flows that follow, with PIN_NOT_SET, PIN_INVALID (attempts left), PIN_LOCKED and TRANSFER_BLOCKED (until when), which PinErrorResponse turns into distinct codes and statuses. - DELETE /marketing/customers/:id/pin (loyalty managers, reason required) and GET /marketing/customers/:id/security-events, scoped to the organization. Every PIN event is in the security log with IP and user agent. No message or binding error contains a PIN. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
129 lines
5.6 KiB
Go
129 lines
5.6 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"apskel-pos-be/internal/appcontext"
|
|
"apskel-pos-be/internal/constants"
|
|
"apskel-pos-be/internal/contract"
|
|
"apskel-pos-be/internal/models"
|
|
"apskel-pos-be/internal/processor"
|
|
"apskel-pos-be/internal/repository"
|
|
)
|
|
|
|
// CustomerPinService serves the customer's PIN (docs/prd-point-coin.md F11) and the
|
|
// dashboard's view of it.
|
|
type CustomerPinService interface {
|
|
Status(ctx context.Context, customerID uuid.UUID) *contract.Response
|
|
RequestOtp(ctx context.Context, customerID uuid.UUID, req *contract.RequestPinOtpRequest) *contract.Response
|
|
CreatePin(ctx context.Context, customerID uuid.UUID, req *contract.CreateCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response
|
|
ChangePin(ctx context.Context, customerID uuid.UUID, req *contract.ChangeCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response
|
|
ResetPin(ctx context.Context, customerID uuid.UUID, req *contract.ResetCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response
|
|
|
|
RemovePin(ctx context.Context, apctx *appcontext.ContextInfo, customerID uuid.UUID, req *contract.RemoveCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response
|
|
ListSecurityEvents(ctx context.Context, apctx *appcontext.ContextInfo, customerID uuid.UUID, page, limit int) *contract.Response
|
|
}
|
|
|
|
type CustomerPinServiceImpl struct {
|
|
pins *processor.CustomerPinProcessor
|
|
}
|
|
|
|
func NewCustomerPinService(pins *processor.CustomerPinProcessor) *CustomerPinServiceImpl {
|
|
return &CustomerPinServiceImpl{pins: pins}
|
|
}
|
|
|
|
func (s *CustomerPinServiceImpl) Status(ctx context.Context, customerID uuid.UUID) *contract.Response {
|
|
status, err := s.pins.Status(ctx, customerID)
|
|
if err != nil {
|
|
return PinErrorResponse(err)
|
|
}
|
|
return contract.BuildSuccessResponse(status)
|
|
}
|
|
|
|
func (s *CustomerPinServiceImpl) RequestOtp(ctx context.Context, customerID uuid.UUID, req *contract.RequestPinOtpRequest) *contract.Response {
|
|
otp, err := s.pins.RequestOtp(ctx, customerID, req.Purpose)
|
|
if err != nil {
|
|
return PinErrorResponse(err)
|
|
}
|
|
return contract.BuildSuccessResponse(otp)
|
|
}
|
|
|
|
func (s *CustomerPinServiceImpl) CreatePin(ctx context.Context, customerID uuid.UUID, req *contract.CreateCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response {
|
|
if err := s.pins.CreatePin(ctx, customerID, req.OtpToken, req.OtpCode, req.Pin, req.ConfirmPin, info); err != nil {
|
|
return PinErrorResponse(err)
|
|
}
|
|
return s.Status(ctx, customerID)
|
|
}
|
|
|
|
func (s *CustomerPinServiceImpl) ChangePin(ctx context.Context, customerID uuid.UUID, req *contract.ChangeCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response {
|
|
if err := s.pins.ChangePin(ctx, customerID, req.OldPin, req.Pin, req.ConfirmPin, info); err != nil {
|
|
return PinErrorResponse(err)
|
|
}
|
|
return s.Status(ctx, customerID)
|
|
}
|
|
|
|
func (s *CustomerPinServiceImpl) ResetPin(ctx context.Context, customerID uuid.UUID, req *contract.ResetCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response {
|
|
if err := s.pins.ResetPin(ctx, customerID, req.OtpToken, req.OtpCode, req.Pin, req.ConfirmPin, info); err != nil {
|
|
return PinErrorResponse(err)
|
|
}
|
|
return s.Status(ctx, customerID)
|
|
}
|
|
|
|
func (s *CustomerPinServiceImpl) RemovePin(ctx context.Context, apctx *appcontext.ContextInfo, customerID uuid.UUID, req *contract.RemoveCustomerPinRequest, info models.CustomerPinRequestInfo) *contract.Response {
|
|
if err := s.pins.RemovePinByAdmin(ctx, apctx.OrganizationID, customerID, apctx.UserID, req.Reason, info); err != nil {
|
|
return PinErrorResponse(err)
|
|
}
|
|
return contract.BuildSuccessResponse(map[string]interface{}{"message": "PIN removed; the customer has to create a new one"})
|
|
}
|
|
|
|
func (s *CustomerPinServiceImpl) ListSecurityEvents(ctx context.Context, apctx *appcontext.ContextInfo, customerID uuid.UUID, page, limit int) *contract.Response {
|
|
events, err := s.pins.ListEvents(ctx, apctx.OrganizationID, customerID, page, limit)
|
|
if err != nil {
|
|
return PinErrorResponse(err)
|
|
}
|
|
return contract.BuildSuccessResponse(events)
|
|
}
|
|
|
|
// PinErrorResponse turns an error from a PIN-guarded action into a response the apps
|
|
// can act on. A *processor.PinError keeps its code (PIN_NOT_SET, PIN_INVALID,
|
|
// PIN_LOCKED, TRANSFER_BLOCKED) and puts the attempts left or the time it lifts in the
|
|
// response data. Other errors map to a validation or server error.
|
|
func PinErrorResponse(err error) *contract.Response {
|
|
var pinErr *processor.PinError
|
|
if errors.As(err, &pinErr) {
|
|
data := map[string]interface{}{"code": pinErr.Code}
|
|
switch pinErr.Code {
|
|
case processor.PinErrInvalid:
|
|
data["remaining_attempts"] = pinErr.RemainingAttempts
|
|
case processor.PinErrLocked:
|
|
data["locked_until"] = pinErr.Until
|
|
case processor.PinErrTransferBlocked:
|
|
data["transfer_blocked_until"] = pinErr.Until
|
|
}
|
|
return &contract.Response{
|
|
Success: false,
|
|
Data: data,
|
|
Errors: []*contract.ResponseError{contract.NewResponseError(pinErr.Code, constants.CustomerPinServiceEntity, pinErr.Error())},
|
|
}
|
|
}
|
|
|
|
code := constants.InternalServerErrorCode
|
|
switch {
|
|
case errors.Is(err, repository.ErrPinCustomerNotFound):
|
|
code = constants.NotFoundErrorCode
|
|
case errors.Is(err, processor.ErrPinOtpTooSoon):
|
|
code = constants.TooManyRequestsErrorCode
|
|
case errors.Is(err, processor.ErrInvalidPinInput),
|
|
errors.Is(err, processor.ErrPinAlreadySet),
|
|
errors.Is(err, processor.ErrPinOtpInvalid),
|
|
errors.Is(err, processor.ErrPinNoPhone):
|
|
code = constants.ValidationErrorCode
|
|
}
|
|
return contract.BuildErrorResponse([]*contract.ResponseError{
|
|
contract.NewResponseError(code, constants.CustomerPinServiceEntity, err.Error()),
|
|
})
|
|
}
|