@globisnv/cypress-core 0.0.1

package/dist/apiMethods/IGS_response.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Represents an object containing key-value pairs with string values.
+ * @typedef {Object.<string, string>} responseUUIDObject
+ */
+type responseUUIDObject = {
+    [key: string]: string;
+};
+/**
+ * Represents the default structure of a response object.
+ * @typedef {Object} responseDefault
+ * @property {number} status - The status code of the response.
+ */
+export type responseDefault = {
+    status: number;
+};
+/**
+ * Represents the structure of a response object for create operations.
+ * @typedef {responseDefault} responseCreate
+ * @property {Object} body - The body of the response.
+ * @property {Array<responseUUIDObject>} body.create - An array of objects containing created UUIDs.
+ */
+export type responseCreate = responseDefault & {
+    body: {
+        create: Array<responseUUIDObject>;
+    };
+};
+/**
+ * Represents the structure of a response object for patch operations.
+ * @typedef {responseDefault} responsePatch
+ * @property {Object} body - The body of the response.
+ * @property {Array<responseUUIDObject>} body.patch - An array of objects containing patched UUIDs.
+ */
+export type responsePatch = responseDefault & {
+    body: {
+        patch: Array<responseUUIDObject>;
+    };
+};
+/**
+ * Represents the structure of a response object for read operations.
+ * @typedef {responseDefault} responseRead
+ * @template T - Type of the body of the response.
+ * @property {T} body - The body of the response.
+ */
+export type responseRead<T> = responseDefault & {
+    body: T;
+};
+export {};

package/dist/apiMethods/IGS_response.js

@@ -0,0 +1 @@
+export {};

package/dist/blueprints/GLO_addressPopup.d.ts

@@ -0,0 +1,45 @@
+import { type CheckState } from '../tsHelper.js';
+export type ObjAddressPopupBase = {
+    type?: 'search' | 'create';
+    addressCode?: string;
+    name?: string;
+    country?: string;
+    state?: string;
+    county?: string;
+    PC?: string;
+    city?: string;
+    streetName?: string;
+    number?: string | number;
+    latitude?: string;
+    longitude?: string;
+    flagUseSelectedAddress?: CheckState;
+    rowToSelect?: string | number;
+    flag_postaddress?: CheckState;
+    flag_deliveryaddress?: CheckState;
+    flag_invoiceaddress?: CheckState;
+    flag_legaladdress?: CheckState;
+    flag_visitaddress?: CheckState;
+    flag_manual_coordinates?: CheckState;
+    btn_validate_address?: boolean;
+    close_popup?: boolean;
+    btn_use_entered_address?: boolean;
+    btn_use_selected_address?: boolean;
+    btn_save_address?: boolean;
+    autoSelect?: boolean;
+    btn_accept_double_address?: boolean;
+};
+type OnlyOneTrue<T, K extends keyof T = keyof T> = (K extends keyof T ? {
+    [P in K]-?: true;
+} & {
+    [P in Exclude<keyof T, K>]?: false | undefined;
+} : never) | {
+    [P in keyof T]?: false | undefined;
+};
+type MutuallyExclusiveButtons = OnlyOneTrue<{
+    btn_save_address?: boolean;
+    btn_use_entered_address?: boolean;
+    btn_use_selected_address?: boolean;
+}>;
+export type objAddressPopup = ObjAddressPopupBase & MutuallyExclusiveButtons;
+export declare const GLO_enterAddressPopup: (obj: objAddressPopup) => void;
+export {};

package/dist/blueprints/GLO_addressPopup.js

