@lcdp/api-react-rest-client 2.4.0-develop.5421336326 → 2.4.0-develop.5544937458

package/product/src/apis/SearchProductMetadataApi.d.ts

@@ -11,10 +11,24 @@
  */
 import { BaseAPI, ApiResponse, BlobWithMeta } from '../runtime';
 import { ProductSecondaryType, ProductType } from '../models';
+export interface GetProductSecondaryTypeRequest {
+    secondaryTypeId: string;
+}
+export interface GetProductTypeRequest {
+    typeId: string;
+}
 /**
  * no description
  */
 export declare class SearchProductMetadataApi extends BaseAPI {
+    /**
+     * Get product secondary type
+     */
+    getProductSecondaryTypeRaw(requestParameters: GetProductSecondaryTypeRequest): Promise<ApiResponse<ProductSecondaryType | BlobWithMeta>>;
+    /**
+     * Get product secondary type
+     */
+    getProductSecondaryType(requestParameters: GetProductSecondaryTypeRequest): Promise<ProductSecondaryType | BlobWithMeta>;
     /**
      * Get product secondary types
      */
@@ -23,6 +37,14 @@ export declare class SearchProductMetadataApi extends BaseAPI {
      * Get product secondary types
      */
     getProductSecondaryTypes(): Promise<Array<ProductSecondaryType> | BlobWithMeta>;
+    /**
+     * Get product type
+     */
+    getProductTypeRaw(requestParameters: GetProductTypeRequest): Promise<ApiResponse<ProductType | BlobWithMeta>>;
+    /**
+     * Get product type
+     */
+    getProductType(requestParameters: GetProductTypeRequest): Promise<ProductType | BlobWithMeta>;
     /**
      * Get product types
      */

package/product/src/apis/SearchProductMetadataApi.js

@@ -76,14 +76,17 @@ var SearchProductMetadataApi = /** @class */ (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     /**
-     * Get product secondary types
+     * Get product secondary type
      */
-    SearchProductMetadataApi.prototype.getProductSecondaryTypesRaw = function () {
+    SearchProductMetadataApi.prototype.getProductSecondaryTypeRaw = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, token, tokenString, response, contentType, response_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        if (requestParameters.secondaryTypeId === null || requestParameters.secondaryTypeId === undefined) {
+                            throw new runtime_1.RequiredError('secondaryTypeId', 'Required parameter requestParameters.secondaryTypeId was null or undefined when calling getProductSecondaryType.');
+                        }
                         queryParameters = {};
                         headerParameters = {};
                         if (this.configuration && this.configuration.apiKey) {
@@ -100,7 +103,7 @@ var SearchProductMetadataApi = /** @class */ (function (_super) {
                     case 1:
                         _a.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, this.request({
-                                path: "/products/secondary-types",
+                                path: "/products/secondary-types/{secondaryTypeId}".replace("{".concat("secondaryTypeId", "}"), encodeURIComponent(String(requestParameters.secondaryTypeId))),
                                 method: 'GET',
                                 headers: headerParameters,
                                 query: queryParameters,
@@ -109,7 +112,7 @@ var SearchProductMetadataApi = /** @class */ (function (_super) {
                         response = _a.sent();
                         contentType = response.headers.get("content-type");
                         if (contentType && contentType.indexOf("application/json") !== -1) {
-                            return [2 /*return*/, new runtime_1.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(models_1.ProductSecondaryTypeFromJSON); })];
+                            return [2 /*return*/, new runtime_1.JSONApiResponse(response, function (jsonValue) { return (0, models_1.ProductSecondaryTypeFromJSON)(jsonValue); })];
                         }
                         else if (contentType && contentType.indexOf("text/plain") !== -1) {
                             return [2 /*return*/, new runtime_1.TextApiResponse(response)];
@@ -128,6 +131,76 @@ var SearchProductMetadataApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Get product secondary type
+     */
+    SearchProductMetadataApi.prototype.getProductSecondaryType = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getProductSecondaryTypeRaw(requestParameters)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get product secondary types
+     */
+    SearchProductMetadataApi.prototype.getProductSecondaryTypesRaw = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response, contentType, response_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (this.configuration && this.configuration.apiKey) {
+                            headerParameters["x-api-key"] = this.configuration.apiKey("x-api-key"); // apiKeyAuth authentication
+                        }
+                        if (this.configuration && this.configuration.accessToken) {
+                            token = this.configuration.accessToken;
+                            tokenString = typeof token === 'function' ? token("bearerAuth", []) : token;
+                            if (tokenString) {
+                                headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                            }
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.request({
+                                path: "/products/secondary-types",
+                                method: 'GET',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            })];
+                    case 2:
+                        response = _a.sent();
+                        contentType = response.headers.get("content-type");
+                        if (contentType && contentType.indexOf("application/json") !== -1) {
+                            return [2 /*return*/, new runtime_1.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(models_1.ProductSecondaryTypeFromJSON); })];
+                        }
+                        else if (contentType && contentType.indexOf("text/plain") !== -1) {
+                            return [2 /*return*/, new runtime_1.TextApiResponse(response)];
+                        }
+                        else {
+                            // TODO : Better handling of others application types
+                            return [2 /*return*/, new runtime_1.BlobWithMetaApiResponse(response)];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        response_2 = _a.sent();
+                        console.debug(response_2);
+                        throw response_2;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Get product secondary types
      */
@@ -145,12 +218,85 @@ var SearchProductMetadataApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Get product type
+     */
+    SearchProductMetadataApi.prototype.getProductTypeRaw = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response, contentType, response_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters.typeId === null || requestParameters.typeId === undefined) {
+                            throw new runtime_1.RequiredError('typeId', 'Required parameter requestParameters.typeId was null or undefined when calling getProductType.');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (this.configuration && this.configuration.apiKey) {
+                            headerParameters["x-api-key"] = this.configuration.apiKey("x-api-key"); // apiKeyAuth authentication
+                        }
+                        if (this.configuration && this.configuration.accessToken) {
+                            token = this.configuration.accessToken;
+                            tokenString = typeof token === 'function' ? token("bearerAuth", []) : token;
+                            if (tokenString) {
+                                headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                            }
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.request({
+                                path: "/products/types/{typeId}".replace("{".concat("typeId", "}"), encodeURIComponent(String(requestParameters.typeId))),
+                                method: 'GET',
+                                headers: headerParameters,
+                                query: queryParameters,
+                            })];
+                    case 2:
+                        response = _a.sent();
+                        contentType = response.headers.get("content-type");
+                        if (contentType && contentType.indexOf("application/json") !== -1) {
+                            return [2 /*return*/, new runtime_1.JSONApiResponse(response, function (jsonValue) { return (0, models_1.ProductTypeFromJSON)(jsonValue); })];
+                        }
+                        else if (contentType && contentType.indexOf("text/plain") !== -1) {
+                            return [2 /*return*/, new runtime_1.TextApiResponse(response)];
+                        }
+                        else {
+                            // TODO : Better handling of others application types
+                            return [2 /*return*/, new runtime_1.BlobWithMetaApiResponse(response)];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        response_3 = _a.sent();
+                        console.debug(response_3);
+                        throw response_3;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get product type
+     */
+    SearchProductMetadataApi.prototype.getProductType = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getProductTypeRaw(requestParameters)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Get product types
      */
     SearchProductMetadataApi.prototype.getProductTypesRaw = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, token, tokenString, response, contentType, response_2;
+            var queryParameters, headerParameters, token, tokenString, response, contentType, response_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -190,9 +336,9 @@ var SearchProductMetadataApi = /** @class */ (function (_super) {
                         }
                         return [3 /*break*/, 4];
                     case 3:
-                        response_2 = _a.sent();
-                        console.debug(response_2);
-                        throw response_2;
+                        response_4 = _a.sent();
+                        console.debug(response_4);
+                        throw response_4;
                     case 4: return [2 /*return*/];
                 }
             });

package/product/src/models/{ProductProvider.d.ts → DataProvider.d.ts}

@@ -14,10 +14,12 @@
  * @export
  * @enum {string}
  */
-export declare enum ProductProvider {
+export declare enum DataProvider {
     VIDAL = "VIDAL",
-    BCB = "BCB"
+    BCB = "BCB",
+    LCDPCATALOG = "LCDP_CATALOG",
+    USER = "USER"
 }
-export declare function ProductProviderFromJSON(json: any): ProductProvider;
-export declare function ProductProviderFromJSONTyped(json: any, ignoreDiscriminator: boolean): ProductProvider;
-export declare function ProductProviderToJSON(value?: ProductProvider | null): any;
+export declare function DataProviderFromJSON(json: any): DataProvider;
+export declare function DataProviderFromJSONTyped(json: any, ignoreDiscriminator: boolean): DataProvider;
+export declare function DataProviderToJSON(value?: DataProvider | null): any;

package/product/src/models/DataProvider.js

@@ -0,0 +1,40 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * lcdp-monolith-service
+ * This is the REST API of LCDP products
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: contact@lecomptoirdespharmacies.fr
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataProviderToJSON = exports.DataProviderFromJSONTyped = exports.DataProviderFromJSON = exports.DataProvider = void 0;
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+var DataProvider;
+(function (DataProvider) {
+    DataProvider["VIDAL"] = "VIDAL";
+    DataProvider["BCB"] = "BCB";
+    DataProvider["LCDPCATALOG"] = "LCDP_CATALOG";
+    DataProvider["USER"] = "USER";
+})(DataProvider = exports.DataProvider || (exports.DataProvider = {}));
+function DataProviderFromJSON(json) {
+    return DataProviderFromJSONTyped(json, false);
+}
+exports.DataProviderFromJSON = DataProviderFromJSON;
+function DataProviderFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+exports.DataProviderFromJSONTyped = DataProviderFromJSONTyped;
+function DataProviderToJSON(value) {
+    return value;
+}
+exports.DataProviderToJSON = DataProviderToJSON;

package/product/src/models/Image.d.ts

@@ -9,6 +9,7 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+import { DataProvider } from './DataProvider';
 import { ImageVersions } from './ImageVersions';
 /**
  *
@@ -34,6 +35,12 @@ export interface Image {
      * @memberof Image
      */
     versions?: ImageVersions;
+    /**
+     *
+     * @type {DataProvider}
+     * @memberof Image
+     */
+    source?: DataProvider;
 }
 export declare function ImageFromJSON(json: any): Image;
 export declare function ImageFromJSONTyped(json: any, ignoreDiscriminator: boolean): Image;

package/product/src/models/Image.js

@@ -15,6 +15,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImageToJSON = exports.ImageFromJSONTyped = exports.ImageFromJSON = void 0;
 var runtime_1 = require("../runtime");
+var DataProvider_1 = require("./DataProvider");
 var ImageVersions_1 = require("./ImageVersions");
 function ImageFromJSON(json) {
     return ImageFromJSONTyped(json, false);
@@ -28,6 +29,7 @@ function ImageFromJSONTyped(json, ignoreDiscriminator) {
         'id': !(0, runtime_1.exists)(json, 'id') ? undefined : json['id'],
         'active': !(0, runtime_1.exists)(json, 'active') ? undefined : json['active'],
         'versions': !(0, runtime_1.exists)(json, 'versions') ? undefined : (0, ImageVersions_1.ImageVersionsFromJSON)(json['versions']),
+        'source': !(0, runtime_1.exists)(json, 'source') ? undefined : (0, DataProvider_1.DataProviderFromJSON)(json['source']),
     };
 }
 exports.ImageFromJSONTyped = ImageFromJSONTyped;
@@ -42,6 +44,7 @@ function ImageToJSON(value) {
         'id': value.id,
         'active': value.active,
         'versions': (0, ImageVersions_1.ImageVersionsToJSON)(value.versions),
+        'source': (0, DataProvider_1.DataProviderToJSON)(value.source),
     };
 }
 exports.ImageToJSON = ImageToJSON;

package/product/src/models/Product.d.ts

@@ -13,9 +13,10 @@ import { Barcodes } from './Barcodes';
 import { HttpLink } from './HttpLink';
 import { LaboratoryLink } from './LaboratoryLink';
 import { ProductDispensationPlace } from './ProductDispensationPlace';
+import { ProductJournal } from './ProductJournal';
 import { ProductMarketStatus } from './ProductMarketStatus';
-import { ProductProvider } from './ProductProvider';
 import { ProductSecondaryType } from './ProductSecondaryType';
+import { ProductSource } from './ProductSource';
 import { ProductStatus } from './ProductStatus';
 import { ProductStorageType } from './ProductStorageType';
 import { ProductType } from './ProductType';
@@ -32,157 +33,163 @@ export interface Product {
      * @type {number}
      * @memberof Product
      */
-    id?: number;
-    /**
-     * Indicates if automatic external synchronization is enabled
-     * @type {boolean}
-     * @memberof Product
-     */
-    isExternalSyncEnabled?: boolean;
-    /**
-     *
-     * @type {Array<ProductProvider>}
-     * @memberof Product
-     */
-    providers?: Array<ProductProvider>;
+    id: number;
     /**
      *
      * @type {Barcodes}
      * @memberof Product
      */
-    barcodes?: Barcodes;
+    barcodes: Barcodes;
     /**
      *
      * @type {string}
      * @memberof Product
      */
-    name?: string;
+    name: string;
     /**
      *
      * @type {string}
      * @memberof Product
      */
-    shortName?: string | null;
+    shortName: string | null;
     /**
      *
      * @type {string}
      * @memberof Product
      */
-    dci?: string | null;
+    dci: string | null;
     /**
      * Weight of a single unit in grams
      * @type {number}
      * @memberof Product
      */
-    unitWeight?: number | null;
+    unitWeight: number | null;
     /**
      * Public price of the product
      * @type {number}
      * @memberof Product
      */
-    unitPrice?: number | null;
+    unitPrice: number | null;
+    /**
+     * Date on which the unit price take effect
+     * @type {Date}
+     * @memberof Product
+     */
+    unitPriceEffectiveDate: Date | null;
     /**
      *
      * @type {ProductType}
      * @memberof Product
      */
-    type?: ProductType | null;
+    type: ProductType | null;
     /**
      *
      * @type {ProductSecondaryType}
      * @memberof Product
      */
-    secondaryType?: ProductSecondaryType | null;
+    secondaryType: ProductSecondaryType | null;
     /**
      *
      * @type {LaboratoryLink}
      * @memberof Product
      */
-    laboratory?: LaboratoryLink | null;
+    laboratory: LaboratoryLink | null;
     /**
      *
      * @type {Vat}
      * @memberof Product
      */
-    vat?: Vat | null;
+    vat: Vat | null;
     /**
      *
      * @type {boolean}
      * @memberof Product
      */
-    narcoticPrescription?: boolean | null;
+    narcoticPrescription: boolean | null;
     /**
      *
      * @type {ProductStorageType}
      * @memberof Product
      */
-    storageType?: ProductStorageType | null;
+    storageType: ProductStorageType | null;
     /**
      *
      * @type {ProductStatus}
      * @memberof Product
      */
-    status?: ProductStatus | null;
+    status: ProductStatus | null;
     /**
      *
      * @type {ProductMarketStatus}
      * @memberof Product
      */
-    marketStatus?: ProductMarketStatus | null;
+    marketStatus: ProductMarketStatus | null;
     /**
      *
      * @type {ProductDispensationPlace}
      * @memberof Product
      */
-    dispensationPlace?: ProductDispensationPlace | null;
+    dispensationPlace: ProductDispensationPlace | null;
     /**
      *
      * @type {boolean}
      * @memberof Product
      */
-    isOtc?: boolean;
+    isOtc: boolean | null;
     /**
      *
      * @type {boolean}
      * @memberof Product
      */
-    isDrugInSport?: boolean | null;
+    isDrugInSport: boolean | null;
     /**
      *
      * @type {HttpLink}
      * @memberof Product
      */
-    images?: HttpLink;
+    images: HttpLink;
     /**
      * Creation date of this product
      * @type {Date}
      * @memberof Product
      */
-    createdAt?: Date;
+    createdAt: Date;
     /**
      *
      * @type {Statistics}
      * @memberof Product
      */
-    statistics?: Statistics;
+    statistics: Statistics;
     /**
      * If True, can only be sold by LABORATORY. If False, it can be sold by anyone.
      * @type {boolean}
      * @memberof Product
      */
-    restricted?: boolean;
+    restricted: boolean;
     /**
      *
      * @type {HttpLink}
      * @memberof Product
      */
-    proscriptions?: HttpLink;
+    proscriptions: HttpLink;
     /**
      * Associated tags for this product
      * @type {Array<string>}
      * @memberof Product
      */
-    tags?: Array<string>;
+    tags: Array<string>;
+    /**
+     *
+     * @type {ProductSource}
+     * @memberof Product
+     */
+    source: ProductSource;
+    /**
+     *
+     * @type {ProductJournal}
+     * @memberof Product
+     */
+    journal: ProductJournal;
 }
 export declare function ProductFromJSON(json: any): Product;
 export declare function ProductFromJSONTyped(json: any, ignoreDiscriminator: boolean): Product;