@infrab4a/connect 6.0.0-alpha.0 → 6.0.0-alpha.1

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

@@ -1,355 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

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

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

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

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

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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

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

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

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

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

@@ -1,6 +0,0 @@
-export type GlamCredentials = {
-  baseUrl: string
-  username: string
-  password: string
-  integrationToken: string
-}

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

@@ -1,16 +0,0 @@
-export * from './adyen-card.type'
-export * from './adyen-credentials.type'
-export * from './antifraud-provider.type'
-export * from './card-info.type'
-export * from './checkout-paylod-request.type'
-export * from './checkout-response.type'
-export * from './checkout-stock-validation.type'
-export * from './glam-credentials.type'
-export * from './order-tracking-events.type'
-export * from './pagarme-card.type'
-export * from './pagarme-credentials.type'
-export * from './payment-card-info.type'
-export * from './payment-method.type'
-export * from './payment-provider.type'
-export * from './shipping-method-response.type'
-export * from './shipping-product-request.type'

package/src/domain/shopping/types/order-tracking-events.type.ts

@@ -1,14 +0,0 @@
-export type OrderTrackingEvent = {
-  cnpj?: string
-  eventCategory?: string
-  eventDate?: string
-  eventDescription?: string
-  eventTime?: string
-  invoiceNumber?: string
-  observation?: string
-  proofUrl?: string
-  receiverDocument?: string
-  receiverName?: string
-  receiverRelationship?: string
-  shippingCompanyName?: string
-}

package/src/domain/shopping/types/pagarme-card-manual-hash.type.ts

@@ -1,7 +0,0 @@
-import { BaseCard } from './base-card.type'
-
-export interface PagarMeCardManualHash extends BaseCard {
-  id: string
-  public_key: string
-  date_created: string
-}

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

@@ -1,17 +0,0 @@
-import { BaseCard } from './base-card.type'
-
-export interface PagarMeCard extends BaseCard {
-  object: string
-  id: string
-  date_created: string
-  date_updated: string
-  brand: string
-  holder_name: string
-  first_digits: string
-  last_digits: string
-  country: string
-  fingerprint: string
-  customer: string
-  valid: boolean
-  expiration_date: string
-}

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

@@ -1,7 +0,0 @@
-export type PagarmeCredentials = {
-  URL: string
-  URL_POSTBACK: string
-  API_KEY: string
-  SUBSCRIPTION_API_KEY: string
-  SHOP_API_KEY: string
-}

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

@@ -1,7 +0,0 @@
-export type PaymentCardInfo = {
-  cardId: string
-  cardCvv?: string
-  installments: number
-  cpf?: string
-  fingerprint?: string
-}

package/src/domain/shopping/types/payment-method.type.ts

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

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

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

package/src/domain/shopping/types/shipping-method-response.type.ts

@@ -1,13 +0,0 @@
-export type ShippingMethodResponse = {
-  daysToDelivery: number
-  currency?: string
-  description: string
-  maxDeliveryDate: string
-  minDeliveryDate: string
-  serviceCode: string
-  serviceName: string
-  totalPrice: number
-  additionalDescription?: string
-  cnpj?: string
-  ShippingCompanyName?: string
-}