@@ -0,0 +1,96 @@
+import { equalBool, row, skipCheck, span } from '../tsHelper.js';
+const addresFormName = 'ng$address_search_creation_sel';
+export const GLO_enterAddressPopup = (obj) => {
+    // Set the default value to true
+    obj = { autoSelect: true, ...obj };
+    if (obj.type === 'search') {
+        searchAddress(obj);
+    }
+    else if (obj.type === 'create') {
+        createAddress(obj);
+    }
+    else {
+        throw new Error('Invalid type for address popup. Use "search" or "create".');
+    }
+};
+const fillInBasicAddressFields = (obj) => {
+    cy.GLO_addInput([addresFormName, 'address_name'], obj.name);
+    if (obj.country) {
+        cy.GLO_getElement(['ng$address_search_creation_sel', 'country']).then(($country) => {
+            if ($country.find('.fa-search').length > 0) {
+                cy.GLO_popupWindow([addresFormName, 'country'], obj.country);
+            }
+            else {
+                cy.GLO_addInput([addresFormName, 'country'], obj.country);
+            }
+        });
+    }
+    if (obj.state)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([addresFormName, 'local_state_id'], obj.state);
+    if (obj.county)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_popupWindow([addresFormName, 'local_county_id'], obj.county, 'branch_code', equalBool);
+    cy.GLO_addInput([addresFormName, 'postal_code'], obj.PC);
+    if (obj.PC)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([addresFormName, 'city'], obj.city);
+    if (obj.city)
+        cy.GLO_checkLoadingIndicator();
+    if (obj.type === 'search') {
+        cy.GLO_popupWindow([addresFormName, 'btn_select_street'], obj.streetName, 'streetname');
+    }
+    else if (obj.type === 'create' && obj.streetName) {
+        // If the type is create, we should use the streetName directly
+        cy.get('body').then(($body) => {
+            if ($body.find(`[data-cy$="${addresFormName}.streetname_validation"]`).length > 0) {
+                cy.GLO_getElement([addresFormName, 'streetname_validation']).find('.dx-texteditor-input').filter(':enabled').clear().type(obj.streetName);
+            }
+            else {
+                cy.GLO_addInput([addresFormName, 'streetname'], obj.streetName);
+            }
+        });
+    }
+    cy.GLO_addInput([addresFormName, 'house_number'], obj.number);
+};
+// Seperate functions for cognitive complexity sonar warning
+const searchAddress = (obj) => {
+    cy.GLO_addInput([addresFormName, 'address_code'], obj.addressCode);
+    fillInBasicAddressFields(obj);
+    cy.GLO_clickButton([addresFormName, 'button_search']);
+    if (obj.addressCode && obj.autoSelect) {
+        // If you have the address code then you can select it based on the span else you need to take the first one for now
+        cy.GLO_dblClickRowInGrid(span, [addresFormName, 'grid'], obj.addressCode, undefined, skipCheck);
+    }
+    else if (obj.autoSelect) {
+        cy.GLO_dblClickRowInGrid(typeof obj.rowToSelect === 'string' ? span : row, [addresFormName, 'grid'], obj.rowToSelect ?? 0, undefined, skipCheck, equalBool);
+    }
+};
+const createAddress = (obj) => {
+    const formNameCreateGrid = 'ng$relations_dtl_add_address_dlg_lower';
+    cy.GLO_getElement([addresFormName, 'mode_create_or_select']).find('.dx-radiobutton-icon').last().click();
+    cy.GLO_checkLoadingIndicator();
+    fillInBasicAddressFields(obj);
+    cy.GLO_checkbox([addresFormName, 'flag_postaddress'], obj.flag_postaddress);
+    cy.GLO_checkbox([addresFormName, 'flag_deliveryaddress'], obj.flag_deliveryaddress);
+    cy.GLO_checkbox([addresFormName, 'flag_invoiceaddress'], obj.flag_invoiceaddress);
+    cy.GLO_checkbox([addresFormName, 'flag_legaladdress'], obj.flag_legaladdress);
+    cy.GLO_checkbox([addresFormName, 'flag_visitaddress'], obj.flag_visitaddress);
+    if (obj.btn_validate_address) {
+        cy.GLO_clickButton([addresFormName, 'btn_validate_address']);
+    }
+    cy.GLO_checkbox([addresFormName, 'flag_manual_coordinates'], obj.flag_manual_coordinates);
+    cy.GLO_addInput([addresFormName, 'local_geo_latitude'], obj.latitude);
+    cy.GLO_addInput([addresFormName, 'local_geo_longitude'], obj.longitude);
+    if (obj.btn_save_address !== true)
+        cy.GLO_dblClickRowInGrid(typeof obj.rowToSelect === 'string' ? span : row, [formNameCreateGrid, 'grid'], obj.rowToSelect ?? 0, undefined, skipCheck, equalBool);
+    const buttonToClick = ['btn_use_entered_address', 'btn_use_selected_address', 'btn_save_address'].find((key) => obj[key]);
+    if (buttonToClick) {
+        cy.get(`[data-cy="${addresFormName}.${buttonToClick}"]`, { timeout: 10000 }).filter(':visible').should('exist');
+        cy.GLO_clickButton([addresFormName, buttonToClick]);
+        if (obj.btn_accept_double_address) {
+            cy.GLO_dialogChoice('Accept');
+        }
+        cy.get('.svy-dialog', { timeout: 20000 }).should('not.exist');
+    }
+};

