@revenexx/node 0.0.1 → 0.1.0

package/dist/services/products-categories.js

@@ -0,0 +1,638 @@
+'use strict';
+
+var client = require('../client');
+
+class ProductsCategories {
+  constructor(client) {
+    this.client = client;
+  }
+  productsCategoriesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1],
+        id: rest[2],
+        code: rest[3],
+        parentId: rest[4],
+        xpath: rest[5],
+        position: rest[6],
+        labels: rest[7],
+        values: rest[8],
+        rules: rest[9],
+        ruleMatch: rest[10],
+        rulesComputedAt: rest[11],
+        createdAt: rest[12],
+        updatedAt: rest[13]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const code = params.code;
+    const parentId = params.parentId;
+    const xpath = params.xpath;
+    const position = params.position;
+    const labels = params.labels;
+    const values = params.values;
+    const rules = params.rules;
+    const ruleMatch = params.ruleMatch;
+    const rulesComputedAt = params.rulesComputedAt;
+    const createdAt = params.createdAt;
+    const updatedAt = params.updatedAt;
+    const apiPath = "/v1/products/categories";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof parentId !== "undefined") {
+      apiPayload["parent_id"] = parentId;
+    }
+    if (typeof xpath !== "undefined") {
+      apiPayload["path"] = xpath;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof values !== "undefined") {
+      apiPayload["values"] = values;
+    }
+    if (typeof rules !== "undefined") {
+      apiPayload["rules"] = rules;
+    }
+    if (typeof ruleMatch !== "undefined") {
+      apiPayload["rule_match"] = ruleMatch;
+    }
+    if (typeof rulesComputedAt !== "undefined") {
+      apiPayload["rules_computed_at"] = rulesComputedAt;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    if (typeof updatedAt !== "undefined") {
+      apiPayload["updated_at"] = updatedAt;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        code: paramsOrFirst,
+        labels: rest[0],
+        parentId: rest[1],
+        xpath: rest[2],
+        position: rest[3],
+        ruleMatch: rest[4],
+        rules: rest[5],
+        rulesComputedAt: rest[6],
+        values: rest[7]
+      };
+    }
+    const code = params.code;
+    const labels = params.labels;
+    const parentId = params.parentId;
+    const xpath = params.xpath;
+    const position = params.position;
+    const ruleMatch = params.ruleMatch;
+    const rules = params.rules;
+    const rulesComputedAt = params.rulesComputedAt;
+    const values = params.values;
+    if (typeof code === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "code"');
+    }
+    const apiPath = "/v1/products/categories";
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof parentId !== "undefined") {
+      apiPayload["parent_id"] = parentId;
+    }
+    if (typeof xpath !== "undefined") {
+      apiPayload["path"] = xpath;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof ruleMatch !== "undefined") {
+      apiPayload["rule_match"] = ruleMatch;
+    }
+    if (typeof rules !== "undefined") {
+      apiPayload["rules"] = rules;
+    }
+    if (typeof rulesComputedAt !== "undefined") {
+      apiPayload["rules_computed_at"] = rulesComputedAt;
+    }
+    if (typeof values !== "undefined") {
+      apiPayload["values"] = values;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesRulesRecomputeAll(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst) && "data" in paramsOrFirst) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        data: paramsOrFirst
+      };
+    }
+    const data = params.data;
+    if (typeof data === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "data"');
+    }
+    const apiPath = "/v1/products/categories/rules/recompute-all";
+    const apiPayload = {};
+    if (typeof data !== "undefined") {
+      Object.assign(apiPayload, data);
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesRulesPreview(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        categoryId: paramsOrFirst,
+        conditions: rest[0],
+        ruleMatch: rest[1]
+      };
+    }
+    const categoryId = params.categoryId;
+    const conditions = params.conditions;
+    const ruleMatch = params.ruleMatch;
+    if (typeof categoryId === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "categoryId"');
+    }
+    if (typeof conditions === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "conditions"');
+    }
+    const apiPath = "/v1/products/categories/{category_id}/rules/preview".replace("{category_id}", categoryId);
+    const apiPayload = {};
+    if (typeof conditions !== "undefined") {
+      apiPayload["conditions"] = conditions;
+    }
+    if (typeof ruleMatch !== "undefined") {
+      apiPayload["rule_match"] = ruleMatch;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesRulesRecompute(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        categoryId: paramsOrFirst,
+        cursor: rest[0]
+      };
+    }
+    const categoryId = params.categoryId;
+    const cursor = params.cursor;
+    if (typeof categoryId === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "categoryId"');
+    }
+    const apiPath = "/v1/products/categories/{category_id}/rules/recompute".replace("{category_id}", categoryId);
+    const apiPayload = {};
+    if (typeof cursor !== "undefined") {
+      apiPayload["cursor"] = cursor;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        code: rest[0],
+        labels: rest[1],
+        parentId: rest[2],
+        xpath: rest[3],
+        position: rest[4],
+        ruleMatch: rest[5],
+        rules: rest[6],
+        rulesComputedAt: rest[7],
+        values: rest[8]
+      };
+    }
+    const id = params.id;
+    const code = params.code;
+    const labels = params.labels;
+    const parentId = params.parentId;
+    const xpath = params.xpath;
+    const position = params.position;
+    const ruleMatch = params.ruleMatch;
+    const rules = params.rules;
+    const rulesComputedAt = params.rulesComputedAt;
+    const values = params.values;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof code !== "undefined") {
+      apiPayload["code"] = code;
+    }
+    if (typeof labels !== "undefined") {
+      apiPayload["labels"] = labels;
+    }
+    if (typeof parentId !== "undefined") {
+      apiPayload["parent_id"] = parentId;
+    }
+    if (typeof xpath !== "undefined") {
+      apiPayload["path"] = xpath;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof ruleMatch !== "undefined") {
+      apiPayload["rule_match"] = ruleMatch;
+    }
+    if (typeof rules !== "undefined") {
+      apiPayload["rules"] = rules;
+    }
+    if (typeof rulesComputedAt !== "undefined") {
+      apiPayload["rules_computed_at"] = rulesComputedAt;
+    }
+    if (typeof values !== "undefined") {
+      apiPayload["values"] = values;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesList(paramsOrFirst, ...rest) {
+    let params;
+    if (!paramsOrFirst || paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        limit: paramsOrFirst,
+        offset: rest[0],
+        order: rest[1],
+        id: rest[2],
+        productId: rest[3],
+        categoryId: rest[4],
+        position: rest[5],
+        source: rest[6],
+        createdAt: rest[7]
+      };
+    }
+    const limit = params.limit;
+    const offset = params.offset;
+    const order = params.order;
+    const id = params.id;
+    const productId = params.productId;
+    const categoryId = params.categoryId;
+    const position = params.position;
+    const source = params.source;
+    const createdAt = params.createdAt;
+    const apiPath = "/v1/products/product_categories";
+    const apiPayload = {};
+    if (typeof limit !== "undefined") {
+      apiPayload["limit"] = limit;
+    }
+    if (typeof offset !== "undefined") {
+      apiPayload["offset"] = offset;
+    }
+    if (typeof order !== "undefined") {
+      apiPayload["order"] = order;
+    }
+    if (typeof id !== "undefined") {
+      apiPayload["id"] = id;
+    }
+    if (typeof productId !== "undefined") {
+      apiPayload["product_id"] = productId;
+    }
+    if (typeof categoryId !== "undefined") {
+      apiPayload["category_id"] = categoryId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof source !== "undefined") {
+      apiPayload["source"] = source;
+    }
+    if (typeof createdAt !== "undefined") {
+      apiPayload["created_at"] = createdAt;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesCreate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        categoryId: paramsOrFirst,
+        productId: rest[0],
+        position: rest[1],
+        source: rest[2]
+      };
+    }
+    const categoryId = params.categoryId;
+    const productId = params.productId;
+    const position = params.position;
+    const source = params.source;
+    if (typeof categoryId === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "categoryId"');
+    }
+    if (typeof productId === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "productId"');
+    }
+    const apiPath = "/v1/products/product_categories";
+    const apiPayload = {};
+    if (typeof categoryId !== "undefined") {
+      apiPayload["category_id"] = categoryId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof productId !== "undefined") {
+      apiPayload["product_id"] = productId;
+    }
+    if (typeof source !== "undefined") {
+      apiPayload["source"] = source;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesDelete(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "delete",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesGet(paramsOrFirst) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst
+      };
+    }
+    const id = params.id;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {};
+    return this.client.call(
+      "get",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsProductCategoriesUpdate(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        categoryId: rest[0],
+        position: rest[1],
+        productId: rest[2],
+        source: rest[3]
+      };
+    }
+    const id = params.id;
+    const categoryId = params.categoryId;
+    const position = params.position;
+    const productId = params.productId;
+    const source = params.source;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "id"');
+    }
+    const apiPath = "/v1/products/product_categories/{id}".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof categoryId !== "undefined") {
+      apiPayload["category_id"] = categoryId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    if (typeof productId !== "undefined") {
+      apiPayload["product_id"] = productId;
+    }
+    if (typeof source !== "undefined") {
+      apiPayload["source"] = source;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "put",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+  productsCategoriesAssign(paramsOrFirst, ...rest) {
+    let params;
+    if (paramsOrFirst && typeof paramsOrFirst === "object" && !Array.isArray(paramsOrFirst)) {
+      params = paramsOrFirst || {};
+    } else {
+      params = {
+        id: paramsOrFirst,
+        categoryId: rest[0],
+        position: rest[1]
+      };
+    }
+    const id = params.id;
+    const categoryId = params.categoryId;
+    const position = params.position;
+    if (typeof id === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "id"');
+    }
+    if (typeof categoryId === "undefined") {
+      throw new client.RevenexxException('Missing required parameter: "categoryId"');
+    }
+    const apiPath = "/v1/products/{id}/categories".replace("{id}", id);
+    const apiPayload = {};
+    if (typeof categoryId !== "undefined") {
+      apiPayload["category_id"] = categoryId;
+    }
+    if (typeof position !== "undefined") {
+      apiPayload["position"] = position;
+    }
+    const uri = new URL(this.client.config.endpoint + apiPath);
+    const apiHeaders = {
+      "content-type": "application/json"
+    };
+    return this.client.call(
+      "post",
+      uri,
+      apiHeaders,
+      apiPayload
+    );
+  }
+}
+
+exports.ProductsCategories = ProductsCategories;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=products-categories.js.map