@infrab4a/connect-angular 5.0.0-alpha.9 → 5.0.0-beta.1

package/services/catalog/catalog.service.d.ts

@@ -1,20 +1,78 @@
-import { Category, RepositoryCacheOptions, Shops } from '@infrab4a/connect';
-import { CatalogSearchContext } from './context/catalog-search.context';
-import { CatalogHelpersService } from './services';
-import { FetchProductsParams, FetchProductsResponse, StockNotificationParams } from './types';
+import { Category, Product, ProductGender, ProductRepository, ProductsIndex, Shops } from '@infrab4a/connect';
+import { CategoryStructureAdapter } from './adapters';
+import { ProductSort } from './types/product-sort.type';
 import * as i0 from "@angular/core";
+type FetchProductsFilters = {
+    clubDiscount?: number[];
+    brands?: string[];
+    prices?: {
+        min?: number;
+        max?: number;
+        subscriberPrice?: boolean;
+    };
+    gender?: ProductGender[];
+    rate?: number;
+    customOptions?: string[];
+    tags?: string[];
+};
+type FetchProductsOptions = {
+    page?: number;
+    perPage?: number;
+    sort?: ProductSort;
+    mainGender?: ProductGender;
+};
+type FetchProductsMainParams<T extends Category> = {
+    category?: T;
+    profile?: string[];
+    term?: string;
+};
+type FetchProductsParams<T extends Category> = FetchProductsOptions & ({
+    category: FetchProductsMainParams<T>['category'];
+    filters?: FetchProductsFilters;
+} | {
+    profile: FetchProductsMainParams<T>['profile'];
+    filters?: FetchProductsFilters & {
+        customOptions?: never;
+        tags?: never;
+    };
+} | {
+    term: FetchProductsMainParams<T>['term'];
+    filters?: FetchProductsFilters & {
+        customOptions?: never;
+    };
+});
+type FetchProductsResponse = {
+    products: {
+        data: Product[];
+        total: number;
+    };
+    pages: number;
+    prices: {
+        price: {
+            min: number;
+            max: number;
+        };
+        subscriberPrice: {
+            min: number;
+            max: number;
+        };
+    };
+    brands?: string[];
+};
 export declare class CatalogService<T extends Category = Category> {
-    private readonly searchContext;
-    private readonly helpersService;
+    private readonly productRepository;
+    private readonly categoryStructureAdapter;
     private readonly shop;
-    constructor(searchContext: CatalogSearchContext, helpersService: CatalogHelpersService, shop: Shops);
-    fetchProducts(options: FetchProductsParams<T>, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<FetchProductsResponse>;
-    addCustomerToStockNotification(params: StockNotificationParams): Promise<void>;
-    private validateRequest;
-    private buildSearchParams;
-    private buildResponse;
+    private readonly productIndex;
+    private productsByTerm;
+    constructor(productRepository: ProductRepository, categoryStructureAdapter: CategoryStructureAdapter, shop: Shops, productIndex: ProductsIndex);
+    fetchProducts(options: FetchProductsParams<T>): Promise<FetchProductsResponse>;
+    private findCatalog;
+    private buildMainFilter;
+    private findCatalogByTermAndSortByMostRevelant;
+    private findCatalogIdsByElasticSearch;
+    private buildFilterQuery;
+    private buildSortQuery;
     private buildLimitQuery;
     private hasProfile;
     private hasTerm;
@@ -22,3 +80,4 @@ export declare class CatalogService<T extends Category = Category> {
     static ɵfac: i0.ɵɵFactoryDeclaration<CatalogService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CatalogService<any>>;
 }
+export {};

package/services/catalog/category.service.d.ts

@@ -1,22 +1,15 @@
-import { Category, Filter, ProductGender, RepositoryCacheOptions, Shops } from '@infrab4a/connect';
-import { CategoryRepositoryFacade, ProductCatalogFacade } from './facades';
+import { Category, CategoryFilterRepository, CategoryRepository, Filter, ProductGender, ProductRepository, Shops } from '@infrab4a/connect';
+import { CategoryStructureAdapter } from './adapters';
 import * as i0 from "@angular/core";
-type FetchBrandsOptions = {
-    mainGender?: ProductGender;
-    shop?: Shops;
-};
 export declare class CategoryService {
-    private readonly categoryFacade;
-    private readonly productCatalog;
+    private readonly productRepository;
+    private readonly categoryRepository;
+    private readonly categoryFilterRepository;
+    private readonly categoryStructureAdapter;
     private readonly shop;
-    constructor(categoryFacade: CategoryRepositoryFacade, productCatalog: ProductCatalogFacade, shop: Shops);
-    fetchBrands(category: Category, options?: FetchBrandsOptions, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category[]>;
-    fetchFilterOptions(category: Category, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Filter[]>;
+    constructor(productRepository: ProductRepository, categoryRepository: CategoryRepository, categoryFilterRepository: CategoryFilterRepository, categoryStructureAdapter: CategoryStructureAdapter, shop: Shops);
+    fetchBrands(category: Category, mainGender?: ProductGender): Promise<Category[]>;
+    fetchFilterOptions(category: Category): Promise<Filter[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CategoryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CategoryService>;
 }
-export {};

package/services/catalog/types/index.d.ts

@@ -1,5 +1 @@
-export * from './fetch-products-options.type';
-export * from './fetch-products-params.type';
-export * from './fetch-products-response.type';
-export * from './method-params.type';
 export * from './product-sort.type';

package/services/catalog/wishlist.service.d.ts

@@ -1,58 +1,39 @@
-import { LogRepository, PersonType, Shops, Wishlist, WishlistRepository } from '@infrab4a/connect';
+import { CategoryFilterRepository, CategoryRepository, ProductRepository, ProductsIndex, Shops, Wishlist, WishlistRepository } from '@infrab4a/connect';
 import { CatalogService } from './catalog.service';
 import { CategoryService } from './category.service';
-import { CatalogServiceFacade, CategoryServiceFacade } from './facades';
 import * as i0 from "@angular/core";
 export declare class WishlistService {
     private readonly wishlistRepository;
+    private readonly categoryRepository;
     private readonly shop;
-    private readonly logRepository;
     private catalogService;
     private categoryService;
-    constructor(wishlistRepository: WishlistRepository, shop: Shops, logRepository: LogRepository);
-    initializeServices(catalogServiceFacade: CatalogServiceFacade, categoryServiceFacade: CategoryServiceFacade): void;
+    constructor(wishlistRepository: WishlistRepository, categoryRepository: CategoryRepository, shop: Shops, productRepository: ProductRepository, categoryFilterRepository: CategoryFilterRepository, productIndex: ProductsIndex);
     getCatalogService(): CatalogService<import("@infrab4a/connect").Category>;
     getCategoryService(): CategoryService;
-    create({ personId, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }: {
+    create({ personId, title, description, userFullName, userPhoto, theme, bannerUrl, }: {
         personId: string;
         title: string;
         description: string;
-        published: boolean;
         userFullName: string;
         userPhoto?: string;
         theme?: string;
         bannerUrl?: string;
-        personType?: PersonType;
-        personIsSubscriber?: boolean;
     }): Promise<Wishlist>;
-    private buildWishlistData;
-    private findExistingWishlistByPersonId;
-    private createNewWishlist;
-    update({ id, title, description, published, userFullName, userPhoto, theme, bannerUrl, personType, personIsSubscriber, }: {
+    update({ id, title, description, userFullName, userPhoto, theme, bannerUrl, }: {
         id: string;
         title: string;
         description: string;
-        published: boolean;
         userFullName: string;
         userPhoto?: string;
         theme?: string;
         bannerUrl?: string;
-        personType?: PersonType;
-        personIsSubscriber?: boolean;
     }): Promise<Wishlist>;
     delete(wishlistId: string): Promise<void>;
     getWishlistBySlug(slug: string): Promise<Wishlist>;
     getWishlistsByPerson(personId: string): Promise<Wishlist[]>;
     addProduct(wishlistId: string, productId: string): Promise<Wishlist>;
     removeProduct(wishlistId: string, productId: string): Promise<Wishlist>;
-    private findById;
-    private findProductById;
-    private createWishlistLog;
-    private createWishlistOperationLog;
-    private createWishlistProductLog;
-    private getOperationTypeFromWishlistLogType;
-    private buildWishlistLogDocument;
-    private buildProductLogData;
     static ɵfac: i0.ɵɵFactoryDeclaration<WishlistService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WishlistService>;
 }

package/services/checkout-subscription.service.d.ts

@@ -1,19 +1,18 @@
-import { CheckoutSubscription, CheckoutSubscriptionRepository, Coupon } from '@infrab4a/connect';
+import { CheckoutSubscription, CheckoutSubscriptionRepository, Coupon, SubscriptionRepository } from '@infrab4a/connect';
 import { Observable } from 'rxjs';
-import { DataPersistence } from '../persistence';
 import { RequiredCheckoutSubscriptionData } from './types';
 import { CouponService } from './coupon.service';
 import * as i0 from "@angular/core";
 export declare class CheckoutSubscriptionService {
     private readonly checkoutSubscriptionRepository;
-    private readonly dataPersistence;
+    private readonly subscriptionRepository;
     private readonly couponService;
-    constructor(checkoutSubscriptionRepository: CheckoutSubscriptionRepository, dataPersistence: DataPersistence, couponService: CouponService);
+    constructor(checkoutSubscriptionRepository: CheckoutSubscriptionRepository, subscriptionRepository: SubscriptionRepository, couponService: CouponService);
     getCheckoutSubscription(checkoutData?: RequiredCheckoutSubscriptionData): Observable<CheckoutSubscription>;
+    private createCheckoutSubscription;
     clearCheckoutSubscriptionFromSession(): Observable<void>;
-    checkCoupon(nickname: string, _userEmail: string): Observable<Coupon>;
+    checkCoupon(nickname: string, userEmail: string): Observable<Coupon>;
     calcDiscountSubscription(coupon: Coupon): Observable<number>;
-    private createCheckoutSubscription;
     static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutSubscriptionService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutSubscriptionService>;
 }

package/services/checkout.service.d.ts

@@ -1,29 +1,22 @@
-import { Checkout, CheckoutPayloadRequest, CheckoutResponse, CheckoutStockValidation, CheckoutTypes, Coupon, ShippingMethodResponse, ShippingProductRequest, User, UserAddress } from '@infrab4a/connect';
+import { Checkout, CheckoutRepository, CheckoutTypes, Coupon, OrderRepository, Shops, User, UserRepository } from '@infrab4a/connect';
 import { Observable } from 'rxjs';
+import { CouponService } from './coupon.service';
 import { RequiredCheckoutData } from './types';
-import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './checkout';
-import { ConfigurationFacade } from './shared';
 import * as i0 from "@angular/core";
 export declare class CheckoutService {
-    private readonly repositoriesFacade;
-    private readonly dependenciesFacade;
-    private readonly configurationFacade;
-    private checkoutUrl;
-    constructor(repositoriesFacade: CheckoutRepositoriesFacade, dependenciesFacade: CheckoutDependenciesFacade, configurationFacade: ConfigurationFacade);
+    private readonly couponService;
+    private readonly checkoutRepository;
+    private readonly orderRepository;
+    private readonly userRepository;
+    private readonly defaultShop;
+    constructor(couponService: CouponService, checkoutRepository: CheckoutRepository, orderRepository: OrderRepository, userRepository: UserRepository, defaultShop: Shops);
     getCheckout(checkoutData?: RequiredCheckoutData): Observable<Checkout>;
     getUserByCheckout(checkoutId: string): Observable<User>;
     updateCheckoutLineItems(checkout: Partial<Checkout>): Observable<Checkout>;
     updateCheckoutUser(checkout: Partial<Checkout>): Observable<Checkout>;
     clearCheckoutFromSession(): Observable<void>;
-    resetCheckoutValues(): Observable<Checkout>;
-    applyCouponDiscount(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon>;
-    removeCouponDiscount(): Observable<Checkout>;
-    validateStockProducts(): Observable<CheckoutStockValidation>;
-    selectShippingAddress(address: UserAddress): Observable<Checkout>;
-    getAvailableShippingForProduct(productShipping: ShippingProductRequest): Observable<ShippingMethodResponse[]>;
-    getAvailableShippingForCheckout(): Observable<ShippingMethodResponse[]>;
-    selectShipping(option: string): Observable<Checkout>;
-    createOrder(checkoutPayload: CheckoutPayloadRequest, paymentProvider: string, applicationVersion: string): Observable<CheckoutResponse>;
+    calcDiscount(coupon: Coupon): Observable<number>;
+    checkCoupon(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon>;
     private createCheckout;
     static ɵfac: i0.ɵɵFactoryDeclaration<CheckoutService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CheckoutService>;

package/services/coupon.service.d.ts

@@ -1,25 +1,18 @@
-import { CheckoutSubscription, Coupon } from '@infrab4a/connect';
+import { CategoryRepository, Checkout, CheckoutSubscription, CheckoutTypes, Coupon, CouponRepository, OrderRepository, Shops } from '@infrab4a/connect';
 import { Observable } from 'rxjs';
-import { CouponRepositoriesFacade } from './coupon';
-import { CheckCouponParams } from './coupon/types/coupon-params.type';
-import { ConfigurationFacade } from './shared';
 import * as i0 from "@angular/core";
 export declare class CouponService {
-    private readonly repositoriesFacade;
-    private readonly configurationFacade;
-    constructor(repositoriesFacade: CouponRepositoriesFacade, configurationFacade: ConfigurationFacade);
-    checkCoupon(params: CheckCouponParams): Observable<Coupon>;
+    private readonly couponRepository;
+    private readonly defaultShop;
+    private readonly orderRepository;
+    private readonly categoryRepository;
+    constructor(couponRepository: CouponRepository, defaultShop: Shops, orderRepository: OrderRepository, categoryRepository: CategoryRepository);
+    checkCoupon(nickname: string, checkoutType: CheckoutTypes, checkout: Partial<Checkout>, plan: string): Observable<Coupon>;
     private couponValidation;
     private couponRulesValidation;
-    private validateSubscriptionCoupon;
-    private validateEcommerceCoupon;
-    private validateUserEligibility;
-    private validateUsageLimits;
-    private validateFirstOrderLimit;
-    private validateCouponUsageLimits;
-    private validateProductEligibility;
-    private throwMinSubTotalError;
     calcDiscountSubscription(coupon: Coupon, checkout: Partial<CheckoutSubscription>): Observable<number>;
+    calcDiscountShopping(coupon: Coupon, checkout: Partial<Checkout>): Promise<number>;
+    private calcDiscountByType;
     private hasMinSubTotal;
     private hasProductCategories;
     private coupomUserValidation;

package/services/home-shop.service.d.ts

@@ -1,15 +1,15 @@
-import { Banner, Home } from '@infrab4a/connect';
+import { Banner, CategoryRepository, Home, HomeRepository, ProductRepository, Shops } from '@infrab4a/connect';
 import { Observable } from 'rxjs';
-import { HomeShopRepositoriesFacade } from './home-shop';
-import { ConfigurationFacade } from './shared';
 import * as i0 from "@angular/core";
 type BannerType = 'brand' | 'buyToWin' | 'block' | 'blog';
 export declare class HomeShopService {
-    private readonly repositoriesFacade;
-    private readonly configurationFacade;
+    private readonly categoryRepository;
+    private readonly homeRepository;
+    private readonly productRepository;
+    private readonly defaultShop;
     private homeConfiguration;
     private get homeId();
-    constructor(repositoriesFacade: HomeShopRepositoriesFacade, configurationFacade: ConfigurationFacade);
+    constructor(categoryRepository: CategoryRepository, homeRepository: HomeRepository, productRepository: ProductRepository, defaultShop: Shops);
     getHomeData(): Observable<Home>;
     getBanners(type: BannerType): Observable<Banner[]>;
     getMinValueForFreeShipping(): Observable<number>;

package/services/index.d.ts

@@ -7,3 +7,4 @@ export * from './coupon.service';
 export * from './helpers';
 export * from './home-shop.service';
 export * from './order.service';
+export * from './shipping.service';

package/services/shipping.service.d.ts

@@ -0,0 +1,19 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { HomeShopService } from './home-shop.service';
+import { ShippingMethodResponse } from './types/shipping-methods.type';
+import * as i0 from "@angular/core";
+export declare class ShippingService {
+    private http;
+    private apiUrl;
+    private homeService;
+    constructor(http: HttpClient, apiUrl: string, homeService: HomeShopService);
+    getShippingMethods(shop: string, zip: string, weightGrams: number, totalPrice: number, personId: string, subscriptionPlan?: string): Observable<Array<ShippingMethodResponse & {
+        ShippingCompanyName?: string;
+    }>>;
+    private isFreeShippingBySubscription;
+    private isHalfShippingBySubscription;
+    private isHolidays;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShippingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShippingService>;
+}

package/services/types/shipping-methods.type.d.ts

@@ -0,0 +1,12 @@
+export interface ShippingMethodResponse {
+    daysToDelivery: number;
+    currency: string;
+    description: string;
+    maxDeliveryDate: string;
+    minDeliveryDate: string;
+    serviceCode: string;
+    serviceName: string;
+    totalPrice: number;
+    additionalDescription: string;
+    cnpj: string;
+}

package/angular-vertex-search.module.d.ts

@@ -1,9 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { VertexSearchConfig } from '@infrab4a/connect';
-import * as i0 from "@angular/core";
-export declare class AngularVertexSeachModule {
-    static initializeApp(options: VertexSearchConfig): ModuleWithProviders<AngularVertexSeachModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularVertexSeachModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularVertexSeachModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AngularVertexSeachModule>;
-}

package/consts/persistence.const.d.ts

@@ -1 +0,0 @@
-export declare const PERSISTENCE_PROVIDER = "PERSISTENCE_PROVIDER";

package/consts/vertex-config.const.d.ts

@@ -1 +0,0 @@
-export declare const VERTEX_CONFIG = "VERTEX_CONFIG";