package/dist/blueprints/GLO_article.d.ts

@@ -0,0 +1,45 @@
+import { type CheckState } from '../tsHelper.js';
+export type objArticle = {
+    articleCode?: string;
+    articleMainGroup?: string;
+    articleSubGroup?: string;
+    articleType?: string;
+    articleDefaultSupplier?: string;
+    attention?: string;
+    articleStatus?: string;
+    extraSearchCode?: string;
+    articleUnit?: string;
+    articleSalesPriceUnit?: string;
+    articlePurchasePriceUnit?: string;
+    articleSalesPriceQuantity?: number;
+    articlePurchasePriceQuantity?: number;
+    articleGrossWeight?: string | number;
+    articleNetWeight?: string | number;
+    articlePackagingType?: string;
+    articlePackagingPerAmount?: number;
+    articlePackagingGrossWeight?: string | number;
+    articlePackagesPerLayer?: number;
+    articleLayersPerPallet?: number;
+    articleUnitsPerPallet?: number;
+    articlePalletType?: string;
+    articleVATCode?: string;
+    pricePerUnit?: string;
+    layerHeight?: string | number;
+    purchaseProduction?: string;
+    productionRouting?: string;
+    translationStandard0?: string;
+    translationStandard1?: string;
+    translationStandard2?: string;
+    articleUnitLength?: string | number;
+    articleUnitWidth?: string;
+    articleUnitHeight?: string;
+    weightContents?: number;
+    weightContentsUnit?: string;
+    financialCostaccount?: string;
+    financialTurnoveraccount?: string;
+    financialStockaccount?: string;
+    financialFlagIncludeCostImportDutyCalc?: CheckState;
+    useLotType?: string;
+    minimumStock?: number;
+};
+export declare const GLO_enterArticle: (obj: objArticle) => void;

package/dist/blueprints/GLO_article.js

