@infrab4a/connect 5.0.0-alpha.9 → 6.0.0-alpha.0

package/src/domain/shopping/repositories/checkout.repository.ts

@@ -0,0 +1,4 @@
+import { Checkout } from '../models/checkout'
+import { CrudRepository } from '../../generic/repository/crud.repository'
+
+export interface CheckoutRepository extends CrudRepository<Checkout> {}

package/src/domain/shopping/repositories/coupon.repository.ts

@@ -0,0 +1,4 @@
+import { Coupon } from '../models/coupons/coupon'
+import { CrudRepository } from '../../generic/repository/crud.repository'
+
+export interface CouponRepository extends CrudRepository<Coupon> {}

package/src/domain/shopping/repositories/index.ts

@@ -0,0 +1,10 @@
+export * from './buy-2-win.repository'
+export * from './campaign-dashboard.repository'
+export * from './campaign-hashtag.repository'
+export * from './checkout.repository'
+export * from './coupon.repository'
+export * from './legacy-order.repository'
+export * from './order-blocked.repository'
+export * from './order.repository'
+export * from './payment.repository'
+export * from './subscription'

package/src/domain/shopping/repositories/legacy-order.repository.ts

@@ -0,0 +1,3 @@
+import { OrderRepository } from './order.repository'
+
+export interface LegacyOrderRepository extends OrderRepository {}

package/src/domain/shopping/repositories/order-blocked.repository.ts

@@ -0,0 +1,15 @@
+import { CrudRepository } from '../../generic/repository/crud.repository'
+import { Checkout, OrderBlocked } from '../models'
+import { PaymentCardInfo } from '../types'
+
+type CreateBlockedOrderParams = {
+  checkout: Checkout
+  blockType: string
+  type: string
+  limiteRange: string
+  card?: PaymentCardInfo
+}
+
+export interface OrderBlockedRepository extends CrudRepository<OrderBlocked> {
+  createBlockedOrderOrPayment(params: CreateBlockedOrderParams): Promise<OrderBlocked>
+}

package/src/domain/shopping/repositories/order.repository.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../generic/repository/crud.repository'
+import { Order } from '../models/order'
+
+export interface OrderRepository extends CrudRepository<Order> {}

package/src/domain/shopping/repositories/payment.repository.ts

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../generic/repository/crud.repository'
+import { Payment } from '../models/payment'
+
+export interface PaymentRepository extends CrudRepository<Payment> {}

package/src/domain/shopping/repositories/subscription/checkout.repository.ts

@@ -0,0 +1,4 @@
+import { CheckoutSubscription } from '../../models/subscription/checkout'
+import { CrudRepository } from '../../../generic/repository/crud.repository'
+
+export interface CheckoutSubscriptionRepository extends CrudRepository<CheckoutSubscription> {}

package/src/domain/shopping/repositories/subscription/index.ts

@@ -0,0 +1,2 @@
+export * from './checkout.repository'
+export * from './plan.repository'

package/src/domain/shopping/repositories/subscription/plan.repository.ts

@@ -0,0 +1,4 @@
+import { SubscriptionPlan } from '../../models/subscription/plan'
+import { CrudRepository } from '../../../generic/repository/crud.repository'
+
+export interface SubscriptionPlanRepository extends CrudRepository<SubscriptionPlan> {}

package/src/domain/shopping/services/antifraud-bankslip.service.ts

@@ -0,0 +1,33 @@
+import { FraudValidationError } from '../../../errors'
+import { AntifraudProvider } from '../interfaces'
+import { Checkout } from '../models'
+import { OrderBlockedRepository } from '../repositories'
+
+export class AntifraudBankSlipService implements AntifraudProvider {
+  private MAX_ORDER_VALUE = 5000
+
+  constructor(private orderBlockedRepository: OrderBlockedRepository) {}
+
+  async validate(checkout: Checkout): Promise<Boolean> {
+    if (checkout.totalPrice && checkout.totalPrice > this.MAX_ORDER_VALUE && !checkout.user?.isSubscriber) {
+      await this.orderBlockedRepository.createBlockedOrderOrPayment({
+        checkout,
+        blockType: 'Boleto not authorized',
+        type: 'Boleto',
+        limiteRange: 'day',
+      })
+
+      throw new FraudValidationError('Boleto não autorizado para cliente não assinante', {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: {
+          isSubscriber: checkout.user?.isSubscriber,
+          subtotal: checkout.subTotalPrice,
+          total: checkout.totalPrice,
+        },
+      })
+    }
+
+    return true
+  }
+}

