Importer 2019

process/ImporterCustomMappingFunctions_lib/ImporterCustomMappingFunctions_lib.aod

+<?xml version="1.0" encoding="UTF-8"?>
+<process xmlns="http://www.adito.de/2018/ao/Model" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" VERSION="1.2.1" xsi:schemaLocation="http://www.adito.de/2018/ao/Model adito://models/xsd/process/1.2.1">
+  <name>ImporterCustomMappingFunctions_lib</name>
+  <majorModelMode>DISTRIBUTED</majorModelMode>
+  <process>%aditoprj%/process/ImporterCustomMappingFunctions_lib/process.js</process>
+  <variants>
+    <element>LIBRARY</element>
+  </variants>
+</process>

process/ImporterCustomMappingFunctions_lib/process.js

+///////////////////////////////////////////////////////////////////
+/// custom toolkit methods for the import handler               ///
+/// edit this, since this is serperate vor every project        ///
+///////////////////////////////////////////////////////////////////

process/ImporterMappingFunctions_lib/ImporterMappingFunctions_lib.aod

+<?xml version="1.0" encoding="UTF-8"?>
+<process xmlns="http://www.adito.de/2018/ao/Model" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" VERSION="1.2.1" xsi:schemaLocation="http://www.adito.de/2018/ao/Model adito://models/xsd/process/1.2.1">
+  <name>ImporterMappingFunctions_lib</name>
+  <comment></comment>
+  <majorModelMode>DISTRIBUTED</majorModelMode>
+  <process>%aditoprj%/process/ImporterMappingFunctions_lib/process.js</process>
+  <variants>
+    <element>LIBRARY</element>
+  </variants>
+</process>

process/ImporterTest_lib/ImporterTest_lib.aod

+<?xml version="1.0" encoding="UTF-8"?>
+<process xmlns="http://www.adito.de/2018/ao/Model" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" VERSION="1.2.1" xsi:schemaLocation="http://www.adito.de/2018/ao/Model adito://models/xsd/process/1.2.1">
+  <name>ImporterTest_lib</name>
+  <majorModelMode>DISTRIBUTED</majorModelMode>
+  <process>%aditoprj%/process/ImporterTest_lib/process.js</process>
+  <variants>
+    <element>LIBRARY</element>
+  </variants>
+</process>

process/ImporterTest_lib/process.js

+import("system.question");
+import("system.text");
+import("system.db");
+import("Importer_lib");
+
+function ImporterTest() {
+    this.startImporter = function (pTestCases) {
+        var parse = function (pElement, pPath) {
+            if (pElement.childs == undefined) {
+                return [{ 
+                    id: text.encodeMS(pPath.concat(pElement.name)), 
+                    element: pElement }];
+            }
+            var childs = [];
+            for (let i = 0; i < pElement.childs.length; i++) {
+                childs.push(parse(pElement.childs[i], pPath.concat(pElement.name))[0])
+            }
+            return [{
+                id: text.encodeMS(pPath.concat(pElement.name)),
+                element: {
+                    name: pElement.name,
+                    description: pElement.description,
+                    childs: childs.map(function (val) { return val.id })
+                }
+            }].concat(childs);
+        }.bind(this)
+
+        for (let i = 0 ; i < Object.keys(pTestCases).length; i++)  {
+            var res = parse(pTestCases[Object.keys(pTestCases)[i]], []);
+            if (res.length == 1) {
+                this.startProcess(res[0].element);
+            } else {
+                for (var j = 1; j< res.length; j++) {
+                    var testcase = res[j].element;
+                    this.startProcess(testcase);
+                }
+            }
+        }
+    }
+    
+    this.getBaseImporter = function (pConfig) {
+        var imp = new Importer(pConfig);
+        imp.Log = "CONSOLE";
+        imp.LogLevel = imp.LogLevels.Debug;
+        imp.ImportUser = "IMPORTER_TESTER";
+        imp.Preview = false;
+        imp.Debug = true;
+        imp.LogLevel = imp.LogLevels.Debug;
+        imp.BatchSize = 50;
+        imp.skipEmptyValue = false;
+        if (db.getDatabaseType(pConfig.AliasTo) == db.DBTYPE_MARIADB10) imp.TableCase = imp.Cases.Lower;
+        return imp;
+    }
+    
+    this.startProcess = function (testCase) {
+        if (testCase.fn != undefined)  {   
+            var cbFn = function (pConfig) {
+                return this.getBaseImporter(pConfig)
+            }.bind(this)
+
+            var testResult = testCase.fn.call(testCase, cbFn);
+            if (testResult instanceof Importer)  {
+                testResult = testResult.process();
+                question.showMessage("Successful: " + testCase.name +"\n" + JSON.stringify(testResult, null, " "))
+            } else {
+                question.showMessage("Successful\nResult:\n\n" + testResult)
+            }
+        } else {
+            question.showMessage("No test function defined!", question.WARNING)
+        }
+        return true;
+    }
+}
+