@@ -0,0 +1,110 @@
+import { close, open } from '../tsHelper.js';
+const articleUnitsForm = 'ng$article_dtl_units';
+const articleFinancialForm = 'ng$article_dtl_financial';
+const articleWarehouseForm = 'ng$article_dtl_warehousemgt';
+const articleProductionForm = 'ng$article_dtl_production';
+const articleMainForm = 'ng$article_dtl';
+export const GLO_enterArticle = (obj) => {
+    cy.GLO_addInput([articleMainForm, 'article_code'], obj.articleCode);
+    cy.GLO_addInput([articleMainForm, 'articlemaingroup_id'], obj.articleMainGroup);
+    if (obj.articleMainGroup && obj.articleSubGroup)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([articleMainForm, 'articlesubgroup_id'], obj.articleSubGroup);
+    if (obj.articleMainGroup || obj.articleSubGroup)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([articleMainForm, 'extra_search_code'], obj.extraSearchCode);
+    cy.GLO_addInput([articleMainForm, 'articlestatus_id'], obj.articleStatus);
+    cy.GLO_addInput([articleMainForm, 'articletype_id'], obj.articleType);
+    cy.GLO_popupWindow([articleMainForm, 'supplier'], obj.articleDefaultSupplier);
+    cy.GLO_addInput([articleMainForm, 'attentionline'], obj.attention);
+    if (obj.articleUnit ||
+        obj.articleSalesPriceUnit ||
+        obj.articlePurchasePriceUnit ||
+        obj.articleSalesPriceQuantity ||
+        obj.articlePurchasePriceQuantity ||
+        obj.articleGrossWeight ||
+        obj.articleNetWeight ||
+        obj.articlePackagingType ||
+        obj.articlePackagingPerAmount ||
+        obj.articlePackagingGrossWeight ||
+        obj.articlePackagesPerLayer ||
+        obj.articleLayersPerPallet ||
+        obj.articleUnitsPerPallet ||
+        obj.articlePalletType ||
+        obj.weightContents ||
+        obj.weightContentsUnit ||
+        obj.layerHeight) {
+        GLO_enterArticleUnits(obj);
+    }
+    if (obj.articleVATCode || obj.financialCostaccount || obj.financialTurnoveraccount || obj.financialStockaccount || obj.financialFlagIncludeCostImportDutyCalc) {
+        GLO_enterArticleFinancial(obj);
+    }
+    if (obj.purchaseProduction || obj.useLotType || obj.minimumStock)
+        GLO_enterWarehouseManagement(obj);
+    if (obj.productionRouting)
+        GLO_enterProduction(obj);
+    if (obj.translationStandard0 || obj.translationStandard1 || obj.translationStandard2) {
+        GLO_enterTranslations(obj);
+    }
+};
+const GLO_enterArticleUnits = (obj) => {
+    // Tab 'Units'
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Units', open);
+    cy.GLO_addInput([articleUnitsForm, 'content_articleunit_id'], obj.articleUnit);
+    cy.GLO_addInput([articleUnitsForm, 'weight'], obj.weightContents);
+    cy.GLO_addInput([articleUnitsForm, 'weight_articleunit_id'], obj.weightContentsUnit);
+    cy.GLO_addInput([articleUnitsForm, 'length_in_unit'], obj.articleUnitLength);
+    cy.GLO_addInput([articleUnitsForm, 'width_in_unit'], obj.articleUnitWidth);
+    cy.GLO_addInput([articleUnitsForm, 'height_in_unit'], obj.articleUnitHeight);
+    cy.GLO_addInput([articleUnitsForm, 'price_per_unit_id'], obj.articleSalesPriceUnit);
+    cy.GLO_addInput([articleUnitsForm, 'purchase_price_per_unit_id'], obj.articlePurchasePriceUnit);
+    cy.GLO_addInput([articleUnitsForm, 'price_per'], obj.articleSalesPriceQuantity);
+    if (obj.articleSalesPriceQuantity && obj.articlePurchasePriceQuantity)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([articleUnitsForm, 'purchase_price_per'], obj.articlePurchasePriceQuantity);
+    cy.GLO_addInput([articleUnitsForm, 'gross_weight_in_kg'], obj.articleGrossWeight);
+    cy.GLO_addInput([articleUnitsForm, 'net_weight_in_kg'], obj.articleNetWeight);
+    cy.GLO_addInput([articleUnitsForm, 'colli_articleunit_id'], obj.articlePackagingType);
+    cy.GLO_addInput([articleUnitsForm, 'number_of_content'], obj.articlePackagingPerAmount);
+    cy.GLO_addInput([articleUnitsForm, 'colli_weight_in_kg'], obj.articlePackagingGrossWeight);
+    cy.GLO_addInput([articleUnitsForm, 'packages_per_pallet_layer'], obj.articlePackagesPerLayer);
+    cy.GLO_addInput([articleUnitsForm, 'layer_height'], obj.layerHeight);
+    cy.GLO_addInput([articleUnitsForm, 'layers_per_pallet'], obj.articleLayersPerPallet);
+    if (obj.articleLayersPerPallet && obj.articleUnitsPerPallet)
+        cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([articleUnitsForm, 'units_per_pallet'], obj.articleUnitsPerPallet);
+    cy.GLO_addInput([articleUnitsForm, 'container_subtype_id'], obj.articlePalletType);
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Units', close);
+};
+const GLO_enterArticleFinancial = (obj) => {
+    // Tab 'Financial'
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Financial', open);
+    cy.GLO_addInput([articleFinancialForm, 'vat_id'], obj.articleVATCode);
+    cy.GLO_addInput([articleFinancialForm, 'gl_account_id_costs'], obj.financialCostaccount);
+    cy.GLO_addInput([articleFinancialForm, 'gl_account_id_turnover'], obj.financialTurnoveraccount);
+    cy.GLO_addInput([articleFinancialForm, 'goods_costs_gl_account_id'], obj.financialStockaccount);
+    cy.GLO_checkbox([articleFinancialForm, 'Check_Box'], obj.financialFlagIncludeCostImportDutyCalc);
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Financial', close);
+};
+const GLO_enterWarehouseManagement = (obj) => {
+    // Tab 'Warehouse management'
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Warehouse management', open);
+    cy.GLO_addInput([articleWarehouseForm, 'purchase_production'], obj.purchaseProduction);
+    cy.GLO_addInput([articleWarehouseForm, 'use_lot_type'], obj.useLotType);
+    cy.GLO_addInput([articleWarehouseForm, 'minimum_stock'], obj.minimumStock);
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Warehouse management', close);
+};
+const GLO_enterProduction = (obj) => {
+    // Tab 'Financial'
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Production', open);
+    cy.GLO_addInput([articleProductionForm, 'production_routing'], obj.productionRouting);
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Production', close);
+};
+const GLO_enterTranslations = (obj) => {
+    // Tab 'Translations'
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Translations', open);
+    cy.GLO_fillInfieldInGrid(['ng$articletranslations_lst_tab', 'grid'], 0, 'descr', obj.translationStandard0);
+    cy.GLO_fillInfieldInGrid(['ng$articletranslations_lst_tab', 'grid'], 1, 'descr', obj.translationStandard1);
+    cy.GLO_fillInfieldInGrid(['ng$articletranslations_lst_tab', 'grid'], 2, 'descr', obj.translationStandard2);
+    cy.GLO_selectTab([articleMainForm, 'tabs_70'], 'Translations', close);
+};