package/src/domain/shopping/services/antifraud-card.service.ts

@@ -0,0 +1,355 @@
+import { endOfDay, format, startOfDay, subDays } from 'date-fns'
+
+import { FraudValidationError } from '../../../errors'
+import { Where } from '../../generic'
+import { AntifraudProvider } from '../interfaces'
+import { Checkout } from '../models'
+import { OrderBlockedRepository, OrderRepository } from '../repositories'
+import { PaymentCardInfo } from '../types'
+
+type ValidationParams = {
+  cpf: string
+  email: string
+  phone: string
+  zip: string
+  card: PaymentCardInfo
+}
+
+type DateRange = {
+  firstDate: number
+  lastDate: number
+}
+
+type OrderCounts = {
+  cpf: number
+  email: number
+  phone: number
+  zip: number
+}
+
+type BlockedOrderRecordParams = {
+  checkout: Checkout
+  card: PaymentCardInfo | null
+  reason: string
+  key: string
+  period: string
+}
+
+type OrderLimitCheckParams = {
+  checkout: Checkout
+  orderCounts: OrderCounts
+  limit: number
+  period: string
+}
+
+type OrderFieldQueryParams = {
+  property: string
+  field: string
+  value: any
+  range: DateRange
+}
+
+export class AntifraudCardService implements AntifraudProvider {
+  private LIMIT_ORDERS_DAY = 2
+  private LIMIT_ORDERS_WEEK = 7
+  private LIMIT_BLOCKED_ORDERS_DAY = 5
+
+  constructor(
+    private readonly orderRepository: OrderRepository,
+    private readonly orderBlockedRepository: OrderBlockedRepository,
+  ) {}
+
+  async validate(checkout: Checkout, card: PaymentCardInfo): Promise<Boolean> {
+    await this.validateBlockedOrderAttempts(checkout, card)
+    await this.validateDayAndWeekOrderLimits(checkout, card)
+
+    return true
+  }
+
+  private async validateBlockedOrderAttempts(checkout: Checkout, card: PaymentCardInfo): Promise<void> {
+    const isValid = await this.verifyBlockedOrderAttempts(checkout, card)
+
+    if (!isValid) {
+      throw new FraudValidationError('Cliente com mais de 5 compras negadas/bloqueadas no dia', {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: {
+          isSubscriber: checkout.user?.isSubscriber,
+          subtotal: checkout.subTotalPrice,
+          total: checkout.totalPrice,
+        },
+      })
+    }
+  }
+
+  private async validateDayAndWeekOrderLimits(checkout: Checkout, card: PaymentCardInfo): Promise<void> {
+    const isValid = await this.verifyDayAndWeekOrders(checkout, card)
+
+    if (!isValid) {
+      throw new FraudValidationError('Cliente tentando comprar mais de 2 vezes no dia ou 7 vezes na semana', {
+        checkoutId: checkout.id,
+        userEmail: checkout.user.email,
+        info: {
+          isSubscriber: checkout.user?.isSubscriber,
+          subtotal: checkout.subTotalPrice,
+          total: checkout.totalPrice,
+        },
+      })
+    }
+  }
+
+  private async verifyBlockedOrderAttempts(checkout: Checkout, card: PaymentCardInfo): Promise<boolean> {
+    const dateRange = this.getTodayDateRange()
+    const blockedOrders = await this.getBlockedOrdersByMultipleCriteria(checkout, dateRange)
+    const totalBlockedAttempts = this.calculateUniqueBlockedAttempts(blockedOrders, checkout)
+
+    if (totalBlockedAttempts >= this.LIMIT_BLOCKED_ORDERS_DAY) {
+      await this.createBlockedOrderRecord({
+        checkout,
+        card,
+        reason: 'More than 5 attempts have failed',
+        key: 'Failed attempts',
+        period: 'day',
+      })
+
+      return false
+    }
+
+    return true
+  }
+
+  private getTodayDateRange() {
+    const day = `${format(new Date(), 'yyyy-MM-dd')}T00:00:00`
+    const endOfDay = `${format(new Date(), 'yyyy-MM-dd')}T23:59:59`
+
+    return { day, endOfDay }
+  }
+
+  private async getBlockedOrdersByMultipleCriteria(checkout: Checkout, dateRange: any) {
+    const { day, endOfDay } = dateRange
+    const dateFilter = [
+      { operator: Where.GTE, value: new Date(day) },
+      { operator: Where.LTE, value: new Date(endOfDay) },
+    ]
+
+    const [ordersBlockedWithCpf, ordersBlockedWithEmail, ordersBlockedWithCep, ordersBlockedWithPhone] =
+      await Promise.all([
+        this.getBlockedOrdersByCpf(checkout.user?.cpf, dateFilter),
+        this.getBlockedOrdersByEmail(checkout.user?.email, dateFilter),
+        this.getBlockedOrdersByZip(checkout.shippingAddress?.zip, dateFilter),
+        this.getBlockedOrdersByPhone(checkout.user?.phone, dateFilter),
+      ])
+
+    return {
+      ordersBlockedWithCpf,
+      ordersBlockedWithEmail,
+      ordersBlockedWithCep,
+      ordersBlockedWithPhone,
+    }
+  }
+
+  private async getBlockedOrdersByCpf(cpf: string | undefined, dateFilter: any[]) {
+    return this.orderBlockedRepository
+      .find({
+        filters: {
+          customer: { cpf: { operator: Where.EQUALS, value: cpf } },
+          ['date']: dateFilter,
+        },
+      })
+      .then((data) => data.data)
+  }
+
+  private async getBlockedOrdersByEmail(email: string | undefined, dateFilter: any[]) {
+    return this.orderBlockedRepository
+      .find({
+        filters: {
+          customer: { email: { operator: Where.EQUALS, value: email } },
+          ['date']: dateFilter,
+        },
+      })
+      .then((data) => data.data)
+  }
+
+  private async getBlockedOrdersByZip(zip: string | undefined, dateFilter: any[]) {
+    return this.orderBlockedRepository
+      .find({
+        filters: {
+          customer: { shippingAddress: { zip: { operator: Where.EQUALS, value: zip } } },
+          ['date']: dateFilter,
+        },
+      })
+      .then((data) => data.data)
+  }
+
+  private async getBlockedOrdersByPhone(phone: string | undefined, dateFilter: any[]) {
+    return this.orderBlockedRepository
+      .find({
+        filters: {
+          customer: { phoneNumber: { operator: Where.EQUALS, value: phone } },
+          ['date']: dateFilter,
+        },
+      })
+      .then((data) => data.data)
+  }
+
+  private calculateUniqueBlockedAttempts(blockedOrders: any, checkout: Checkout): number {
+    const { ordersBlockedWithCpf, ordersBlockedWithEmail, ordersBlockedWithCep, ordersBlockedWithPhone } = blockedOrders
+
+    const blockedUniqueEmails = this.filterUniqueEmailBlocked(ordersBlockedWithEmail, checkout)
+    const blockedUniqueCeps = this.filterUniqueZipBlocked(ordersBlockedWithCep, checkout)
+    const blockedUniquePhone = this.filterUniquePhoneBlocked(ordersBlockedWithPhone, checkout)
+
+    return ordersBlockedWithCpf.concat(blockedUniqueEmails).concat(blockedUniqueCeps).concat(blockedUniquePhone).length
+  }
+
+  private filterUniqueEmailBlocked(ordersBlockedWithEmail: any[], checkout: Checkout) {
+    return ordersBlockedWithEmail.filter((e) => e.customer.cpf !== checkout.user?.cpf)
+  }
+
+  private filterUniqueZipBlocked(ordersBlockedWithCep: any[], checkout: Checkout) {
+    return ordersBlockedWithCep.filter(
+      (e) => e.customer.cpf !== checkout.user?.cpf && e.customer.email !== checkout.user?.email,
+    )
+  }
+
+  private filterUniquePhoneBlocked(ordersBlockedWithPhone: any[], checkout: Checkout) {
+    return ordersBlockedWithPhone.filter(
+      (e) =>
+        e.customer.cpf !== checkout.user?.cpf &&
+        e.customer.email !== checkout.user?.email &&
+        e.customer.shippingAddress?.zip?.toString() !== checkout.shippingAddress?.zip?.toString(),
+    )
+  }
+
+  private async createBlockedOrderRecord(params: BlockedOrderRecordParams): Promise<void> {
+    const { checkout, card, reason, key, period } = params
+
+    await this.orderBlockedRepository.createBlockedOrderOrPayment({
+      checkout,
+      blockType: reason,
+      type: key,
+      limiteRange: period,
+      card,
+    })
+  }
+
+  private async verifyDayAndWeekOrders(checkout: Checkout, card: PaymentCardInfo): Promise<boolean> {
+    const validationParams = this.buildValidationParams(checkout, card)
+
+    const isDayLimitValid = await this.validateDayOrderLimits(checkout, validationParams)
+
+    if (!isDayLimitValid) return false
+
+    const isWeekLimitValid = await this.validateWeekOrderLimits(checkout, validationParams)
+
+    return isWeekLimitValid
+  }
+
+  private buildValidationParams(checkout: Checkout, card: PaymentCardInfo): ValidationParams {
+    return {
+      cpf: checkout.user?.cpf as string,
+      email: checkout.user?.email as string,
+      phone: checkout.user?.phone as string,
+      zip: checkout.shippingAddress?.zip as string,
+      card,
+    }
+  }
+
+  private async validateDayOrderLimits(checkout: Checkout, params: ValidationParams): Promise<boolean> {
+    const ordersPerDay = await this.validateOrdersByRange(params, this.getDateRange('day'))
+
+    return this.checkOrderLimitsAndBlock({
+      checkout,
+      orderCounts: ordersPerDay,
+      limit: this.LIMIT_ORDERS_DAY,
+      period: 'day',
+    })
+  }
+
+  private async validateWeekOrderLimits(checkout: Checkout, params: ValidationParams): Promise<boolean> {
+    const ordersPerWeek = await this.validateOrdersByRange(params, this.getDateRange('week'))
+
+    return this.checkOrderLimitsAndBlock({
+      checkout,
+      orderCounts: ordersPerWeek,
+      limit: this.LIMIT_ORDERS_WEEK,
+      period: 'week',
+    })
+  }
+
+  private async checkOrderLimitsAndBlock(params: OrderLimitCheckParams): Promise<boolean> {
+    const { checkout, orderCounts, limit, period } = params
+
+    for (const key in orderCounts) {
+      if (orderCounts[key as keyof OrderCounts] > limit) {
+        await this.createBlockedOrderRecord({
+          checkout,
+          card: null,
+          reason: 'Order limit',
+          key,
+          period,
+        })
+
+        return false
+      }
+    }
+
+    return true
+  }
+
+  private async validateOrdersByRange(params: ValidationParams, range: DateRange): Promise<OrderCounts> {
+    const { cpf, email, phone, zip } = params
+
+    const [ordersCpf, ordersByEmail, ordersByPhone, ordersByZip] = await Promise.all([
+      this.countOrdersByField({ property: 'user', field: 'cpf', value: cpf, range }),
+      this.countOrdersByField({ property: 'user', field: 'email', value: email, range }),
+      this.countOrdersByField({ property: 'user', field: 'phone', value: phone, range }),
+      this.countOrdersByField({ property: 'shippingAddress', field: 'zip', value: zip, range }),
+    ])
+
+    return {
+      cpf: ordersCpf,
+      email: ordersByEmail,
+      phone: ordersByPhone,
+      zip: ordersByZip,
+    }
+  }
+
+  private async countOrdersByField(params: OrderFieldQueryParams): Promise<number> {
+    const { property, field, value, range } = params
+
+    const filters = {
+      [property]: {
+        [field]: value,
+      },
+      ['createdAt']: [
+        { operator: Where.GTE, value: range.firstDate },
+        { operator: Where.LTE, value: range.lastDate },
+      ],
+    }
+
+    const docs = await (await this.orderRepository.find({ filters })).count
+
+    return docs
+  }
+
+  private getDateRange(range = 'day'): DateRange {
+    switch (range) {
+      case 'day':
+        return {
+          firstDate: startOfDay(new Date()).getTime(),
+          lastDate: endOfDay(new Date()).getTime(),
+        }
+      case 'week':
+        return {
+          firstDate: startOfDay(subDays(new Date(), 7)).getTime(),
+          lastDate: endOfDay(new Date()).getTime(),
+        }
+      default:
+        return {
+          firstDate: startOfDay(new Date()).getTime(),
+          lastDate: endOfDay(new Date()).getTime(),
+        }
+    }
+  }
+}