process/Importer_lib/Importer_lib.aod

+<?xml version="1.0" encoding="UTF-8"?>
+<process xmlns="http://www.adito.de/2018/ao/Model" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" VERSION="1.2.1" xsi:schemaLocation="http://www.adito.de/2018/ao/Model adito://models/xsd/process/1.2.1">
+  <name>Importer_lib</name>
+  <majorModelMode>DISTRIBUTED</majorModelMode>
+  <process>%aditoprj%/process/Importer_lib/process.js</process>
+  <variants>
+    <element>LIBRARY</element>
+  </variants>
+</process>

process/_test_importer/_test_importer.aod

+<?xml version="1.0" encoding="UTF-8"?>
+<process xmlns="http://www.adito.de/2018/ao/Model" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" VERSION="1.2.1" xsi:schemaLocation="http://www.adito.de/2018/ao/Model adito://models/xsd/process/1.2.1">
+  <name>_test_importer</name>
+  <title>Importer</title>
+  <majorModelMode>DISTRIBUTED</majorModelMode>
+  <process>%aditoprj%/process/_test_importer/process.js</process>
+  <variants>
+    <element>EXECUTABLE</element>
+  </variants>
+</process>

process/_test_importer/process.js

+import("system.text");
+import("system.logging");
+import("Util_lib");
+import("ImporterTest_lib");
+import("Importer_lib");
+import("ImporterMappingFunctions_lib");
+
+var testfunctions = {
+    iKeyword: {
+        "insertKeywordNew": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iKeyword, {Container: 0, Keyword: 1}]]
+            }
+            return runFn(config);
+        },
+        "insertKeywordContainer": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iKeyword, {Container: 0, Keyword: 1}]]
+            }
+            return runFn(config);
+        },
+        "insertKeywordSame": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iKeyword, {Container: 0, Keyword: 1}]]
+            }
+            return runFn(config);
+        },
+        "insertKeywordMissing": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iKeyword, {Container: 0, Keyword: 1}]]
+            }
+            return runFn(config);
+        }
+    },
+    iAttribute: {
+        "insertAttributeNew": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iAttribute, {Attribute: 0, AType: 1}]]
+            }
+            return runFn(config);
+        },
+        "insertAttributeUsage": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iAttribute, {Attribute: 0, AType: 1, OType: 2}]]
+            }
+            return runFn(config);
+        },
+        "insertAttributeRelation": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iAttribute, {Attribute: 0, AType: 1, OType: 2, OID: 3, Value: 4}]]
+            }
+            return runFn(config);
+        },
+        "insertAttributeMissing": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iAttribute, {Attribute: 0, AType: 1}]]
+            }
+            return runFn(config);
+        },
+        "insertAttributeSame": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iAttribute, {Attribute: 0, AType: 1, OType: 2, OID: 3, Value: 4}]]
+            }
+            return runFn(config);
+        }
+    },
+    iKeywordAttribute: {
+        "insertKeywordAttributeNew": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iKeywordAttribute, {Attribute: 0, AType: 1, Container: 2}]]
+            }
+            return runFn(config);
+        },
+        "insertKeywordAttributeRelation": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iKeywordAttribute, {Attribute: 0, AType: 1, Container: 2, Keyword: 3, Value: 4}]]
+            }
+            return runFn(config);
+        },
+        "insertKeywordAttributeMissing": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iKeywordAttribute, {Attribute: 0, AType: 1, Container: 2, Keyword: 3, Value: 4}]]
+            }
+            return runFn(config);
+        }
+    },
+    iComm: {
+        "insertCommNew": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iComm, {Address: 0, Medium: 1, ContactID: 2}]]
+            }
+            return runFn(config);
+        },
+        "insertCommMissing": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iComm, {Address: 0, Medium: 1, ContactID: 2}]]
+            }
+            return runFn(config);
+        }
+    },
+    iActivityLink: {
+        "insertActivityLinkNew": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iActivityLink, {ActivityID: 0, OID: 1, OType: 2}]]
+            }
+            return runFn(config);
+        },      
+        "insertActivityLinkMissing": function(runFn) {
+            var config = {
+                AliasTo: "Data_alias",
+                DataFunction: function(pBatchNum, pBatchSize) {
+                    if (pBatchNum > 1) return null;
+                    return this.fixtures;
+                }.bind(this),
+                ImportCommand: "insert+update",
+                Mapping: [[iActivityLink, {ActivityID: 0, OID: 1, OType: 2}]]
+            }
+            return runFn(config);
+        }
+    }
+}  
+
+var fixtures = {
+    iKeyword: {
+        "insertKeywordNew": function() {
+            return [
+                ["ContainerTest1", "KeywordTest1"]               
+            ];
+        },
+        "insertKeywordContainer": function() {
+            return [
+                ["ContainerTest1", "KeywordTest2"],
+                ["ContainerTest1", "KeywordTest3"],
+                ["ContainerTest1", "KeywordTest4"],
+                ["ContainerTest1", "KeywordTest5"]
+            ];
+        },
+        "insertKeywordSame": function() {
+            return [
+                ["ContainerTest1", "KeywordTest1"],
+                ["ContainerTest1", "KeywordTest2"],
+                ["ContainerTest1", "KeywordTest3"],
+            ];
+        },
+        "insertKeywordMissing": function() {
+            return [
+                ["", "KeywordTest2"],
+                [1234, ""],
+            ];
+        }
+    },
+    iAttribute: {
+        "insertAttributeNew": function() {
+            return [
+                ["TestString", $AttributeTypes.TEXT.toString()],
+                ["TestCombo1.TestCombo2.TestCombo3", $AttributeTypes.COMBOVALUE.toString()],
+                ["TestBool", $AttributeTypes.BOOLEAN.toString()],
+                ["TestNum", $AttributeTypes.NUMBER.toString()]
+            ];
+        },
+        "insertAttributeUsage": function() {
+            return [
+                ["TestUsage1", $AttributeTypes.NUMBER.toString(), "Organisation"],
+                ["TestUsage1", $AttributeTypes.NUMBER.toString(), "Person"]
+            ];
+        },
+        "insertAttributeRelation": function() {
+            return [
+                ["TestRel1", $AttributeTypes.TEXT.toString(), "Person", "666", "six hundred sixty six"],
+                ["TestRel1", $AttributeTypes.TEXT.toString(), "Person", "777", "seven hundred seventy seven"],
+                ["TestRel2", $AttributeTypes.NUMBER.toString(), "Organisation", "888", 888],
+                ["TestRel2", $AttributeTypes.NUMBER.toString(), "Organisation", "999", 999]
+            ];
+        },
+        "insertAttributeMissing": function() {
+            return [
+                ["", $AttributeTypes.TEXT.toString()],
+                ["TestNum", ""],
+                ["", 234]
+            ];
+        },
+        "insertAttributeSame": function() {
+            return [
+                ["TestRel1", $AttributeTypes.TEXT.toString(), "Person", "666", "six hundred sixty four"],
+                ["TestRel1", $AttributeTypes.TEXT.toString(), "Person", "777", "seven hundred seventy five"]               
+            ];
+        }
+    },
+    iKeywordAttribute: {
+        "insertKeywordAttributeNew": function() {
+            return [
+                ["KeyAttribute1", $AttributeTypes.TEXT.toString(), "ContainerTest2"],
+                ["KeyAttribute2", $AttributeTypes.NUMBER.toString(), "ContainerTest2"],
+                ["KeyAttribute3", $AttributeTypes.TEXT.toString(), "ContainerTest3"]
+            ];
+        },
+        "insertKeywordAttributeRelation": function() {
+            return [
+                ["KeyAttRel1", $AttributeTypes.TEXT.toString(), "ContainerTest2", "KeywordTest6", "test value"],
+                ["KeyAttRel2", $AttributeTypes.TEXT.toString(), "ContainerTest2", "KeywordTest7", "test value"],
+                ["KeyAttribute2", $AttributeTypes.NUMBER.toString(), "ContainerTest1", "KeywordTest8", 888]
+            ]
+        },
+        "insertKeywordAttributeMissing": function() {
+            return [
+                ["KeyAttRel", 7, 1],
+                ["KeyAttRel", "My Format", "wrong format"],
+                []
+            ]
+        }
+    },
+    iComm: {
+        "insertCommNew": function() {
+            return [
+                ["TestAddress1", "1", "TestContact1"],
+                ["TestAddress2", "2", "TestContact1"]
+            ];
+        },
+        "insertCommMissing": function() {
+            return [
+                ["TestAddress", ""],
+                ["", 2, ""]
+            ];
+        }
+    },
+    iActivityLink: {
+        "insertActivityLinkNew": function() {
+            return [
+                ["TestActivityId",  "rowTest1", "Person"],
+                ["TestActivityId", "rowTest2", "Organisation"],
+                ["TestActivityId", "rowTest2", "Person"]
+            ];
+        },
+        "insertActivityLinkMissing": function() {
+            return [
+                ["", "rowTest1", "Person"],
+                ["ActivityId", 6293, "Organisation"]
+            ];
+        }
+    }
+}
+
+var testCases = [
+    {
+        name: "Keyword Test",
+        childs: [
+            {
+                name: "Import new keywords",
+                fn: testfunctions.iKeyword.insertKeywordNew,
+                fixtures: fixtures.iKeyword.insertKeywordNew()
+            },
+            {
+                name: "Import keywords with already existing container",
+                fn: testfunctions.iKeyword.insertKeywordContainer,
+                fixtures: fixtures.iKeyword.insertKeywordContainer()
+            },
+            {
+                name: "Import already existing keywords",
+                fn: testfunctions.iKeyword.insertKeywordSame,
+                fixtures: fixtures.iKeyword.insertKeywordSame()
+            },
+            {   
+                name: "Import keywords with missing/wrong values",
+                fn: testfunctions.iKeyword.insertKeywordMissing,
+                fixtures: fixtures.iKeyword.insertKeywordMissing()
+            }
+            
+        ]       
+    },
+    {
+        name: "Attribute Test",
+        childs: [
+            {
+                name: "Import new attributes",
+                fn: testfunctions.iAttribute.insertAttributeNew,
+                fixtures: fixtures.iAttribute.insertAttributeNew()
+            },
+            {
+                name: "Import new attributes with usage",
+                fn: testfunctions.iAttribute.insertAttributeUsage,
+                fixtures: fixtures.iAttribute.insertAttributeUsage()
+            },
+            {
+                name: "Import new attributes with usage and relation",
+                fn: testfunctions.iAttribute.insertAttributeRelation,
+                fixtures: fixtures.iAttribute.insertAttributeRelation()
+            },
+            {
+                name: "Import attributes with missing/wrong values",
+                fn: testfunctions.iAttribute.insertAttributeMissing,
+                fixtures: fixtures.iAttribute.insertAttributeMissing()
+            },
+            {
+                name: "Import already existing attributes",
+                fn: testfunctions.iAttribute.insertAttributeSame,
+                fixtures: fixtures.iAttribute.insertAttributeSame()
+            }
+        ]
+    },
+    {
+        name: "Keyword Attribute Test",
+        childs: [
+            {
+                name: "Import new keyword attributes",
+                fn: testfunctions.iKeywordAttribute.insertKeywordAttributeNew,
+                fixtures: fixtures.iKeywordAttribute.insertKeywordAttributeNew()
+            },
+            {
+                name: "Import keyword attribute relations",
+                fn: testfunctions.iKeywordAttribute.insertKeywordAttributeRelation,
+                fixtures: fixtures.iKeywordAttribute.insertKeywordAttributeRelation()
+            },
+            {
+                name: "Import keyword attributes with missing/wrong values",
+                fn: testfunctions.iKeywordAttribute.insertKeywordAttributeMissing,
+                fixtures: fixtures.iKeywordAttribute.insertKeywordAttributeMissing()
+            }
+        ]
+    },
+    {
+        name: "Communication Test",
+        childs: [
+            {
+                name: "Import new communication entries",
+                fn: testfunctions.iComm.insertCommNew,
+                fixtures: fixtures.iComm.insertCommNew()
+            },
+            {
+                name: "Import communication entries with missing/wrong values",
+                fn: testfunctions.iComm.insertCommMissing,
+                fixtures: fixtures.iComm.insertCommMissing()
+            }
+        ]
+    },
+    {
+        name: "Activitylink Test",
+        childs: [
+            {
+                name: "Import new activity link entries",
+                fn: testfunctions.iActivityLink.insertActivityLinkNew,
+                fixtures: fixtures.iActivityLink.insertActivityLinkNew()
+            },
+            {
+                name: "Import activity link entries with missing/wrong values",
+                fn: testfunctions.iActivityLink.insertActivityLinkMissing,
+                fixtures: fixtures.iActivityLink.insertActivityLinkMissing()
+            }
+        ]
+    }
+]
+
+
+var impTest = new ImporterTest();
+impTest.startImporter(testCases);
\ No newline at end of file