package/dist/blueprints/GLO_articleLot.d.ts

@@ -0,0 +1,12 @@
+export type objArticleLot = {
+    articleCode?: number | string;
+    articleVersionCode?: string;
+    purchasedQuantity?: number;
+    purchasedPriceInEUR?: number;
+    localWarehouseId?: string;
+    localWarehouseLocationId?: string;
+    customsStatus?: string;
+    dialogRecalculatePriceIn?: 'Yes' | 'No';
+    principalCode?: string;
+};
+export declare const GLO_enterArticleLot: (obj: objArticleLot) => void;

package/dist/blueprints/GLO_articleLot.js

@@ -0,0 +1,23 @@
+import { close, open } from '../tsHelper.js';
+export const GLO_enterArticleLot = (obj) => {
+    const formName = 'ng$lot_dtl';
+    const detailTabsName = 'tabs_70';
+    cy.GLO_popupWindow(['ng$lot_dtl', 'article_code'], obj.articleCode);
+    cy.GLO_checkField(['ng$lot_dtl', 'article_code'], obj.articleCode);
+    cy.GLO_addInput([formName, 'local_articleversion_id'], obj.articleVersionCode);
+    cy.GLO_addInput([formName, 'customs_status_id'], obj.customsStatus);
+    cy.GLO_addInput([formName, 'principal_parameters_id'], obj.principalCode);
+    if (obj.purchasedQuantity || obj.purchasedPriceInEUR || obj.localWarehouseId || obj.localWarehouseLocationId) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Purchase/production', open);
+        cy.GLO_addInput(['ng$lot_dtl_purchase_production', 'purchased_quantity'], obj.purchasedQuantity);
+        if (obj.dialogRecalculatePriceIn) {
+            if (!obj.purchasedQuantity)
+                throw new Error('dialogRecalculatePriceIn requires purchasedQuantity to be set');
+            cy.GLO_dialogRequiredCheck(obj.dialogRecalculatePriceIn);
+        }
+        cy.GLO_addInput(['ng$lot_dtl_purchase_production', 'purchased_price_in_euro'], obj.purchasedPriceInEUR);
+        cy.GLO_addInput(['ng$lot_dtl_purchase_production', 'local_warehouse_id'], obj.localWarehouseId);
+        cy.GLO_addInput(['ng$lot_dtl_purchase_production', 'local_warehouse_location_id'], obj.localWarehouseLocationId);
+        cy.GLO_selectTab([formName, detailTabsName], 'Purchase/production', close);
+    }
+};

package/dist/blueprints/GLO_articleVersion.d.ts

@@ -0,0 +1,4 @@
+export type objArticleVersion = {
+    articleVersion?: string;
+};
+export declare const GLO_enterArticleVersion: (obj: objArticleVersion) => void;

package/dist/blueprints/GLO_articleVersion.js

@@ -0,0 +1,4 @@
+const articleVersionMainForm = 'ng$articleversion_dtl';
+export const GLO_enterArticleVersion = (obj) => {
+    cy.GLO_addInput([articleVersionMainForm, 'alternate_article_code'], obj.articleVersion);
+};

package/dist/blueprints/GLO_attachmentPopup.d.ts