package/src/domain/shopping/services/antifraud-glampoints.service.ts

@@ -0,0 +1,10 @@
+import { AntifraudProvider } from '../interfaces'
+import { Checkout } from '../models'
+
+export class AntifraudGlampointsService implements AntifraudProvider {
+  constructor() {}
+
+  async validate(_checkout: Checkout): Promise<Boolean> {
+    return true
+  }
+}

package/src/domain/shopping/services/antifraud-pix.service.ts

@@ -0,0 +1,10 @@
+import { AntifraudProvider } from '../interfaces'
+import { Checkout } from '../models'
+
+export class AntifraudPixService implements AntifraudProvider {
+  constructor() {}
+
+  async validate(_checkout: Checkout): Promise<boolean> {
+    return true
+  }
+}

package/src/domain/shopping/services/glampoints-payment.service.ts

@@ -0,0 +1,123 @@
+import axios, { AxiosError } from 'axios'
+
+import { User } from '../../users'
+import { PaymentProviderGlampoints } from '../interfaces'
+import { Checkout, Order, Payment, PaymentTransaction } from '../models'
+import { PaymentRepository } from '../repositories'
+import { GlamCredentials } from '../types'
+
+export class GlampointsPaymentService implements PaymentProviderGlampoints {
+  constructor(private glamCredentials: GlamCredentials, private paymentRepository: PaymentRepository) {}
+
+  async pay(checkout: Checkout): Promise<Payment> {
+    const payment = await this.paymentRepository.create(
+      Payment.toInstance({
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        userId: checkout.user.id,
+        checkoutId: checkout.id,
+        totalPrice: checkout.totalPrice,
+        paymentProvider: 'glampoints',
+        transaction: {
+          amount: 0,
+          acquirer_response_code: '0000',
+          acquirer_name: 'glampoints',
+          authorized_amount: 0,
+          capture_method: 'ecommerce',
+          installments: 1,
+          cost: 0,
+          paid_amount: 0,
+          paid_at: new Date().toISOString(),
+          payment_method: 'glampoints',
+          referer: 'api_key',
+          refunded_amount: 0,
+          status: 'paid',
+          status_reason: 'acquirer',
+          date_created: new Date().toISOString(),
+        } as PaymentTransaction,
+      }),
+    )
+
+    return payment
+  }
+
+  async rewardByOrder(order: Order, user: User): Promise<any> {
+    try {
+      const points = order.lineItems.filter((item) => !item.isGift).reduce((acc, li) => acc + li.quantity, 0)
+      const hasGlambeauty = order.lineItems?.some(
+        (doc: { brand: string }) => doc.brand && doc.brand.toUpperCase() === 'GLAM BEAUTY',
+      )
+
+      const result = await axios({
+        method: 'POST',
+        url: `${this.glamCredentials.baseUrl}/integration/win/reward`,
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.glamCredentials.integrationToken}`,
+          Origin: 'https://cloudfunctions.b4a.com.br',
+        },
+        timeout: 60000,
+        data: JSON.stringify({
+          personId: user.id,
+          rewardType: 50,
+          referenceId: 0,
+          referenceName: `Compra - ${points} produto(s)`,
+          points,
+          productId: '',
+          token: this.glamCredentials.integrationToken,
+          orderId: order.id,
+          orderNumber: order.orderNumber,
+          glambeauty: hasGlambeauty,
+        }),
+      })
+
+      console.warn('[rewards - rewardByOrder] reward success:', order.orderNumber, JSON.stringify(result.data))
+
+      return result.data
+    } catch (error: any) {
+      if (error instanceof AxiosError)
+        console.error(
+          '[rewards - rewardByOrder] reward request error',
+          error.response.status,
+          JSON.stringify(error.response.data.message),
+          order.orderNumber,
+        )
+      else console.error(JSON.stringify(error))
+
+      throw new Error(`Reward errors: ${error.response.data.message}`)
+    }
+  }
+
+  async negativateRewardByOrderId(order: Order): Promise<any> {
+    try {
+      const result = await axios({
+        method: 'POST',
+        url: `${this.glamCredentials.baseUrl}/integration/negativate/reward`,
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.glamCredentials.integrationToken}`,
+          Origin: 'https://cloudfunctions.b4a.com.br',
+        },
+        timeout: 60000,
+        data: JSON.stringify({
+          rewardType: 51,
+          referenceName: `Pedido #${order.id} cancelado`,
+          token: '$2a$12$2DAPE64UUWAo4TT/1eQ9TOJO40b5z2jdomOJG3X7LeexwOHYtPydW',
+          orderId: order.id,
+          orderNumber: order.orderNumber,
+        }),
+      })
+
+      return result
+    } catch (error) {
+      if (error instanceof AxiosError)
+        console.error(
+          '[negativateRewardByOrderId] request error',
+          error.response.status,
+          JSON.stringify(error.response.data.message),
+          order.orderNumber,
+        )
+      else console.error(JSON.stringify(error))
+    }
+  }
+}