@@ -0,0 +1,9 @@
+export type objAttachmentPopup = {
+    documentGroupCode?: string;
+    documentTypeId?: string;
+    documentDate?: string;
+    documentReminderDatetime?: string;
+    documentExpirationDate?: string;
+    documentClosingDatetime?: string;
+};
+export declare const GLO_enterAttachmentPopup: (obj: objAttachmentPopup) => void;

package/dist/blueprints/GLO_attachmentPopup.js

@@ -0,0 +1,10 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterAttachmentPopup = (obj) => {
+    const propertiesFormName = 'ng$svy_nav_document_add_document';
+    cy.GLO_addInput([propertiesFormName, 'document_group_code_1'], obj.documentGroupCode);
+    cy.GLO_addInput([propertiesFormName, 'document_type_id'], obj.documentTypeId);
+    cy.GLO_addDate(input, [propertiesFormName, 'document_date'], obj.documentDate);
+    cy.GLO_addDate(input, [propertiesFormName, 'document_reminder_datetime'], obj.documentReminderDatetime);
+    cy.GLO_addDate(input, [propertiesFormName, 'expiration_date'], obj.documentExpirationDate);
+    cy.GLO_addDate(input, [propertiesFormName, 'document_closing_datetime'], obj.documentClosingDatetime);
+};

package/dist/blueprints/GLO_bankAccount.d.ts

@@ -0,0 +1,7 @@
+export type objBankAccount = {
+    bankName?: string;
+    bankAccountNr?: string;
+    countryCode?: string;
+    currencyCode?: string;
+};
+export declare const GLO_enterBankAccount: (obj: objBankAccount) => void;

package/dist/blueprints/GLO_bankAccount.js

@@ -0,0 +1,7 @@
+export const GLO_enterBankAccount = (obj) => {
+    const formName = 'ng$bank_account_dtl';
+    cy.GLO_addInput([formName, 'bank_name'], obj.bankName);
+    cy.GLO_addInput([formName, 'bank_account_nr'], obj.bankAccountNr);
+    cy.GLO_addInput([formName, 'bank_country_1'], obj.countryCode);
+    cy.GLO_addInput([formName, 'currency_id'], obj.currencyCode);
+};

package/dist/blueprints/GLO_billingProcess.d.ts

@@ -0,0 +1,4 @@
+export type objBillingProcess = {
+    priceBilling?: string;
+};
+export declare const GLO_enterBillingProcess: (obj: objBillingProcess) => void;

package/dist/blueprints/GLO_billingProcess.js

@@ -0,0 +1,4 @@
+export const GLO_enterBillingProcess = (obj) => {
+    const formName = 'ng$billing_process_tx_dtl';
+    cy.GLO_addInput([formName, 'price'], obj.priceBilling);
+};

package/dist/blueprints/GLO_billingProposal.d.ts

@@ -0,0 +1,9 @@
+export type objBillingProposalTransport = {
+    externalTotalAmountExclVat?: number;
+    externalTotalAmountVat?: number;
+    externalTotalAmountInclVat?: number;
+    relationReference?: string;
+    externalReference?: string;
+    externalInvoiceDate?: string;
+};
+export declare const GLO_enterBillingProposalTransport: (obj: objBillingProposalTransport) => void;

package/dist/blueprints/GLO_billingProposal.js

@@ -0,0 +1,9 @@
+export const GLO_enterBillingProposalTransport = (obj) => {
+    const formName = 'ng$billing_proposal$transport_dtl';
+    cy.GLO_addInput([formName, 'external_total_amount_excl_vat'], obj.externalTotalAmountExclVat);
+    cy.GLO_addInput([formName, 'external_total_amount_vat'], obj.externalTotalAmountVat);
+    cy.GLO_addInput([formName, 'external_total_amount_incl_vat'], obj.externalTotalAmountInclVat);
+    cy.GLO_addInput([formName, 'relation_reference'], obj.relationReference);
+    cy.GLO_addInput([formName, 'external_reference'], obj.externalReference);
+    cy.GLO_addInput([formName, 'external_invoice_date'], obj.externalInvoiceDate);
+};

package/dist/blueprints/GLO_cancel.d.ts

@@ -0,0 +1,7 @@
+import { type CheckState } from '../tsHelper.js';
+export type objCancel = {
+    remark?: string;
+    flagCancelledByCustomer?: CheckState;
+    cancelledDate?: string;
+};
+export declare const GLO_enterCancel: (obj: objCancel) => void;

package/dist/blueprints/GLO_cancel.js

@@ -0,0 +1,7 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterCancel = (obj) => {
+    const formName = 'ng$blocking_and_reason_code_dlg$cancel';
+    cy.GLO_addInput([formName, 'remark'], obj.remark);
+    cy.GLO_checkbox([formName, 'flag_cancelled_by_customer'], obj.flagCancelledByCustomer);
+    cy.GLO_addDate(input, [formName, 'cancelled_date'], obj.cancelledDate);
+};

package/dist/blueprints/GLO_commandlist.d.ts

@@ -0,0 +1,10 @@
+import { type CheckState } from '../tsHelper.js';
+export type objCommandlist = {
+    commandlistType?: string;
+    validFrom?: string;
+    validTo?: string;
+    allowAutomaticUpdate?: CheckState;
+    customerRelation?: string;
+    commandlistCode?: string;
+};
+export declare const GLO_enterCommandlist: (obj: objCommandlist) => void;

package/dist/blueprints/GLO_commandlist.js

@@ -0,0 +1,10 @@
+import { input } from '../tsHelper.js';
+export const GLO_enterCommandlist = (obj) => {
+    const formName = 'ng$commandlist_dtl';
+    cy.GLO_addInput([formName, 'commandlist_type'], obj.commandlistType);
+    cy.GLO_addDate(input, [formName, 'valid_from'], obj.validFrom);
+    cy.GLO_addDate(input, [formName, 'valid_till'], obj.validTo);
+    cy.GLO_checkbox([formName, 'allow_automatic_update'], obj.allowAutomaticUpdate);
+    cy.GLO_popupWindow([formName, 'btn_select_relation'], obj.customerRelation);
+    cy.GLO_addInput([formName, 'commandlist_code'], obj.commandlistCode);
+};

package/dist/blueprints/GLO_complaint.d.ts

@@ -0,0 +1,27 @@
+type BaseComplaint = {
+    type?: string;
+    subtype?: string;
+    relationCode?: string;
+    responsible?: string;
+    subject?: string;
+    description?: string;
+    actionPoints?: string;
+    salesInvoice?: string | number;
+    customerReference?: string;
+    level?: string;
+    purchaseOrder?: string;
+};
+/**
+ * Force SO to be required when SOL is filled in.
+ */
+type ComplaintWithoutArticle = BaseComplaint & {
+    salesOrder?: string;
+    salesOrderLineArticleCode?: never;
+};
+type ComplaintWithArticle = BaseComplaint & {
+    salesOrder: string;
+    salesOrderLineArticleCode: string;
+};
+export type objComplaint = ComplaintWithoutArticle | ComplaintWithArticle;
+export declare const GLO_enterComplaint: (obj: objComplaint) => void;
+export {};

package/dist/blueprints/GLO_complaint.js