package/src/domain/shopping/services/index.ts

@@ -0,0 +1,5 @@
+export * from './antifraud-bankslip.service'
+export * from './antifraud-card.service'
+export * from './antifraud-glampoints.service'
+export * from './antifraud-pix.service'
+export * from './glampoints-payment.service'

package/src/domain/shopping/types/adyen-card.type.ts

@@ -0,0 +1,3 @@
+import { BaseCard } from './base-card.type'
+
+export interface AdyenCard extends BaseCard {}

package/src/domain/shopping/types/adyen-credentials.type.ts

@@ -0,0 +1,6 @@
+export type AdyenCredentials = {
+  URL_TRANSACTION: string
+  URL_POSTBACK: string
+  API_KEY: string
+  MERCHANT_ACCOUNT?: string
+}

package/src/domain/shopping/types/antifraud-provider.type.ts

@@ -0,0 +1,3 @@
+import { AntifraudProviders } from '../enums'
+
+export type AntifraudeProvider = `${AntifraudProviders}`

package/src/domain/shopping/types/base-card.type.ts

@@ -0,0 +1 @@
+export interface BaseCard {}

package/src/domain/shopping/types/card-info.type.ts

@@ -0,0 +1,8 @@
+export type CardInfo = {
+  name: string
+  number: string
+  expirationDate: string
+  cvv: string
+  installments?: string
+  cpf: string
+}

package/src/domain/shopping/types/checkout-paylod-request.type.ts

@@ -0,0 +1,16 @@
+import { PaymentProvider } from './payment-provider.type'
+
+export type CheckoutPayloadRequest = {
+  checkoutId: string
+  shopId: string
+  paymentProvider: PaymentProvider
+  isChange?: boolean
+  card?: {
+    installments: number
+    cardId: string
+    cardCvv?: string
+  }
+  boleto?: boolean
+  pix?: boolean
+  applicationVersion?: string
+}

package/src/domain/shopping/types/checkout-response.type.ts

@@ -0,0 +1,7 @@
+export type CheckoutResponse = {
+  data: {
+    orderId: string
+    boletoUrl?: string
+    pixQrCodeString?: string
+  }
+}

package/src/domain/shopping/types/checkout-stock-validation.type.ts

@@ -0,0 +1,5 @@
+export type CheckoutStockValidation = {
+  valid: boolean
+  outOfStock: string[]
+  limitedStock: string[]
+}