@@ -0,0 +1,51 @@
+import { close, equalBool, open, skipCheck, span } from '../tsHelper.js';
+const formName = 'ng$complaint_dtl';
+const formNameOrders = `${formName}_orders`;
+const detailTabsName = 'tabs_340';
+export const GLO_enterComplaint = (obj) => {
+    cy.GLO_addInput([formName, 'case_type_id'], obj.type);
+    cy.GLO_checkField([formName, 'case_type_id'], obj.type);
+    cy.GLO_checkLoadingIndicator();
+    cy.GLO_addInput([formName, 'subject'], obj.subject);
+    cy.GLO_addInput([formName, 'case_subtype_id'], obj.subtype);
+    cy.GLO_addInput([formName, 'relation_reference'], obj.customerReference);
+    cy.GLO_addInput([formName, 'case_level_id'], obj.level);
+    cy.GLO_popupWindow([formName, 'relation_code'], obj.relationCode, undefined, equalBool);
+    if (obj.responsible) {
+        // Needed for clearing the 'responsible' field first
+        const responsibleElementName = 'responsible_id';
+        cy.GLO_clearField([formName, responsibleElementName]);
+        cy.GLO_popupWindow([formName, responsibleElementName], obj.responsible);
+    }
+    if (obj.actionPoints) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Attributes', open);
+        //! Change this line if its ever possible to add input to aa text area via a name or when dynamic attributes have a 'data_cy'
+        cy.GLO_getElement(['attribute_value_9c8886bf_fc5d_46cd_a88e_c3ea67f92627']).find('textarea').clear().type(obj.actionPoints);
+        cy.GLO_selectTab([formName, detailTabsName], 'Attributes', close);
+    }
+    if (obj.description) {
+        cy.GLO_selectTab([formName, detailTabsName], 'Description', open);
+        cy.GLO_addInput(['ng$cases_dtl_description', 'description'], obj.description);
+        cy.GLO_selectTab([formName, detailTabsName], 'Description', close);
+    }
+    if (obj.salesInvoice || obj.salesOrder || obj.salesOrderLineArticleCode || obj.purchaseOrder) {
+        GLO_ordersTab(obj);
+    }
+};
+const GLO_ordersTab = (obj) => {
+    cy.GLO_selectTab([formName, detailTabsName], 'Orders', open);
+    cy.GLO_popupWindow([formNameOrders, 'btn_select_sales_invoice'], obj.salesInvoice);
+    cy.GLO_popupWindow([formNameOrders, 'btn_select_purchase_order'], obj.purchaseOrder);
+    if (obj.salesOrder && obj.salesOrderLineArticleCode) {
+        cy.GLO_popupWindow([formNameOrders, 'btn_select_sales_orderline'], obj.salesOrder);
+        cy.get('.window-body', { timeout: 10000 })
+            .filter(':visible')
+            .then(() => {
+            cy.GLO_dblClickRowInGrid(span, ['ng$salesorderline_sel', 'grid'], obj.salesOrderLineArticleCode, 'article_code', skipCheck);
+        });
+    }
+    else if (obj.salesOrder && !obj.salesOrderLineArticleCode) {
+        cy.GLO_popupWindow([formNameOrders, 'btn_select_sales_order'], obj.salesOrder);
+    }
+    cy.GLO_selectTab([formName, detailTabsName], 'Orders', close);
+};

package/dist/blueprints/GLO_composition.d.ts

@@ -0,0 +1,14 @@
+import { type CheckState } from '../tsHelper.js';
+export type objComposition = {
+    article?: string;
+    inputQuantity?: number;
+    inputUnit?: string;
+    quantityBase?: number;
+    flagDeliverPart?: CheckState;
+    flagPicking?: CheckState;
+    flagBackflush?: CheckState;
+    parentArticleVersion?: string;
+    componentArticleVersion?: string;
+    sequenceNumber?: number;
+};
+export declare const GLO_enterComposition: (obj: objComposition) => void;

package/dist/blueprints/GLO_composition.js

@@ -0,0 +1,20 @@
+import { close, open } from '../tsHelper.js';
+export const GLO_enterComposition = (obj) => {
+    const formName = 'ng$composition_dtl';
+    const formNameGeneral = 'ng$composition_dtl_general';
+    cy.GLO_addInput([formName, 'article_code'], obj.article);
+    cy.GLO_addInput([formName, 'position_nr'], obj.sequenceNumber);
+    cy.GLO_addInput([formName, 'articleversion'], obj.componentArticleVersion);
+    cy.GLO_addInput([formName, 'alternate_article_code'], obj.parentArticleVersion);
+    // General tab
+    if (obj.inputQuantity || obj.flagDeliverPart || obj.inputUnit || obj.quantityBase || obj.flagPicking || obj.flagBackflush) {
+        cy.GLO_selectTab([formName, 'tabs_70'], 'General', open);
+        cy.GLO_addInput([formNameGeneral, 'input_qty'], obj.inputQuantity);
+        cy.GLO_addInput([formNameGeneral, 'input_qty_per_unit_id'], obj.inputUnit);
+        cy.GLO_checkbox([formNameGeneral, 'flag_deliver_part'], obj.flagDeliverPart);
+        cy.GLO_checkbox([formNameGeneral, 'flag_picking'], obj.flagPicking);
+        cy.GLO_checkbox([formNameGeneral, 'flag_backflush'], obj.flagBackflush);
+        cy.GLO_addInput([formNameGeneral, 'quantity'], obj.quantityBase);
+        cy.GLO_selectTab([formName, 'tabs_70'], 'General', close);
+    }
+};