0);
+ }
+ public void actionPerformed(ActionEvent ae) {
+ moveSelectedNode(getIndexOfSelection() * -1);
+ }
+ }
+ class Up5Action extends NodeNavigateAction {
+ public Up5Action() {
+ super(" 5 ", new DoubleArrowUpIcon());
+ }
+ protected void checkAcceptable() {
+ if (isEnabled())
+ setEnabled(getIndexOfSelection() > 4);
+ }
+ public void actionPerformed(ActionEvent ae) {
+ moveSelectedNode(-5);
+ }
+ }
+ class Up1Action extends NodeNavigateAction {
+ public Up1Action() {
+ super(" 1 ", new ArrowUpIcon());
+ }
+ protected void checkAcceptable() {
+ if (isEnabled())
+ setEnabled(getIndexOfSelection() > 0);
+ }
+ public void actionPerformed(ActionEvent ae) {
+ moveSelectedNode(-1);
+ }
+ }
+ class Down1Action extends NodeNavigateAction {
+ public Down1Action() {
+ super(" 1 ", new ArrowDownIcon());
+ }
+ protected void checkAcceptable() {
+ if (isEnabled())
+ setEnabled(
+ getIndexOfSelection() + 1
+ <= getMaxPossibleIndexOfSelection());
+ }
+ public void actionPerformed(ActionEvent ae) {
+ moveSelectedNode(1);
+ }
+ }
+ class Down5Action extends NodeNavigateAction {
+ public Down5Action() {
+ super(" 5 ", new DoubleArrowDownIcon());
+ }
+ protected void checkAcceptable() {
+ if (isEnabled())
+ setEnabled(
+ getIndexOfSelection() + 5
+ <= getMaxPossibleIndexOfSelection());
+ }
+ public void actionPerformed(ActionEvent ae) {
+ moveSelectedNode(5);
+ }
+ }
+ class DownMaxAction extends NodeNavigateAction {
+ public DownMaxAction() {
+ super(" max", new DoubleArrowDownLineIcon());
+ }
+ protected void checkAcceptable() {
+ if (isEnabled())
+ setEnabled(
+ getIndexOfSelection() < getMaxPossibleIndexOfSelection());
+ }
+ public void actionPerformed(ActionEvent ae) {
+ moveSelectedNode(
+ getMaxPossibleIndexOfSelection() - getIndexOfSelection());
+ }
+ }
+ /* (non-Javadoc)
+ * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
+ */
+ public void actionPerformed(ActionEvent ae) {
+ if (ae.getActionCommand().equals("hide sortpanel"))
+ setSortPanelVisible(false);
+ for (Iterator it = actionListeners.iterator(); it.hasNext();) {
+ ActionListener al = (ActionListener) it.next();
+ al.actionPerformed(ae);
+ }
+ }
+ public void setBackground(Color c) {
+ super.setBackground(c);
+ if (pnorth != null)
+ pnorth.setBackground(c);
+ if (sortPanel != null)
+ sortPanel.setBackground(c);
+ if (sortButtonPanel != null)
+ sortButtonPanel.setBackground(c);
+ }
+
+ /**
+ * Adds an actionListener which is informed if the hide sortpanel button is clicked.
+ * @param al
+ */
+ public void addActionListener(ActionListener al) {
+ actionListeners.add(al);
+ }
+ public void removeActionListener(ActionListener al) {
+ actionListeners.remove(al);
+ }
+}
diff --git a/src/de/memtext/tree/TreeBuilder.java b/src/de/memtext/tree/TreeBuilder.java
new file mode 100644
index 0000000..533b7b4
--- /dev/null
+++ b/src/de/memtext/tree/TreeBuilder.java
@@ -0,0 +1,404 @@
+package de.memtext.tree;
+
+import java.awt.Frame;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.TreeSet;
+import java.util.Vector;
+
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import de.memtext.baseobjects.NamedIdObjectWithParentI;
+import de.memtext.baseobjects.coll.NamedIdObjectWithParentList;
+import de.memtext.time.EphemeralI;
+import de.memtext.widgets.NodeSelectionPanel;
+import de.superx.common.SelectableItemNode;
+
+/**
+ * @author MB
+ *
+ * Adds the nodes in a collection to a root in hierarchical child, parent manner
+ * according to their key and parent entries. The nodes have to implement the
+ * TreeEntry Interface.
+ */
+public class TreeBuilder {
+ private static Collection _elementCollection;
+
+ private static NamedIdObjectWithParentList _nodeList;
+
+ /**
+ *
+ */
+ private TreeBuilder() {
+ }
+
+ private static void addNodesToRoot2(DefaultMutableTreeNode root,
+ NamedIdObjectWithParentList rawList) throws NoMainEntryException {
+ _nodeList = toNodeList(rawList);
+ rawList = null;
+ insertNodes2(root, null);
+
+ }
+
+ private static NamedIdObjectWithParentList toNodeList(
+ NamedIdObjectWithParentList rawList) {
+ NamedIdObjectWithParentList result = new NamedIdObjectWithParentList();
+ for (Iterator it = rawList.iterator(); it.hasNext();) {
+ NamedIdObjectWithParentI element = (NamedIdObjectWithParentI) it
+ .next();
+ result.add(new TreeEntryNode(element));
+ }
+ return result;
+ }
+
+ private static void insertNodes2(DefaultMutableTreeNode presentNode,
+ Object theParent) throws NoMainEntryException {
+ if (_nodeList == null)
+ throw new RuntimeException("node list is null, set it before");
+ TreeEntryNode newNode;
+ NamedIdObjectWithParentList result = (NamedIdObjectWithParentList) _nodeList
+ .getByParent(theParent);
+
+ if (theParent == null && result.size() == 0) {
+ StringBuffer buf = new StringBuffer(
+ "These elements in collection\n");
+ for (Iterator it = _elementCollection.iterator(); it.hasNext();) {
+ TreeEntryI element = (TreeEntryI) it.next();
+ buf.append(element.toString() + "\n");
+
+ }
+ throw new NoMainEntryException(buf.toString());
+ }
+
+ for (Iterator it = result.iterator(); it.hasNext();) {
+ newNode = (TreeEntryNode) it.next();
+ presentNode.add(newNode);
+ insertNodes2(newNode, newNode.getOwnKey());
+
+ }
+ }
+
+ public static NodeSelectionPanel createNodeSelectionPanel(Frame owner,
+ String infoText, NamedIdObjectWithParentList rawList)
+ throws NoMainEntryException {
+ DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
+ TreeBuilder.addNodesToRoot2(root, rawList);
+ JTree tree = new JTree(root);
+ tree.setRootVisible(false);
+ NodeSelectionPanel nsp = new NodeSelectionPanel(owner, infoText, tree);
+ return nsp;
+ }
+
+ /**
+ * @deprecated
+ * @param root
+ * @param elementCollection
+ * @throws NoMainEntryException
+ * @throws KeyParentEqualException
+ */
+ public static void addNodesToRoot(DefaultMutableTreeNode root,
+ Collection elementCollection) throws NoMainEntryException,
+ KeyParentEqualException {
+ _elementCollection = elementCollection;
+ insertnodes(root, null);
+ }
+
+ /**
+ * @deprecated
+ * @param presentNode
+ * @param theParent
+ * @throws NoMainEntryException
+ * @throws KeyParentEqualException
+ */
+ private static void insertnodes(DefaultMutableTreeNode presentNode,
+ Object theParent) throws NoMainEntryException,
+ KeyParentEqualException {
+ if (_elementCollection == null)
+ throw new RuntimeException(
+ "element collection is null, set it before");
+ DefaultMutableTreeNode newNode;
+ Collection result = getEntries(theParent);
+
+ if (theParent == null && result.size() == 0) {
+ StringBuffer buf = new StringBuffer(
+ "These elements in collection\n");
+ for (Iterator it = _elementCollection.iterator(); it.hasNext();) {
+ TreeEntryI element = (TreeEntryI) it.next();
+ buf.append(element.toString() + "\n");
+
+ }
+ throw new NoMainEntryException(buf.toString());
+ }
+
+ Object keyOfNewNode;
+ for (Iterator it = result.iterator(); it.hasNext();) {
+ newNode = (DefaultMutableTreeNode) it.next();
+ presentNode.add(newNode);
+ TreeEntryI newEntry = (TreeEntryI) newNode;
+
+ keyOfNewNode = newEntry.getOwnKey();
+ //nervig null-Werte abfangen
+ if (keyOfNewNode != null && theParent == null)
+ insertnodes(newNode, keyOfNewNode);
+ if (keyOfNewNode == null && theParent == null)
+ throw new KeyParentEqualException(newEntry);
+
+ if (keyOfNewNode != null && theParent != null)
+ if (!theParent.equals(keyOfNewNode))
+ insertnodes(newNode, keyOfNewNode);
+ else
+ throw new KeyParentEqualException(newEntry);
+ }
+
+ }
+
+ /**
+ * liefert alle Einträge mit Parent =checkparent zurück
+ *
+ * @deprecated
+ * @param checkparent
+ * @return Collection
+ */
+ private static Collection getEntries(Object checkparent) {
+
+ Collection result = new LinkedList();
+ Object entrysParent;
+ TreeEntryI anEntry;
+ for (Iterator it = _elementCollection.iterator(); it.hasNext();) {
+ anEntry = (TreeEntryI) it.next();
+ entrysParent = anEntry.getParentKey();
+ if (entrysParent == null && checkparent == null)
+ result.add(anEntry);
+ if (entrysParent != null && checkparent != null)
+ if (entrysParent.equals(checkparent))
+ result.add(anEntry);
+ }
+ //would make faster
+ //_elementCollection.removeAll(result);
+ return result;
+ }
+
+ /**
+ * Newest and fastest version, with map You have to create a HashMap with
+ * one entry of each used parentkey. The value of that entry is a Collection
+ * that has to contain the individual TreeNodes that have the particular
+ * parentKey. See OlapDimension.getRawDataMap for an example
+ *
+ * @param root
+ * @param map -
+ * may be a ChildnodeMap, but doesn't have to be
+ * @param stand -
+ * wenn Stand nicht null ist, werden nur Knoten (müssen vom
+ * de.memtext.time.EphemeralI implementieren, normalerweise
+ * EphemeralTreeEntryNode), die zum angegeben Stand gültig sind,
+ * übergeben
+ * @throws NoMainEntryException
+ * @throws KeyParentEqualException
+ * @see ChildnodeMap
+ */
+ public static void addNodesToRootFromMap(DefaultMutableTreeNode root,
+ HashMap map, java.util.Date stand) throws NoMainEntryException,
+ KeyParentEqualException {
+ NodeInserter inserter = new NodeInserter(map);
+ /* for (Iterator it = map.keySet().iterator(); it.hasNext();) {
+ Object element = (Object) it.next();
+ System.out.println("*"+element+"*");
+ }*/
+ inserter.insertNodesFromMap(root, null, stand);
+ }
+
+ public static void addNodesToRootFromMap(DefaultMutableTreeNode root, Object parentKey,
+ HashMap map, java.util.Date stand) throws NoMainEntryException,
+ KeyParentEqualException {
+ NodeInserter inserter = new NodeInserter(map);
+ inserter.insertNodesFromMap(root, parentKey, stand);
+ }
+ public static void addNodesToRootFromMapByLid(DefaultMutableTreeNode root,String parentLid,
+ HashMap map, java.util.Date stand) throws NoMainEntryException,
+ KeyParentEqualException {
+ NodeInserterLid inserter = new NodeInserterLid(map);
+ /* for (Iterator it = map.keySet().iterator(); it.hasNext();) {
+ Object element = (Object) it.next();
+ System.out.println("*"+element+"*");
+ }*/
+ inserter.insertNodesFromMap(root, parentLid, stand);
+ }
+ public static void add(HashMap map, TreeEntryI item) {
+ add(map,item,item.getParentKey());
+
+ }
+ public static void add(HashMap map, Object item, Object parent) {
+ Collection col;
+ Object obj = map.get(parent);
+ if (obj == null) {
+ // col = new LinkedList();
+ col=new TreeSet();
+ map.put(parent, col);
+ } else {
+ col = (Collection) obj;
+ }
+ col.add(item);
+ }
+
+ private static class NodeInserter {
+ private Map elementMap;
+
+ NodeInserter(Map map) {
+ this.elementMap = map;
+ if (elementMap == null)
+ throw new RuntimeException("element map must not be null");
+ }
+
+ void insertNodesFromMap(DefaultMutableTreeNode presentNode,
+ Object theParent, java.util.Date stand)
+ throws NoMainEntryException, KeyParentEqualException {
+ DefaultMutableTreeNode newNode;
+ Collection result;
+ Object obj = elementMap.get(theParent);
+ if (obj == null)
+ result = new TreeSet(); //no entries with that parent
+ else
+ result = (Collection) obj;
+
+ if (theParent == null)
+ checkAtLeastOneChild(result);
+
+ Object keyOfNewNode;
+ for (Iterator it = result.iterator(); it.hasNext();) {
+ newNode = (DefaultMutableTreeNode) it.next();
+
+ TreeEntryI newEntry = (TreeEntryI) newNode;
+
+ //bei ungültigen Knoten überspringen
+ if (stand != null) {
+ EphemeralI potentialNewEntry = (EphemeralI) newEntry;
+ if (!potentialNewEntry.isValidAt(stand))
+ continue;
+ }
+
+ try
+ {
+
+
+ presentNode.add(newNode);
+ }
+ catch (java.lang.IllegalArgumentException e)
+ {
+ throw new IllegalArgumentException("Konnte Knoten "+newEntry.getOwnKey()+ "nicht einfügen unter "+theParent+" "+e);
+ }
+ keyOfNewNode = newEntry.getOwnKey();
+ //nervig null-Werte abfangen
+ if (keyOfNewNode != null && theParent == null)
+ insertNodesFromMap(newNode, keyOfNewNode, stand);
+
+ if (keyOfNewNode != null && theParent != null)
+ if (!theParent.equals(keyOfNewNode))
+ insertNodesFromMap(newNode, keyOfNewNode, stand);
+ else
+ throw new KeyParentEqualException(newEntry);
+ }
+
+ }
+
+ private void checkAtLeastOneChild(Collection result)
+ throws NoMainEntryException {
+ if (result.size() == 0) {
+ StringBuffer buf = new StringBuffer(
+ "These elements in collection\n");
+
+ for (Iterator it = elementMap.values().iterator(); it.hasNext();) {
+ Collection c = (Collection) it.next();
+ for (Iterator it2 = c.iterator(); it2.hasNext();) {
+ TreeEntryI element = (TreeEntryI) it2.next();
+ buf.append(element.toString() + "\n");
+ }
+ }
+ throw new NoMainEntryException(buf.toString());
+ }
+ }
+
+ }
+
+ private static class NodeInserterLid {
+ private Map elementMap;
+
+ NodeInserterLid(Map map) {
+ this.elementMap = map;
+ if (elementMap == null)
+ throw new RuntimeException("element map must not be null");
+ }
+
+ void insertNodesFromMap(DefaultMutableTreeNode presentNode,
+ Object theParent, java.util.Date stand)
+ throws NoMainEntryException, KeyParentEqualException {
+ SelectableItemNode newNode;
+ Collection result;
+ Object obj = elementMap.get(theParent);
+ if (obj == null)
+ result = new TreeSet(); //no entries with that parent
+ else
+ result = (Collection) obj;
+
+ if (theParent == null)
+ checkAtLeastOneChild(result);
+
+ String lidOfNewNode;
+ for (Iterator it = result.iterator(); it.hasNext();) {
+ newNode = (SelectableItemNode) it.next();
+
+ TreeEntryI newEntry = (TreeEntryI) newNode;
+
+ //bei ungültigen Knoten überspringen
+ if (stand != null) {
+ EphemeralI potentialNewEntry = (EphemeralI) newEntry;
+ if (!potentialNewEntry.isValidAt(stand))
+ continue;
+ }
+
+ try
+ {
+
+
+ presentNode.add(newNode);
+ }
+ catch (java.lang.IllegalArgumentException e)
+ {
+ throw new IllegalArgumentException("Konnte Knoten "+newEntry.getOwnKey()+ "nicht einfügen unter "+theParent+" "+e);
+ }
+ lidOfNewNode = newNode.getLid();
+ //nervig null-Werte abfangen
+ if (lidOfNewNode != null && theParent == null)
+ insertNodesFromMap(newNode, lidOfNewNode, stand);
+
+ if (lidOfNewNode != null && theParent != null)
+ if (!theParent.equals(lidOfNewNode))
+ insertNodesFromMap(newNode, lidOfNewNode, stand);
+ else
+ throw new KeyParentEqualException(newEntry);
+ }
+
+ }
+
+ private void checkAtLeastOneChild(Collection result)
+ throws NoMainEntryException {
+ if (result.size() == 0) {
+ StringBuffer buf = new StringBuffer(
+ "These elements in collection\n");
+
+ for (Iterator it = elementMap.values().iterator(); it.hasNext();) {
+ Collection c = (Collection) it.next();
+ for (Iterator it2 = c.iterator(); it2.hasNext();) {
+ TreeEntryI element = (TreeEntryI) it2.next();
+ buf.append(element.toString() + "\n");
+ }
+ }
+ throw new NoMainEntryException(buf.toString());
+ }
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/TreeEntryI.java b/src/de/memtext/tree/TreeEntryI.java
new file mode 100644
index 0000000..043f954
--- /dev/null
+++ b/src/de/memtext/tree/TreeEntryI.java
@@ -0,0 +1,14 @@
+package de.memtext.tree;
+
+/**
+ * @author MB
+ *
+ * This interface to be implemented by TreeNodes which are to be automatically
+ * brought into hierarchical shape using the TreeFactory.
+ */
+public interface TreeEntryI {
+public Object getParentKey();
+public Object getOwnKey();
+public String getName();
+public void setName(String name);
+}
diff --git a/src/de/memtext/tree/TreeEntryNode.java b/src/de/memtext/tree/TreeEntryNode.java
new file mode 100644
index 0000000..2c4f884
--- /dev/null
+++ b/src/de/memtext/tree/TreeEntryNode.java
@@ -0,0 +1,49 @@
+package de.memtext.tree;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import de.memtext.baseobjects.NamedIdObjectWithParentI;
+/**
+ * A node that can be used in hierarchic trees,
+ * constructed from a NamedIdObject (id is not tid but key)
+ * and an object (parent key)
+ *
+ * Adapter between TreeNodeI and NamedIdObjectWithParentI
+ */
+public class TreeEntryNode
+ extends DefaultMutableTreeNode
+ implements TreeEntryI, NamedIdObjectWithParentI {
+
+ private static final long serialVersionUID = 1L;
+ private NamedIdObjectWithParentI namedIdObjectWithParentI;
+
+ public TreeEntryNode(NamedIdObjectWithParentI namedIdObjectWithParentI) {
+ this.namedIdObjectWithParentI = namedIdObjectWithParentI;
+ }
+ public Object getParentKey() {
+ return namedIdObjectWithParentI.getParentKey();
+ }
+ public Object getOwnKey() {
+ return namedIdObjectWithParentI.getId();
+ }
+ public String getName() {
+ return namedIdObjectWithParentI.getName();
+ }
+ public String toString() {
+ return namedIdObjectWithParentI.getName();
+ }
+ public void setParentKey(Object parentKey) throws KeyParentEqualException {
+ namedIdObjectWithParentI.setParentKey(parentKey);
+ }
+ public Object getId() {
+ return namedIdObjectWithParentI.getId();
+ }
+ public void setId(Object id) {
+ namedIdObjectWithParentI.setId(id);
+ }
+ public void setName(String name) {
+ namedIdObjectWithParentI.setName(name);
+ }
+}
+
+//Created on 18.11.2003
\ No newline at end of file
diff --git a/src/de/memtext/tree/TreeTableIdManager.java b/src/de/memtext/tree/TreeTableIdManager.java
new file mode 100644
index 0000000..ed77660
--- /dev/null
+++ b/src/de/memtext/tree/TreeTableIdManager.java
@@ -0,0 +1,52 @@
+package de.memtext.tree;
+
+public class TreeTableIdManager {
+ private int counter[] = new int[100];
+ private int currentLevel = 0;
+ private int previousLevel = 999;
+ private int minLevel = 1;
+
+ public String getTreeTableId(int level) {
+ if (previousLevel > level) {
+ if (level == minLevel) {
+ for (int i = 1; i < 100; i++)
+ counter[i] = 0;
+ currentLevel = 0;
+ } else {
+ for (int i = currentLevel; i < 100; i++)
+ counter[i] = 0;
+ currentLevel--;
+ if (currentLevel < 0)
+ currentLevel = 0;
+ }
+ counter[currentLevel]++;
+ }
+ if (previousLevel == level) {
+ counter[currentLevel]++;
+ }
+ if (previousLevel < level) {
+ currentLevel++;
+ }
+ previousLevel = level;
+ StringBuffer buf = new StringBuffer();
+ for (int i = 0; i <= currentLevel; i++) {
+ buf.append("_" + counter[i]);
+ }
+ // System.out.println(level+":"+buf);
+ return buf.toString();
+ }
+
+ public void setMinLevel(int minlevel) {
+ this.minLevel = minlevel;
+ }
+
+ public void reset() {
+ currentLevel = 0;
+ minLevel=0;
+ previousLevel = 999;
+ for (int i = 0; i < 100; i++)
+ counter[i] = 0;
+ }
+}
+
+// Created on 15.09.2007 at 09:47:13
diff --git a/src/de/memtext/tree/admin/AddSubNodeAction.java b/src/de/memtext/tree/admin/AddSubNodeAction.java
new file mode 100644
index 0000000..7c8e6b7
--- /dev/null
+++ b/src/de/memtext/tree/admin/AddSubNodeAction.java
@@ -0,0 +1,55 @@
+package de.memtext.tree.admin;
+import javax.swing.JFrame;
+/**
+ * Insert the type's description here.
+ * Creation date: (01.03.2003 14:41:12)
+ * @author:
+ */
+
+public class AddSubNodeAction extends EntryNodeAction {
+
+ /**
+ * AddSubNodeAction constructor comment.
+ */
+ public AddSubNodeAction(AdminTreeModel model) {
+ super(model);
+ }
+ /**
+ * AddSubNodeAction constructor comment.
+ * @param name java.lang.String
+ */
+ public AddSubNodeAction(String name, AdminTreeModel model) {
+ super(name, model);
+ }
+
+ /**
+ * AddSubNodeAction constructor comment.
+ * @param name java.lang.String
+ * @param icon javax.swing.Icon
+ */
+ public AddSubNodeAction(
+ String name,
+ javax.swing.Icon icon,
+ AdminTreeModel model) {
+ super(name, icon, model);
+
+ }
+
+ /**
+ * actionPerformed method comment.
+ */
+ public void actionPerformed(java.awt.event.ActionEvent arg1) {
+ EntryNode newNode = (EntryNode) model.getPrototypeEntry().clone();
+ EntryNode selectedNode = (EntryNode) getSelectedNode();
+ newNode.setParentKey(selectedNode.getKey());
+ EditDlg dlg = new EditDlg(new JFrame(), newNode);
+ dlg.show();
+ if (dlg.wasOkSelected()) {
+ model.insertNodeInto(
+ newNode,
+ selectedNode,
+ selectedNode.getChildCount());
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/AddTopLevelNodeAction.java b/src/de/memtext/tree/admin/AddTopLevelNodeAction.java
new file mode 100644
index 0000000..8edb68a
--- /dev/null
+++ b/src/de/memtext/tree/admin/AddTopLevelNodeAction.java
@@ -0,0 +1,61 @@
+package de.memtext.tree.admin;
+import javax.swing.AbstractAction;
+import javax.swing.JFrame;
+/**
+ * Insert the type's description here.
+ * Creation date: (01.03.2003 14:41:12)
+ * @author:
+ */
+
+public class AddTopLevelNodeAction extends AbstractAction {
+ private AdminTreeModel model;
+ /**
+ * EditAction constructor comment.
+ */
+ public AddTopLevelNodeAction(AdminTreeModel model) {
+ super();
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ }
+ /**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ */
+ public AddTopLevelNodeAction(String name, AdminTreeModel model) {
+ super(name);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ }
+ /**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ * @param icon javax.swing.Icon
+ */
+ public AddTopLevelNodeAction(
+ String name,
+ javax.swing.Icon icon,
+ AdminTreeModel model) {
+ super(name, icon);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ }
+ /**
+ * actionPerformed method comment.
+ */
+ public void actionPerformed(java.awt.event.ActionEvent arg1) {
+
+ EntryNode newNode = (EntryNode) model.getPrototypeEntry().clone();
+ EditDlg dlg = new EditDlg(new JFrame(), newNode);
+ dlg.show();
+ if (dlg.wasOkSelected())
+ {
+ EntryNode root = (EntryNode) model.getRoot();
+ root.add(newNode);
+ model.reload();
+
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/Admin.java b/src/de/memtext/tree/admin/Admin.java
new file mode 100644
index 0000000..9ae27e8
--- /dev/null
+++ b/src/de/memtext/tree/admin/Admin.java
@@ -0,0 +1,74 @@
+package de.memtext.tree.admin;
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JToolBar;
+/**
+ * Insert the type's description here.
+ * Creation date: (28.02.2003 10:41:03)
+ * @author:
+ */
+public class Admin extends JFrame {
+ /**
+ * Tester constructor comment.
+ */
+
+ public static void main(String[] arg) {
+ new Admin(arg[0]);
+ }
+ public Admin(String tablename) {
+ super("Admin");
+ de.memtext.util.PlafUtils.setWindowsLook(this);
+ Status.getInstance().setFrame(this);
+ TableChooser tc=new TableChooser();
+ tc.show();
+ RecursiveTableAdminPanel recursiveTableAdmin = null;
+ try {
+ recursiveTableAdmin = new RecursiveTableAdminPanel(tablename);
+ } catch (Exception e) {
+ JOptionPane.showMessageDialog(
+ null,
+ "Tabelle kann nicht bearbeitet werden.\n"+e.toString(),
+ "Fehler",
+ JOptionPane.WARNING_MESSAGE);
+System.exit(-1);
+ }
+ // recursivTableAdmin.setTable(tablename);
+ Container cp = this.getContentPane();
+ this.setJMenuBar(recursiveTableAdmin.getAMenuBar());
+ JToolBar toolbar = recursiveTableAdmin.getToolBar();
+
+ cp.add(toolbar, BorderLayout.NORTH);
+ cp.add(recursiveTableAdmin, BorderLayout.CENTER);
+ this.addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent e) {
+ // end();
+ }
+ });
+
+ JPanel down = new JPanel();
+ //down.add(new JButton(saveAction));
+ JButton btnOK = new JButton("OK");
+ /* JButton clear=new JButton("clear");
+ clear.addActionListener(new ActionListener()
+ {
+ public void actionPerformed(ActionEvent ae)
+ {
+ tree.clearSelection();
+ }
+ });
+ btnOK.addActionListener(this);
+ down.add(clear);
+ down.add(btnOK);*/
+ cp.add(down, BorderLayout.SOUTH);
+ this.setSize(500, 400);
+ this.show();
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/AdminTree.java b/src/de/memtext/tree/admin/AdminTree.java
new file mode 100644
index 0000000..9360186
--- /dev/null
+++ b/src/de/memtext/tree/admin/AdminTree.java
@@ -0,0 +1,213 @@
+package de.memtext.tree.admin;
+
+import java.awt.Insets;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.datatransfer.Transferable;
+import java.awt.dnd.Autoscroll;
+import java.awt.dnd.DnDConstants;
+import java.awt.dnd.DragGestureEvent;
+import java.awt.dnd.DragGestureListener;
+import java.awt.dnd.DragSource;
+import java.awt.dnd.DragSourceDragEvent;
+import java.awt.dnd.DragSourceDropEvent;
+import java.awt.dnd.DragSourceEvent;
+import java.awt.dnd.DragSourceListener;
+import java.awt.dnd.DropTarget;
+import java.awt.dnd.DropTargetDragEvent;
+import java.awt.dnd.DropTargetDropEvent;
+import java.awt.dnd.DropTargetEvent;
+import java.awt.dnd.DropTargetListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JPopupMenu;
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+
+public class AdminTree
+ extends javax.swing.JTree
+ implements
+ TreeModelListener,
+ DragGestureListener,
+ DragSourceListener,
+ DropTargetListener ,Autoscroll{
+ private String tablename;
+ private java.util.List entryNodes;
+ private EntryNode prototypeEntry;
+ private EntryNode root;
+private int lastRowOver=-1;
+ class ShowPopUpMouseAdapter extends MouseAdapter {
+ private JPopupMenu popupMenu;
+ public ShowPopUpMouseAdapter(JPopupMenu popupMenu) {
+ super();
+ this.popupMenu = popupMenu;
+ }
+
+ //MouseListener
+ public void mouseClicked(MouseEvent me) {
+ if (me.isPopupTrigger())
+ showPopupMenu(me);
+
+ }
+ /* public void mouseEntered(MouseEvent event) {
+ }
+ public void mouseExited(MouseEvent event) {
+ }*/
+ public void mousePressed(MouseEvent me) {
+ if (me.isPopupTrigger())
+ showPopupMenu(me);
+
+ }
+ public void mouseReleased(MouseEvent me) {
+ if (me.isPopupTrigger()) {
+ showPopupMenu(me);
+
+ }
+ }
+ void showPopupMenu(MouseEvent event) {
+
+ //prüfen ob über einem Knoten
+ TreePath tp = getPathForLocation(event.getX(), event.getY());
+ if (tp == null)
+ return;
+ setSelectionPath(tp);
+ popupMenu.show(event.getComponent(), event.getX(), event.getY());
+
+ }
+ }
+ public AdminTree(AdminTreeModel model, JPopupMenu popupMenu) {
+ super(model);
+ this.addMouseListener(new ShowPopUpMouseAdapter(popupMenu));
+ this.setRootVisible(false);
+ DragSource dragSource = DragSource.getDefaultDragSource();
+
+ dragSource.createDefaultDragGestureRecognizer(this,
+ // component where drag originates
+ DnDConstants.ACTION_MOVE, // actions
+ this); // drag gesture recognizer
+
+ DropTarget dropTarget = new DropTarget(this, DnDConstants.ACTION_MOVE, this);
+ }
+ //source
+ public void dragDropEnd(DragSourceDropEvent e) {
+ }
+ public void dragEnter(DragSourceDragEvent e) {
+ }
+ public void dragEnter(DropTargetDragEvent e) {
+ }
+ public void dragExit(DragSourceEvent e) {
+ }
+ public void dragExit(DropTargetEvent e) {
+ }
+ public void dragGestureRecognized(DragGestureEvent e) {
+
+ TreePath path = this.getLeadSelectionPath();
+ DefaultMutableTreeNode selectedNode =
+ (DefaultMutableTreeNode) path.getLastPathComponent();
+ Transferable tr = (Transferable) selectedNode;
+ // TreeTransferable tr=new TreeTransferable(selectedNode);
+
+ e.startDrag(DragSource.DefaultMoveDrop, // cursor
+ tr, // transferable
+ this); // drag source listener
+ }
+ public void dragOver(DragSourceDragEvent e) {
+ }
+ //target
+ public void dragOver(DropTargetDragEvent e) {
+ e.acceptDrag(DnDConstants.ACTION_MOVE);
+ }
+
+ public void drop(DropTargetDropEvent e) {
+ try {
+ DefaultTreeModel model=(DefaultTreeModel)this.getModel();
+ EntryNode movingNode=null;
+
+ /*Using a Transferable didn't work properly, the moving node wasn't
+ deleted at the originating position, does Transferable create a copy?
+
+ */
+ //=(EntryNode)e.getTransferable().getTransferData(TreeTransferable.TREETRANSFERABLE_FLAVOR);
+
+ TreePath selectionPath = getLeadSelectionPath();
+ EntryNode selectedNode = (EntryNode) selectionPath.getLastPathComponent();
+
+ movingNode=selectedNode;
+// System.out.println("gleich:" +(movingNode==selectedNode));
+
+
+ Point loc = e.getLocation();
+ EntryNode newParent =
+ (EntryNode) getPathForLocation(loc.x, loc.y).getLastPathComponent();
+model.removeNodeFromParent(movingNode);//fires events also
+ model.insertNodeInto(movingNode,newParent,newParent.getChildCount());
+
+ movingNode.updateParentKey();
+ e.acceptDrop(DnDConstants.ACTION_MOVE);
+ e.getDropTargetContext().dropComplete(true);
+ //model neu laden und Ast aufklappen
+
+ //model.reload(oldparent);
+ //model.reload(newParent);
+ //model.reload();
+ TreePath parentPath = new TreePath(newParent.getPath());
+ expandPath(parentPath);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ }
+ this.validate();
+ this.repaint();
+ }
+ public void dropActionChanged(DragSourceDragEvent e) {
+ }
+ public void dropActionChanged(DropTargetDragEvent e) {
+ }
+ public void treeNodesChanged(TreeModelEvent e) {
+ }
+ /**
+ * For whatever reason scrollPathToVisible doesn't work
+ * Causes problems (empty rows) when more than one row inserted
+ **/
+ public void treeNodesInserted(TreeModelEvent e) {
+ // TreePath parentPath=e.getTreePath();
+ // DefaultMutableTreeNode parentNode=(DefaultMutableTreeNode)parentPath.getLastPathComponent();
+ // DefaultMutableTreeNode newChild=(DefaultMutableTreeNode)parentNode.getChildAt(e.getChildIndices()[0]);
+ DefaultMutableTreeNode newChild = (DefaultMutableTreeNode) e.getChildren()[0];
+
+ TreePath tp = new TreePath(newChild.getPath());
+ // System.out.println(SwingUtilities.isEventDispatchThread());
+ expandPath(tp);
+ this.makeVisible(tp);
+ scrollPathToVisible(tp);
+ }
+ public void treeNodesRemoved(TreeModelEvent e) {
+ }
+ public void treeStructureChanged(TreeModelEvent e) {
+ }
+ public void autoscroll(Point p){
+int currentRow = this.getClosestRowForLocation(p.x,p.y);
+ // (int) lastRowOver is a member of the class, initialized with -1
+if (lastRowOver==-1) {lastRowOver=currentRow;return;}
+
+if(currentRow > lastRowOver)
+ scrollRowToVisible(currentRow + 1);
+ else if(currentRow > 0)
+ scrollRowToVisible(currentRow - 1);
+ lastRowOver = currentRow;
+ }
+
+public Insets getAutoscrollInsets() {
+int margin=12;
+ Rectangle outer = getBounds();
+Rectangle inner = getParent().getBounds();
+return new Insets(
+inner.y - outer.y + margin, inner.x - outer.x + margin,
+outer.height - inner.height - inner.y + outer.y + margin,
+outer.width - inner.width - inner.x + outer.x + margin);
+}
+}
+//* Creation date: (28.02.2003 18:53:41)
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/AdminTreeModel.java b/src/de/memtext/tree/admin/AdminTreeModel.java
new file mode 100644
index 0000000..aca9155
--- /dev/null
+++ b/src/de/memtext/tree/admin/AdminTreeModel.java
@@ -0,0 +1,240 @@
+package de.memtext.tree.admin;
+
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+
+import de.memtext.db.DBAccess;
+/**
+ * Insert the type's description here.
+
+ * @author:
+ */
+/*
+Verbesserungsmöglichkeiten:
+- wenn Fehlerknoten auftreten, die auf Struktur prüfen,
+vielleicht fehlt z.B. nur bei Fak2 der richtige ParentKey-Eintrag
+alle Lehreinheiten darunter sind aber OK
+*/
+public class AdminTreeModel extends DefaultTreeModel {
+ private String tablename;
+ private StringBuffer protocol;
+ private java.util.List entryNodes;
+ private EntryNode prototypeEntry;
+ private EntryNode root;
+ private final String noMainKey =
+ "Kein Haupteintrag mit parent=null gefunden!";
+ private final String error1Txt =
+ "Element hat fälschlicherweise den eigenen Key als parent key";
+ private DefaultMutableTreeNode errorNodes =
+ new DefaultMutableTreeNode("Error nodes");
+ private IllegalArgumentException noMainKeyEx =
+ new IllegalArgumentException(noMainKey);
+ private boolean isNoMainKeyAcceptable = true;
+ /**
+ * AdminTreeModel constructor comment.
+ */
+ public AdminTreeModel(String tablename) throws Exception {
+ super(new DefaultMutableTreeNode("dummy"));
+ setTable(tablename);
+ }
+
+ public void setTable(String tablename) throws Exception {
+ this.tablename = tablename;
+ protocol = new StringBuffer();
+ root = new EntryNode();
+ errorNodes.removeAllChildren();
+ initPrototypeEntry();
+ entryNodes = getEntryNodesFromDB();
+
+ insertnodes(root, null);
+ //List entryNodes should be empty
+
+ markRemainingNodesAsErrors();
+ if (errorNodes.getChildCount() > 0)
+ root.add(errorNodes);
+ this.setRoot(root);
+ this.reload();
+ }
+ private java.util.List getEntryNodesFromDB()
+ throws SQLException, CloneNotSupportedException {
+ java.util.List entries = new java.util.LinkedList();
+ EntryNode anEntryNode;
+ Object key, parentKey;
+ ResultSet rs =
+ DBAccess.get("RecursiveTableAdmin").executeQuery(
+ "select * from " + tablename);
+ while (rs.next()) {
+ anEntryNode = (EntryNode) prototypeEntry.clone();
+ anEntryNode.setName(rs.getString("NAME"));
+ key = rs.getObject("KEY");
+ anEntryNode.setKey(key);
+ parentKey = rs.getObject("PARENT");
+ anEntryNode.setParentKey(parentKey);
+ for (Iterator it = anEntryNode.fieldNameIterator();
+ it.hasNext();
+ ) {
+ String fieldname = (String) it.next();
+ anEntryNode.setValue(
+ fieldname,
+ rs.getObject(fieldname.toUpperCase()));
+ }
+ if (key != null && parentKey != null && key.equals(parentKey)) {
+ anEntryNode.setErrorInfo(error1Txt);
+ errorNodes.add(anEntryNode);
+ protocol.append(
+ anEntryNode.getName()
+ + "("
+ + anEntryNode.getKey()
+ + ") - "
+ + error1Txt);
+ } else {
+ entries.add(anEntryNode);
+ }
+ }
+ rs.close();
+ return entries;
+
+ }
+
+ public EntryNode getPrototypeEntry() {
+ return prototypeEntry;
+ }
+ private void initPrototypeEntry() throws Exception {
+ DatabaseMetaData metadata =
+ DBAccess.get("RecursiveTableAdmin").getDatabaseMetaData();
+
+ ResultSet rs = metadata.getColumns(null, null, tablename, null);
+
+ //checking if key,parent and name are contained
+ boolean containsKey = false,
+ containsParent = false,
+ containsName = false;
+ String aFieldname;
+ int aFieldType;
+ Field aField;
+ prototypeEntry = new EntryNode();
+ while (rs.next()) {
+ aFieldname = rs.getObject(4).toString();
+ aFieldType = rs.getInt(5);
+ aField = new Field(aFieldname, aFieldType);
+ if (aFieldname.equalsIgnoreCase("key")) {
+ containsKey = true;
+ prototypeEntry.setKeyfield(aField);
+ } else if (aFieldname.equalsIgnoreCase("name")) {
+ containsName = true;
+ } else if (aFieldname.equalsIgnoreCase("parent")) {
+ containsParent = true;
+ prototypeEntry.setParentfield(aField);
+ } else {
+ prototypeEntry.addField(aField);
+ }
+ }
+ if (containsKey == false
+ || containsParent == false
+ || containsName == false)
+ throw new IllegalArgumentException("table doesn't contain key, parent or name");
+
+ }
+
+ /**
+ * Returns all nodes with the specified parent
+ **/
+ private List getNodesWithParentKey(Object checkparent) {
+ Object parentKey;
+ EntryNode anEntryNode;
+ List result = new LinkedList();
+ //if (checkparent!=null) System.out.println(checkparent.getClass());
+ for (Iterator it = entryNodes.iterator(); it.hasNext();) {
+ anEntryNode = (EntryNode) it.next();
+ parentKey = anEntryNode.getParentKey();
+ if (parentKey == null && checkparent == null)
+ result.add(anEntryNode);
+ if (parentKey != null && checkparent != null)
+ if (parentKey.equals(checkparent))
+ result.add(anEntryNode);
+
+ }
+ return result;
+ }
+ /**
+ * rekursive Methode, die Dimensionen in den Baum einträgt
+ **/
+ private void insertnodes(EntryNode presentNode, Object parentKey)
+ throws IllegalArgumentException {
+ EntryNode newNode;
+ //it is no longer necessary to check if presentNode might be a child
+ //it is used therefore it can be removed from List of entryNodes
+ entryNodes.remove(presentNode);
+ List childrensList = getNodesWithParentKey(parentKey);
+
+ if (parentKey == null && childrensList.size() == 0) {
+ if (isNoMainKeyAcceptable)
+ protocol.append(noMainKey);
+ else
+ throw noMainKeyEx;
+ }
+ Object keyOfNewNode;
+ for (Iterator it = childrensList.iterator(); it.hasNext();) {
+ newNode = (EntryNode) it.next();
+ presentNode.add(newNode);
+ keyOfNewNode = newNode.getKey();
+ //nervig null-Werte abfangen
+ if (keyOfNewNode != null && parentKey == null)
+ insertnodes(newNode, keyOfNewNode);
+ //ich glaub die Fehler können gar nicht auftauchen
+ if (keyOfNewNode == null && parentKey == null) {
+ newNode.setErrorInfo(error1Txt);
+ errorNodes.add(newNode);
+ }
+ if (keyOfNewNode != null && parentKey != null)
+ if (!parentKey.equals(keyOfNewNode))
+ insertnodes(newNode, keyOfNewNode);
+ else {
+ newNode.setErrorInfo(error1Txt);
+ protocol.append(
+ newNode.getName()
+ + "("
+ + newNode.getKey()
+ + ") - "
+ + error1Txt);
+ errorNodes.add(newNode);
+ }
+ }
+
+ }
+ private void markRemainingNodesAsErrors() {
+ String txt = "Dieser Knoten passte nicht in die Struktur";
+ EntryNode fehlernode = null;
+ for (Iterator it = entryNodes.iterator(); it.hasNext();) {
+ fehlernode = (EntryNode) it.next();
+ fehlernode.setErrorInfo(txt);
+ protocol.append(
+ fehlernode.getName()
+ + " (key: "
+ + fehlernode.getKey()
+ + ") - "
+ + txt
+ + "\n");
+ errorNodes.add(fehlernode);
+ }
+ }
+ public String getTablename() {
+ return tablename;
+ }
+ /**
+ * Returns the protocol.
+ * @return StringBuffer
+ */
+ public String getProtocol() {
+ protocol.append("\n");
+ return protocol.toString();
+ }
+ // Creation date: (02.03.2003 13:00:43)
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/DeleteAction.java b/src/de/memtext/tree/admin/DeleteAction.java
new file mode 100644
index 0000000..2e3478a
--- /dev/null
+++ b/src/de/memtext/tree/admin/DeleteAction.java
@@ -0,0 +1,40 @@
+package de.memtext.tree.admin;
+import javax.swing.JOptionPane;
+import javax.swing.tree.MutableTreeNode;
+public class DeleteAction extends EntryNodeAction {
+
+/**
+ * EditAction constructor comment.
+ */
+public DeleteAction(AdminTreeModel model) {
+ super(model);
+}
+/**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ */
+public DeleteAction(String name, AdminTreeModel model) {
+ super(name,model);
+}
+/**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ * @param icon javax.swing.Icon
+ */
+public DeleteAction(
+ String name,
+ javax.swing.Icon icon,
+ AdminTreeModel model) {
+ super(name, icon,model);
+}
+/**
+ * actionPerformed method comment.
+ */
+public void actionPerformed(java.awt.event.ActionEvent arg1) {
+ if (JOptionPane.showConfirmDialog(null,"Wirklich löschen?")==JOptionPane.YES_OPTION)
+ model.removeNodeFromParent((MutableTreeNode)getSelectedNode());
+
+ }
+
+}
+//Creation date: (01.03.2003 14:41:12)
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/EditAction.java b/src/de/memtext/tree/admin/EditAction.java
new file mode 100644
index 0000000..76e68f2
--- /dev/null
+++ b/src/de/memtext/tree/admin/EditAction.java
@@ -0,0 +1,63 @@
+package de.memtext.tree.admin;
+import javax.swing.JFrame;
+
+import de.memtext.tree.SelectedNodeAction;
+/**
+ * Insert the type's description here.
+ * Creation date: (01.03.2003 14:41:12)
+ * @author:
+ */
+
+
+public class EditAction extends SelectedNodeAction {
+private AdminTreeModel model;
+/**
+ * EditAction constructor comment.
+ */
+public EditAction(AdminTreeModel model) {
+ super();
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ super.addAcceptableTreeNodeClass(EntryNode.class);
+}
+/**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ */
+public EditAction(String name, AdminTreeModel model) {
+ super(name);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ super.addAcceptableTreeNodeClass(EntryNode.class);
+}
+/**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ * @param icon javax.swing.Icon
+ */
+public EditAction(
+ String name,
+ javax.swing.Icon icon,
+ AdminTreeModel model) {
+ super(name, icon);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ super.addAcceptableTreeNodeClass(EntryNode.class);
+}
+/**
+ * actionPerformed method comment.
+ */
+public void actionPerformed(java.awt.event.ActionEvent arg1) {
+ if (!(getSelectedNode() instanceof EntryNode)) return;
+ EntryNode node =
+ (EntryNode) getSelectedNode() ;
+ EditDlg dlg=new EditDlg(new JFrame(),node);
+ dlg.show();
+ model.nodeChanged(node); //to inform Status
+
+ }
+
+}
diff --git a/src/de/memtext/tree/admin/EditDlg.java b/src/de/memtext/tree/admin/EditDlg.java
new file mode 100644
index 0000000..7821cec
--- /dev/null
+++ b/src/de/memtext/tree/admin/EditDlg.java
@@ -0,0 +1,98 @@
+package de.memtext.tree.admin;
+
+import java.awt.Frame;
+import java.awt.event.ActionListener;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.SwingConstants;
+
+import de.memtext.dlg.OkCancelDlg;
+import de.memtext.widgets.LabeledTextField;
+import de.memtext.widgets.MultilineEditPanel;
+import de.memtext.widgets.WarningMessage;
+public class EditDlg extends OkCancelDlg {
+
+ private LabeledTextField keyTextField, nameTextField;
+ private EntryNode anEntry;
+ private java.util.List editFields;
+
+ class EditField extends LabeledTextField {
+ private Field f;
+ EditField(Field f) {
+ super(f.getName(), f.getValueString());
+ this.f = f;
+ }
+ void updateField() throws IllegalArgumentException {
+ f.setValue(getValue().toString());
+ }
+ }
+ public EditDlg(Frame f, EntryNode anEntry) {
+ super(f, "Bearbeiten");
+ this.anEntry = anEntry;
+ setCenter(getCenterPanel());
+ this.pack();
+ de.memtext.util.WindowUtils.center(this);
+ }
+
+ private void copyValuesToEntry() throws IllegalArgumentException {
+ anEntry.setName(nameTextField.getValue().toString());
+ anEntry.setKey(keyTextField.getValue());
+ Field f;
+ EditField ef;
+ for (Iterator it = editFields.iterator(); it.hasNext();) {
+ ef = (EditField) it.next();
+ ef.updateField();
+ }
+
+ }
+ private JComponent getCenterPanel() {
+ MultilineEditPanel editp = new MultilineEditPanel();
+ nameTextField = new LabeledTextField("Name: ", anEntry.getName());
+ editp.add(nameTextField);
+ /*editp.add(
+ new JLabel(
+ "key of parent: " + anEntry.getParentKey(),
+ SwingConstants.CENTER));
+ */
+ keyTextField = new LabeledTextField("Key: ", anEntry.getKey(), 12);
+ keyTextField.add(
+ new JLabel(
+ "key of parent: " + anEntry.getParentKey(),
+ SwingConstants.CENTER));
+ editp.add(keyTextField);
+ editFields = new LinkedList();
+ Field f;
+ EditField ef;
+ for (Iterator it = anEntry.fieldIterator(); it.hasNext();) {
+ f = (Field) it.next();
+ ef = new EditField(f);
+ editFields.add(ef);
+ editp.add(ef);
+ }
+ if (anEntry.getErrorInfo() != null) {
+ JLabel lbl =
+ new JLabel(anEntry.getErrorInfo(), SwingConstants.CENTER);
+ editp.add(lbl);
+ }
+ return editp;
+ }
+ protected void performOk() {
+ try {
+ copyValuesToEntry();
+ this.setVisible(false);
+ } catch (IllegalArgumentException e) {
+ new WarningMessage(this, e.toString().substring(35), "Achtung").show();
+
+ }
+
+ }
+ protected void performCancel() {
+
+ this.setVisible(false);
+
+ }
+}
+// Creation date: (28.02.2003 10:40:22)}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/Entry.java b/src/de/memtext/tree/admin/Entry.java
new file mode 100644
index 0000000..699ef4c
--- /dev/null
+++ b/src/de/memtext/tree/admin/Entry.java
@@ -0,0 +1,121 @@
+package de.memtext.tree.admin;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+/**
+ * Insert the type's description here.
+ * Creation date: (28.02.2003 10:31:22)
+ * @author:
+ */
+class Entry implements Cloneable{
+ private boolean debug=false;
+ private Field keyfield, parentfield;
+ private String name;
+ private final Map fields;
+ /**
+ * Entry constructor comment.
+ */
+ public Entry() {
+ fields = new HashMap();
+ }
+
+ public void setKeyfield(Field keyfield)
+ {
+ this.keyfield = keyfield;
+ }
+ public void setParentfield(Field parentfield)
+ {
+ this.parentfield = parentfield;
+ }
+
+
+ public void addField(Field field)
+ {
+ fields.put(field.getName(),field);
+ }
+ public void setValue(String fieldname, Object value) {
+ Field field=(Field)fields.get(fieldname);
+ field.setValue(value);
+ }
+ public Object getValue(Object fieldname) {
+ Field field=(Field)fields.get(fieldname);
+ return field.getValue();
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name=name;
+ }
+
+ public Object getKey() {
+ return keyfield.getValue();
+ }
+
+ public void setKey(Object key) {
+ this.keyfield.setValue(key);
+ }
+ public Object getParent() {
+ return parentfield.getValue();
+ }
+
+ public void setParent(Object parent) {
+ this.parentfield.setValue(parent);
+ }
+ public int getSpecialFieldCount()
+ {
+ return fields.size();
+ }
+ public Iterator fieldNameIterator()
+ {
+ Set fieldkeys=fields.keySet();
+ return fieldkeys.iterator();
+ }
+ public Iterator fieldIterator()
+ {
+ Collection c=fields.values();
+ return c.iterator();
+ }
+ public String toString()
+ {
+ String result=null;
+ if (debug)
+ {
+
+
+ result ="Entry name:"+getName()+" key:"+getKey()+" parent:"+getParent()+" "+fields.size()+" fields:";
+
+ Set fieldkeys=fields.keySet();
+ for (Iterator it=fieldkeys.iterator();it.hasNext();)
+ {
+ String key=(String)it.next();
+ Field f=(Field)fields.get(key);
+ result+=" "+key+" value:"+f.getValue()+" ";
+ }
+ }
+ else
+ result=getName();
+ return result;
+
+ }
+
+ public Object clone() throws CloneNotSupportedException
+ {
+ Entry result=new Entry();
+ result.setKeyfield(new Field(this.keyfield.getName(),this.keyfield.getType()));
+ result.setParentfield(new Field(this.parentfield.getName(),this.parentfield.getType()));
+ result.setName(getName());
+ Set fieldkeys=fields.keySet();
+ for (Iterator it=fieldkeys.iterator();it.hasNext();)
+ {
+ String key=(String)it.next();
+ Field f=(Field)fields.get(key);
+ result.addField((Field)f.clone());
+ }
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/EntryNode.java b/src/de/memtext/tree/admin/EntryNode.java
new file mode 100644
index 0000000..6c55063
--- /dev/null
+++ b/src/de/memtext/tree/admin/EntryNode.java
@@ -0,0 +1,208 @@
+package de.memtext.tree.admin;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+/**
+ * Insert the type's description here.
+ * Creation date: (28.02.2003 10:31:22)
+ * @author:
+ */
+
+class EntryNode
+ extends DefaultMutableTreeNode
+ implements Transferable, Serializable, Cloneable {
+ final public static DataFlavor ENTRY_FLAVOR =
+ new DataFlavor(EntryNode.class, "ENTRY");
+
+ static DataFlavor flavors[] = { ENTRY_FLAVOR };
+
+ private boolean debug = false;
+ private Field keyfield, parentfield;
+ private String name, errorInfo;
+ private final Map fields;
+ /**
+ * Entry constructor comment.
+ */
+ public EntryNode() {
+ fields = new HashMap();
+ }
+
+ public void setKeyfield(Field keyfield) {
+ this.keyfield = keyfield;
+ }
+ public void setParentfield(Field parentfield) {
+ this.parentfield = parentfield;
+ }
+
+ public void addField(Field field) {
+ fields.put(field.getName(), field);
+ }
+ public void setValue(String fieldname, Object value) {
+ Field field = (Field) fields.get(fieldname);
+ field.setValue(value);
+ }
+ public Object getValue(Object fieldname) {
+ Field field = (Field) fields.get(fieldname);
+ return field.getValueString();
+ }
+
+ public String getName() {
+ String result = null;
+ if (name == null)
+ result = "";
+ else
+ result = name;
+ return result;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public Object getKey() {
+ return keyfield.getValue();
+ }
+
+ public void setKey(Object key) {
+ this.keyfield.setValue(key);
+ //must also change direkt children's parentKey entry to match the change
+ Enumeration en = this.children();
+ EntryNode anEntryNode;
+ while (en.hasMoreElements()) {
+ anEntryNode = (EntryNode) en.nextElement();
+ anEntryNode.setParentKey(key);
+ }
+ }
+ public Object getParentKey() {
+ return parentfield.getValue();
+ }
+
+ public void setParentKey(Object parent) {
+ this.parentfield.setValue(parent);
+
+ }
+ public void updateParentKey() {
+ EntryNode parentNode = (EntryNode) this.getParent();
+ this.setParentKey(parentNode.getKey());
+ }
+ public int getSpecialFieldCount() {
+ return fields.size();
+ }
+ public Iterator fieldNameIterator() {
+ Set fieldkeys = fields.keySet();
+ return fieldkeys.iterator();
+ }
+ public Iterator fieldIterator() {
+ Collection c = fields.values();
+ return c.iterator();
+ }
+
+ public void setErrorInfo(String errorInfo) {
+ this.errorInfo = errorInfo;
+ }
+ public String getErrorInfo() {
+ return errorInfo;
+ }
+ public String toString() {
+ String result = null;
+ if (debug) {
+
+ result =
+ "Entry name:"
+ + getName()
+ + " key:"
+ + getKey()
+ + " parent:"
+ + getParentKey()
+ + " "
+ + fields.size()
+ + " fields:";
+
+ Set fieldkeys = fields.keySet();
+ for (Iterator it = fieldkeys.iterator(); it.hasNext();) {
+ String key = (String) it.next();
+ Field f = (Field) fields.get(key);
+ result += " " + key + " value:" + f.getValueString() + " ";
+ }
+ } else
+ result = getName();
+ return result;
+
+ }
+ public String getInsertCommand(String tablename) {
+ StringBuffer header =
+ new StringBuffer("insert into " + tablename + "(key,parent,name,");
+ System.out.println(name);
+ StringBuffer values = new StringBuffer(" values(");
+ values.append(
+ keyfield.getInsertCommandValue()
+ + ","
+ + parentfield.getInsertCommandValue()
+ + ",'"
+ + getName()
+ + "',");
+
+ for (Iterator it = fieldIterator(); it.hasNext();) {
+
+ Field f = (Field) it.next();
+ header.append(f.getName() + ",");
+ values.append(f.getInsertCommandValue() + ",");
+ }
+ //delete last comma
+ header.deleteCharAt(header.length() - 1);
+ header.append(") ");
+ values.deleteCharAt(values.length() - 1);
+ values.append(") ");
+
+ return header.toString() + values.toString();
+
+ }
+
+ public Object clone() {
+ EntryNode result = null;
+ try {
+ result = new EntryNode();
+ result.setKeyfield(new Field(this.keyfield.getName(), this.keyfield.getType()));
+ result.setParentfield(
+ new Field(this.parentfield.getName(), this.parentfield.getType()));
+ result.setName(getName());
+ Set fieldkeys = fields.keySet();
+ for (Iterator it = fieldkeys.iterator(); it.hasNext();) {
+ String key = (String) it.next();
+ Field f = (Field) fields.get(key);
+ result.addField((Field) f.clone());
+ }
+
+ } catch (CloneNotSupportedException e) {
+ System.out.println(e.toString());
+ System.exit(-1);
+ }
+ return result;
+ }
+ // --------- Transferable --------------
+
+ public boolean isDataFlavorSupported(DataFlavor df) {
+ return df.equals(ENTRY_FLAVOR);
+ }
+ public Object getTransferData(DataFlavor df)
+ throws UnsupportedFlavorException, IOException {
+ if (df.equals(ENTRY_FLAVOR)) {
+ return this;
+ } else
+ throw new UnsupportedFlavorException(df);
+ }
+ public DataFlavor[] getTransferDataFlavors() {
+ return flavors;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/EntryNodeAction.java b/src/de/memtext/tree/admin/EntryNodeAction.java
new file mode 100644
index 0000000..dc6c007
--- /dev/null
+++ b/src/de/memtext/tree/admin/EntryNodeAction.java
@@ -0,0 +1,41 @@
+package de.memtext.tree.admin;
+
+import de.memtext.tree.SelectedNodeAction;
+
+/**
+ * @author MB
+ *
+ * To change this generated comment edit the template variable "typecomment":
+ * Window>Preferences>Java>Templates.
+ * To enable and disable the creation of type comments go to
+ * Window>Preferences>Java>Code Generation.
+ */
+public abstract class EntryNodeAction extends SelectedNodeAction //implements Observer
+{
+ AdminTreeModel model;
+ private boolean isSaveNecessary;
+ /**
+ * EditAction constructor comment.
+ */
+ public EntryNodeAction(AdminTreeModel model) {
+ this(null,null,model);
+ }
+ public EntryNodeAction(String name, AdminTreeModel model) {
+ this(name,null,model);
+ }
+ /**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ * @param icon javax.swing.Icon
+ */
+ public EntryNodeAction(String name, javax.swing.Icon icon, AdminTreeModel model) {
+ super(name, icon);
+if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ isSaveNecessary=false;
+ super.addAcceptableTreeNodeClass(EntryNode.class);
+ }
+
+ public abstract void actionPerformed(java.awt.event.ActionEvent e) ;
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/ExitAction.java b/src/de/memtext/tree/admin/ExitAction.java
new file mode 100644
index 0000000..7b8fc3b
--- /dev/null
+++ b/src/de/memtext/tree/admin/ExitAction.java
@@ -0,0 +1,77 @@
+package de.memtext.tree.admin;
+import java.util.Observable;
+import java.util.Observer;
+
+import javax.swing.AbstractAction;
+import javax.swing.JOptionPane;
+
+import de.memtext.db.DBAccess;
+/**
+ * Insert the type's description here.
+ * Creation date: (01.03.2003 14:41:12)
+ * @author:
+ */
+
+public class ExitAction extends AbstractAction implements Observer {
+ private AdminTreeModel model;
+ private boolean isSaveNecessary;
+ /**
+ * EditAction constructor comment.
+ */
+ public ExitAction(AdminTreeModel model) {
+ super();
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ isSaveNecessary=false;
+ }
+ /**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ */
+ public ExitAction(String name, AdminTreeModel model) {
+ super(name);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ isSaveNecessary=false;
+ }
+ /**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ * @param icon javax.swing.Icon
+ */
+ public ExitAction(String name, javax.swing.Icon icon, AdminTreeModel model) {
+ super(name, icon);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ isSaveNecessary=false;
+ }
+ /**
+ * actionPerformed method comment.
+ */
+ public void actionPerformed(java.awt.event.ActionEvent arg1) {
+ if ( isSaveNecessary)
+ {
+ int result= JOptionPane.showConfirmDialog(null,
+ "Änderungen sind noch nicht gespeichert. Wirklich beenden?","Frage", JOptionPane.YES_NO_OPTION);
+if (result==JOptionPane.NO_OPTION) return;
+ }
+
+ DBAccess.get("RecursiveTableAdmin").closeConnection();
+ System.exit(-1);
+ }
+/**
+ nur zu Übungszwecken, könne eigentlich auch auf eigenes Feld
+ isSaveNecessary verzichten und in actionPerformed Status.getInstance().isSaveNecessary() abfragen
+ */
+public void update(Observable o, Object arg)
+{
+ if (o instanceof Status)
+ {
+ isSaveNecessary=((Status)o).isSaveNecessary();
+ }
+}
+
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/Field.java b/src/de/memtext/tree/admin/Field.java
new file mode 100644
index 0000000..6ef37ae
--- /dev/null
+++ b/src/de/memtext/tree/admin/Field.java
@@ -0,0 +1,163 @@
+package de.memtext.tree.admin;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+public class Field implements Cloneable, Serializable {
+ private String name;
+ private Object value;
+ private int type;
+
+ public Field(String name, int type) {
+ if (name == null)
+ throw new NullPointerException("Field name must not be null");
+ setName(name);
+ setType(type);
+ }
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ if (name == null)
+ throw new NullPointerException("Field name must not be null");
+ this.name = name;
+ }
+
+ public int getType() {
+ return type;
+ }
+
+ public void setType(int type) {
+ this.type = type;
+ }
+ public String getValueString() {
+
+ String result;
+ if (value == null)
+ result = "";
+ else
+ result = value.toString();
+ //bei Date in German locale umwandeln
+ if (value != null && getType() == java.sql.Types.DATE) {
+ result = de.memtext.util.DateUtils.format((java.sql.Date)value);
+ }
+ return result;
+ }
+
+ public Object getValue() {
+ return value;
+ }
+ public void setValue(Object value) throws IllegalArgumentException {
+ if (value == null)
+ this.value = null;
+ else
+ switch (getType()) {
+ case java.sql.Types.TINYINT :
+ case java.sql.Types.SMALLINT :
+ case java.sql.Types.INTEGER :
+ case java.sql.Types.NUMERIC :
+ try {
+ this.value = new BigInteger(value.toString());
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(value + " not OK for field: " + getName());
+ }
+ break;
+ case java.sql.Types.DECIMAL :
+ case java.sql.Types.DOUBLE :
+ case java.sql.Types.FLOAT :
+ case java.sql.Types.REAL :
+ try {
+ this.value = new BigDecimal(value.toString());
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(value + " not OK for field: " + getName());
+ }
+ break;
+ case java.sql.Types.CHAR :
+ case java.sql.Types.VARCHAR :
+ case java.sql.Types.LONGVARCHAR :
+ this.value = value.toString();
+ break;
+ case java.sql.Types.DATE :
+ if (value instanceof java.util.Date)
+ this.value = value;
+ else
+ try {
+
+ this.value = de.memtext.util.DateUtils.parse(value.toString());
+ } catch (java.text.ParseException e) {
+ throw new IllegalArgumentException(value + " not OK for field: " + getName());
+ }
+ break;
+ default :
+ throw new RuntimeException("SQL-Type " + getType() + " not supported!");
+ }
+
+ }
+ public boolean isStringType() {
+ boolean result = false;
+ switch (getType()) {
+ case java.sql.Types.CHAR :
+ case java.sql.Types.VARCHAR :
+ case java.sql.Types.LONGVARCHAR :
+ result = true;
+ break;
+ default :
+
+ }
+ return result;
+ }
+
+ public Object clone() throws CloneNotSupportedException {
+
+ Field result = (Field) super.clone();
+ result.setName(this.getName());
+ result.setType(this.getType());
+ Object value = this.getValue();
+ Object newval = null;
+ if (value != null) {
+ if (value instanceof String)
+ newval = new String(value.toString());
+ if (value instanceof BigInteger)
+ newval = new BigInteger(value.toString());
+ if (value instanceof BigDecimal)
+ newval = new BigDecimal(value.toString());
+ if (value instanceof java.util.Date)
+ newval = ((java.util.Date) value).clone();
+ if (newval == null) //new val should have been set by now
+ throw new CloneNotSupportedException("can't clone datatype" + value.getClass());
+ }
+ result.setValue(newval);
+
+ return result;
+ }
+ public String toString() {
+ return "Field name:"
+ + getName()
+ + " type:"
+ + getType()
+ + " value:"
+ + getValueString();
+ }
+ public String getInsertCommandValue()
+ {
+ StringBuffer result=new StringBuffer();
+ if (getValue()==null)
+ {
+ result.append("null");
+ }
+ else
+ {
+ if (getType()!=java.sql.Types.DATE)
+ {
+ if (isStringType()) result.append("'");
+ result.append(getValueString());
+ if (isStringType()) result.append("'");
+ }
+ else
+ {
+ result.append(de.memtext.util.HsqlUtils.getDateForHsql((java.util.Date)getValue()));
+ }
+ }
+ return result.toString();
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/RecursiveTableAdmin.java b/src/de/memtext/tree/admin/RecursiveTableAdmin.java
new file mode 100644
index 0000000..90e252f
--- /dev/null
+++ b/src/de/memtext/tree/admin/RecursiveTableAdmin.java
@@ -0,0 +1,143 @@
+package de.memtext.tree.admin;
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.sql.Connection;
+import java.sql.Statement;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import de.memtext.db.ConnectionCreator;
+import de.memtext.db.DBAccess;
+import de.memtext.tree.MBTreeSelectionListener;
+import de.memtext.widgets.InfoMessage;
+import de.memtext.widgets.MBFrame;
+import de.memtext.widgets.WarningMessage;
+
+public class RecursiveTableAdmin extends MBFrame {
+ /**
+ * Tester constructor comment.
+ */
+ private Connection con;
+ private Statement stmt;
+ private JTree selectionTree;
+ private RecursiveTableAdminPanel adm;
+ private static String table,keycolname,parentcolname;
+ public static void main(String[] arg) {
+ if (arg.length < 1 || arg.length>4) {
+ System.out.println("RecursiveTableAdmin propfilename [table] [keycolumn name] [parent column name]");
+ System.exit(0);
+
+ }
+ try
+ {
+ Connection con=ConnectionCreator.getConnectionCryptPassword(arg[0],"driverName","connectionURL","connectionName","connectionPassword");
+ DBAccess.addConnection("RecursiveTableAdmin",con);
+ }
+ catch (Exception e)
+ {
+ WarningMessage.show(null,"Verbindung konnte nicht aufgebaut werden.\n"+e,"Achtung");
+ e.printStackTrace();
+ System.exit(-1);
+ }
+ if (arg.length>1)
+ { table=arg[1];
+ keycolname=arg[2];
+ parentcolname=arg[3];
+ }
+ InfoMessage.show(null,"Änderungen werden erst in die Datenbank gespielt, wenn man Save aufruft.\nBisher können keine null-Werte eingefügt werden - immer Leerstring!","Hinweis");
+ RecursiveTableAdmin admin=new RecursiveTableAdmin();
+ admin.setSize(900, 500);
+ de.memtext.util.WindowUtils.center(admin);
+ admin.show();
+ }
+ public RecursiveTableAdmin() {
+ super("RecursiveTableAdmin");
+ de.memtext.util.PlafUtils.setWindowsLook(this);
+ Status.getInstance().setFrame(this);
+ Container cp = this.getContentPane();
+ Collection tables=null;
+ if (table==null)
+ tables = getRecursiveTables();
+ else
+ {tables=new LinkedList();
+ tables.add(table);
+ }
+ selectionTree = getSelectionTree(tables);
+
+ selectionTree.setSelectionRow(1);
+ adm = new RecursiveTableAdminPanel(tables.toArray()[0].toString());
+ selectionTree.addTreeSelectionListener(
+ new RecursiveTableTreeSelectionListener());
+ JSplitPane splitp =
+ new JSplitPane(
+ JSplitPane.HORIZONTAL_SPLIT,
+ new JScrollPane(selectionTree),
+ adm);
+ cp.add(splitp, BorderLayout.CENTER);
+ this.setJMenuBar(adm.getAMenuBar());
+ //this.setToolBar(adm.getToolBar());
+
+
+ }
+
+
+
+
+ /**
+ * Method getSelectionTree.
+ * @param tableList
+ * @return JTree
+ */
+ private JTree getSelectionTree(Collection tableList) {
+ DefaultMutableTreeNode root =
+ new DefaultMutableTreeNode("rekursive Tables");
+ for (Iterator it = tableList.iterator(); it.hasNext();) {
+ String tableName = (String) it.next();
+ root.add(new DefaultMutableTreeNode(tableName));
+ }
+ return new JTree(root);
+ }
+
+ /**
+ * Method getRecursiveTables.
+ * @return List with all table that have a key and a parent column
+ */
+ private Collection getRecursiveTables() {
+Set result=new TreeSet();
+ result.addAll(DBAccess.get("RecursiveTableAdmin").getTableList());
+ List removeList = new LinkedList();
+ for (Iterator it = result.iterator(); it.hasNext();) {
+ String aTablename = (String) it.next();
+ if (!DBAccess.get("RecursiveTableAdmin").hasColumn(aTablename, "key")
+ || !DBAccess.get("RecursiveTableAdmin").hasColumn(aTablename, "parent")
+ || !DBAccess.get("RecursiveTableAdmin").hasColumn(aTablename, "name")
+ )
+ removeList.add(aTablename);
+ }
+ result.removeAll(removeList);
+ return result;
+ }
+ protected void doBeforeExit() {
+ DBAccess.get("RecursiveTableAdmin").closeConnection();
+ }
+
+ class RecursiveTableTreeSelectionListener extends MBTreeSelectionListener {
+
+ public void selectionChanged() {
+ String tablename = null;
+ if (getSelectedNode() != null)
+ tablename = getSelectedNode().toString();
+ adm.setTable(tablename);
+ }
+ }
+}
+//* Creation date: (28.02.2003 10:41:03)
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/RecursiveTableAdminPanel.java b/src/de/memtext/tree/admin/RecursiveTableAdminPanel.java
new file mode 100644
index 0000000..45f8dee
--- /dev/null
+++ b/src/de/memtext/tree/admin/RecursiveTableAdminPanel.java
@@ -0,0 +1,146 @@
+package de.memtext.tree.admin;
+import java.awt.BorderLayout;
+
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.JToolBar;
+
+import de.memtext.db.DBAccess;
+import de.memtext.widgets.LogPanel;
+import de.memtext.widgets.TitlePanel;
+import de.memtext.widgets.WarningMessage;
+/**
+ * Insert the type's description here.
+ * Creation date: (28.02.2003 10:41:03)
+ * @author:
+ */
+public class RecursiveTableAdminPanel extends JPanel {
+ /**
+ * Tester constructor comment.
+ */
+ private AdminTreeModel model;
+ private AdminTree tree;
+ private EditAction editAction;
+ private DeleteAction deleteAction;
+ private AddSubNodeAction addSubNodeAction;
+ private AddTopLevelNodeAction addTopLevelNodeAction;
+ private SaveAction saveAction;
+ private ExitAction exitAction;
+ private final TitlePanel titlePanel = new TitlePanel();
+ private final LogPanel logPanel=new LogPanel();
+ public RecursiveTableAdminPanel(String tablename) {
+ super(new BorderLayout());
+ this.add(titlePanel, BorderLayout.NORTH);
+ this.add(logPanel,BorderLayout.SOUTH);
+ titlePanel.setTitleText(tablename);
+
+ try {
+ model = new AdminTreeModel(tablename);
+ if (!model.getProtocol().equals("")) logPanel.log(model.getProtocol());
+ } catch (Exception e) {
+ closeWithWarning(e);
+ }
+ saveAction = new SaveAction("Save", model);
+ exitAction = new ExitAction("Exit", model);
+ Status.getInstance().addObserver(exitAction);
+ addTopLevelNodeAction =
+ new AddTopLevelNodeAction("Add Top Level Node", model);
+ editAction = new EditAction("Edit Node", model);
+ deleteAction = new DeleteAction("Delete Node", model);
+
+ addSubNodeAction = new AddSubNodeAction("Add Subnode", model);
+ tree = new AdminTree(model, getPopupMenu());
+
+ model.addTreeModelListener(tree);
+ model.addTreeModelListener(Status.getInstance());
+ tree.addTreeSelectionListener(editAction);
+ tree.addTreeSelectionListener(addSubNodeAction);
+ tree.addTreeSelectionListener(deleteAction);
+
+ titlePanel.add(getToolBar());
+ this.add(new JScrollPane(tree), BorderLayout.CENTER);
+ // this.add(tree, BorderLayout.CENTER);
+ }
+ private void closeWithWarning(Exception e) {
+ WarningMessage msg = new WarningMessage(this,"Fehler: " + e);
+ msg.show();
+ e.printStackTrace();
+ DBAccess.get("RecursiveTableAdmin").closeConnection();
+ System.exit(-1);
+ }
+ public void setTable(String tablename) {
+ try {
+ logPanel.logln("Changing to table: "+tablename);
+ titlePanel.setTitleText(tablename);
+ model.setTable(tablename);
+ if (!model.getProtocol().equals("")) logPanel.log(model.getProtocol());
+ } catch (Exception e) {
+ closeWithWarning(e);
+ }
+ }
+ private JPopupMenu getPopupMenu() {
+ JPopupMenu popmenu = new JPopupMenu();
+ popmenu.add(addSubNodeAction);
+ popmenu.add(editAction);
+ popmenu.add(deleteAction);
+ return popmenu;
+ }
+
+ public JToolBar getToolBar() {
+ JToolBar toolbar = new JToolBar();
+ toolbar.add(addTopLevelNodeAction);
+ toolbar.add(addSubNodeAction);
+ toolbar.add(editAction);
+ toolbar.add(deleteAction);
+ return toolbar;
+
+ }
+ public JMenuBar getAMenuBar() {
+ JMenuBar bar = new JMenuBar();
+ JMenu m1 = new JMenu("Program");
+ m1.add(saveAction);
+ m1.add(exitAction);
+ bar.add(m1);
+ JMenu medit = new JMenu("Edit");
+ medit.add(addTopLevelNodeAction);
+ medit.add(addSubNodeAction);
+ medit.add(editAction);
+ medit.add(deleteAction);
+ bar.add(medit);
+ return bar;
+ }
+
+ private void end() {
+ DBAccess.get("RecursiveTableAdmin").closeConnection();
+ System.exit(-1);
+ }
+ /* private JTree createTree(String tablename) throws Exception {
+
+ DatabaseMetaData metadata = con.getMetaData();
+ ResultSet rs = metadata.getColumns(null, null, tablename, null);
+ ResultSetMetaData rsmd = rs.getMetaData();
+ int numberOfColumns = rsmd.getColumnCount();
+
+ Object o;
+ while (rs.next()) {
+ for (int i = 1; i <= numberOfColumns; i++) {
+ o = rs.getObject(i);
+ System.out.println(o);
+ }
+ }
+ ResultSet rs2 = stmt.executeQuery("select * from " + tablename);
+ ResultSetMetaData rsmd2 = rs2.getMetaData();
+ numberOfColumns = rsmd2.getColumnCount();
+
+ while (rs2.next()) {
+ for (int i = 1; i <= numberOfColumns; i++) {
+ o = rs2.getObject(i);
+ }
+ }
+ return null;
+ }
+ */
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/SaveAction.java b/src/de/memtext/tree/admin/SaveAction.java
new file mode 100644
index 0000000..e137fb0
--- /dev/null
+++ b/src/de/memtext/tree/admin/SaveAction.java
@@ -0,0 +1,68 @@
+package de.memtext.tree.admin;
+import java.util.Enumeration;
+
+import javax.swing.AbstractAction;
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import de.memtext.db.DBAccess;
+/**
+ * Insert the type's description here.
+ * Creation date: (01.03.2003 14:41:12)
+ * @author:
+ */
+
+public class SaveAction extends AbstractAction {
+ private AdminTreeModel model;
+ /**
+ * EditAction constructor comment.
+ */
+ public SaveAction(AdminTreeModel model) {
+ super();
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ }
+ /**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ */
+ public SaveAction(String name, AdminTreeModel model) {
+ super(name);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ }
+ /**
+ * EditAction constructor comment.
+ * @param name java.lang.String
+ * @param icon javax.swing.Icon
+ */
+ public SaveAction(String name, javax.swing.Icon icon, AdminTreeModel model) {
+ super(name, icon);
+ if (model == null)
+ throw new RuntimeException("Model must not be null!");
+ this.model = model;
+ }
+ /**
+ * actionPerformed method comment.
+ */
+ public void actionPerformed(java.awt.event.ActionEvent arg1) {
+ Status.getInstance().setBusy();
+ DBAccess.get("RecursiveTableAdmin").execute("delete from " + model.getTablename() + " where 1=1");
+ DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
+ Object node = null;
+ EntryNode entryNode;
+ for (Enumeration en = root.depthFirstEnumeration(); en.hasMoreElements();) {
+ node = en.nextElement();
+ if (!(node instanceof EntryNode))
+ continue;
+ entryNode = (EntryNode) node;
+ if (entryNode.isRoot()) continue;
+ DBAccess.get("RecursiveTableAdmin").execute(entryNode.getInsertCommand(model.getTablename()));
+
+
+ }
+ Status.getInstance().setIdle();
+ Status.getInstance().setSaveNecessary(false);
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/Status.java b/src/de/memtext/tree/admin/Status.java
new file mode 100644
index 0000000..3377313
--- /dev/null
+++ b/src/de/memtext/tree/admin/Status.java
@@ -0,0 +1,64 @@
+package de.memtext.tree.admin;
+import java.util.Observable;
+
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+/**
+ * Insert the type's description here.
+ * Creation date: (05.03.2003 12:47:43)
+ * @author:
+ */
+public class Status extends Observable implements TreeModelListener {
+
+ final static private Status INSTANCE = new Status();
+ private boolean _isSaveNecessary;
+ private java.awt.Frame frame;
+ private Status() {
+ }
+ public static Status getInstance() {
+ return INSTANCE;
+ }
+
+ public void setSaveNecessary(boolean isSaveNecessary) {
+ if (_isSaveNecessary!=isSaveNecessary)
+ {
+ _isSaveNecessary = isSaveNecessary ;
+ setChanged();
+ notifyObservers();
+ }
+ }
+
+ public void setBusy()
+ {
+ if (frame==null) throw new NullPointerException("Frame in Status is still null!");
+ de.memtext.util.WindowUtils.setWaitCursor(frame,true);
+ }
+ public void setIdle()
+ {
+ if (frame==null) throw new NullPointerException("Frame in Status is still null!");
+ de.memtext.util.WindowUtils.setWaitCursor(frame,false);
+ }
+
+
+ public boolean isSaveNecessary() {
+ return _isSaveNecessary;
+ }
+ public void treeNodesChanged(TreeModelEvent e) {
+ setSaveNecessary(true);
+ }
+ public void treeNodesInserted(TreeModelEvent e) {
+ setSaveNecessary(true);
+ }
+ public void treeNodesRemoved(TreeModelEvent e) {
+ setSaveNecessary(true);
+ }
+ public void treeStructureChanged(TreeModelEvent e) {
+ setSaveNecessary(true);
+ }
+
+
+ public void setFrame(java.awt.Frame f)
+ {
+ this.frame=f;
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/StoredProcedures.java b/src/de/memtext/tree/admin/StoredProcedures.java
new file mode 100644
index 0000000..0640677
--- /dev/null
+++ b/src/de/memtext/tree/admin/StoredProcedures.java
@@ -0,0 +1,46 @@
+package de.memtext.tree.admin;
+import java.sql.ResultSet;
+import java.sql.Statement;
+public class StoredProcedures
+{
+
+ public static Integer get1()
+ {
+ return new Integer(1);
+
+ }
+ public static void fillTmpOrganigramm(java.sql.Connection con,Integer userid)
+ {
+ try{
+ Statement stmt=con.createStatement();
+try{
+ stmt.execute("create temp table tmp_bluep_org_einheit(key varchar,parent varchar, name varchar)");
+ }
+ catch (Exception e)
+ {
+ //Tabelle gabs schon
+ stmt.execute("delete from tmp_bluep_org_einheit");
+
+ }
+ ResultSet rs=stmt.executeQuery("select institution from user_institution where userid="+userid);
+ Object anInst;
+ while (rs.next())
+ {
+ anInst=rs.getObject(1);
+ if (anInst.equals("-1"))
+ {
+ stmt.execute("insert into tmp_bluep_org_einheit select key,parent, name from bluep_organigramm where 1=1");
+ }
+ else
+ {
+ stmt.execute("insert into tmp_bluep_org_einheit select key,parent, name from bluep_organigramm where key='"+anInst+"'");
+}
+ }
+ stmt.close();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+}
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/tree/admin/TableChooser.java b/src/de/memtext/tree/admin/TableChooser.java
new file mode 100644
index 0000000..c8194f4
--- /dev/null
+++ b/src/de/memtext/tree/admin/TableChooser.java
@@ -0,0 +1,37 @@
+package de.memtext.tree.admin;
+import javax.swing.JOptionPane;
+
+import de.memtext.db.DBAccess;
+/**
+ * Insert the type's description here.
+ * Creation date: (05.03.2003 21:14:42)
+ * @author:
+ */
+public class TableChooser {
+private Object[] tables;
+private final String PREFIX="DIM_";
+ /**
+ * TableChooser constructor comment.
+ */
+private String selectedValue ;
+public TableChooser() {
+ super();
+ tables=DBAccess.get("RecursiveTableAdmin").getTablesStartingWith(PREFIX);
+}
+
+public void show()
+{
+ Object selectedValue = JOptionPane.showInputDialog(null,
+"Bitte Tabelle auswählen", "Input",
+JOptionPane.QUESTION_MESSAGE, null,
+tables, tables[0]);
+if (selectedValue==null)
+ this.selectedValue=null;
+ else
+ this.selectedValue=selectedValue.toString();
+}
+public String getSelectedValue()
+{
+ return selectedValue;
+}
+}
diff --git a/src/de/memtext/tree/admin/TreeTransferable.java b/src/de/memtext/tree/admin/TreeTransferable.java
new file mode 100644
index 0000000..d996d0e
--- /dev/null
+++ b/src/de/memtext/tree/admin/TreeTransferable.java
@@ -0,0 +1,64 @@
+package de.memtext.tree.admin;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.UnsupportedFlavorException;
+
+import javax.swing.tree.TreeNode;
+
+/**
+ * Insert the type's description here.
+ * Creation date: (04.03.2003 11:40:40)
+ * @author:
+ */
+public class TreeTransferable implements java.awt.datatransfer.Transferable, java.io.Serializable {
+
+
+final public static DataFlavor TREETRANSFERABLE_FLAVOR =
+ new DataFlavor(TreeTransferable.class, "TreeTransferable");
+
+ static DataFlavor flavors[] = { TREETRANSFERABLE_FLAVOR };
+
+
+private TreeNode node;
+
+
+public TreeTransferable(TreeNode node)
+{
+ this.node=node;
+}
+ /**
+ * Returns an object which represents the data to be transferred. The class
+ * of the object returned is defined by the representation class of the flavor.
+ *
+ * @param flavor the requested flavor for the data
+ * @see DataFlavor#getRepresentationClass
+ * @exception IOException if the data is no longer available
+ * in the requested flavor.
+ * @exception UnsupportedFlavorException if the requested data flavor is
+ * not supported.
+ */
+public Object getTransferData(java.awt.datatransfer.DataFlavor df) throws java.io.IOException, java.awt.datatransfer.UnsupportedFlavorException {
+ if (df.equals(TREETRANSFERABLE_FLAVOR)) {
+ return node;
+ } else
+ throw new UnsupportedFlavorException(df);
+
+}
+ /**
+ * Returns an array of DataFlavor objects indicating the flavors the data
+ * can be provided in. The array should be ordered according to preference
+ * for providing the data (from most richly descriptive to least descriptive).
+ * @return an array of data flavors in which this data can be transferred
+ */
+public java.awt.datatransfer.DataFlavor[] getTransferDataFlavors() {
+ return flavors;
+}
+ /**
+ * Returns whether or not the specified data flavor is supported for
+ * this object.
+ * @param flavor the requested flavor for the data
+ * @return boolean indicating wjether or not the data flavor is supported
+ */
+public boolean isDataFlavorSupported(java.awt.datatransfer.DataFlavor df) {
+ return df.equals(TREETRANSFERABLE_FLAVOR);
+}
+}
diff --git a/src/de/memtext/util/AppletUtils.java b/src/de/memtext/util/AppletUtils.java
new file mode 100644
index 0000000..c1e108d
--- /dev/null
+++ b/src/de/memtext/util/AppletUtils.java
@@ -0,0 +1,39 @@
+package de.memtext.util;
+
+import java.applet.Applet;
+
+/**
+ *
+ * @author MB
+ * */
+public class AppletUtils {
+
+ /**
+ *
+ */
+ private AppletUtils() {
+
+ }
+ /*the docBase shouldn't contain the html file that holds the applet
+ some browsers don't behave accordingly, trying to correct that here*/
+ public static String getCorrectDocBase(Applet applet) {
+ String docBase = applet.getDocumentBase().toString();
+ if (docBase.indexOf(".htm") > 0 || docBase.indexOf(".jsp") > 0) {
+ int posSeparator = docBase.lastIndexOf("/");
+ //System.out.print("correcting docbase: shouldn't be "+docBase);
+ docBase = docBase.substring(0, posSeparator + 1);
+ //System.out.println(" but "+docBase);
+ }
+ if (!docBase
+ .substring(docBase.length() - 1, docBase.length())
+ .equals("/")) {
+ System.out.println(
+ "docBase doesn't end with /, "
+ + docBase
+ + " trying to correct it by clipping");
+ int posSeparator = docBase.lastIndexOf("/");
+ docBase = docBase.substring(0, posSeparator + 1);
+ }
+ return docBase;
+ }
+}
diff --git a/src/de/memtext/util/BrowserLauncher.java b/src/de/memtext/util/BrowserLauncher.java
new file mode 100644
index 0000000..578d7fe
--- /dev/null
+++ b/src/de/memtext/util/BrowserLauncher.java
@@ -0,0 +1,582 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * BrowserLauncher is a class that provides one static method, openURL, which opens the default
+ * web browser for the current user of the system to the given URL. It may support other
+ * protocols depending on the system -- mailto, ftp, etc. -- but that has not been rigorously
+ * tested and is not guaranteed to work.
+ *
+ * Yes, this is platform-specific code, and yes, it may rely on classes on certain platforms
+ * that are not part of the standard JDK. What we're trying to do, though, is to take something
+ * that's frequently desirable but inherently platform-specific -- opening a default browser --
+ * and allow programmers (you, for example) to do so without worrying about dropping into native
+ * code or doing anything else similarly evil.
+ *
+ * Anyway, this code is completely in Java and will run on all JDK 1.1-compliant systems without
+ * modification or a need for additional libraries. All classes that are required on certain
+ * platforms to allow this to run are dynamically loaded at runtime via reflection and, if not
+ * found, will not cause this to do anything other than returning an error when opening the
+ * browser.
+ *
+ * There are certain system requirements for this class, as it's running through Runtime.exec(),
+ * which is Java's way of making a native system call. Currently, this requires that a Macintosh
+ * have a Finder which supports the GURL event, which is true for Mac OS 8.0 and 8.1 systems that
+ * have the Internet Scripting AppleScript dictionary installed in the Scripting Additions folder
+ * in the Extensions folder (which is installed by default as far as I know under Mac OS 8.0 and
+ * 8.1), and for all Mac OS 8.5 and later systems. On Windows, it only runs under Win32 systems
+ * (Windows 95, 98, and NT 4.0, as well as later versions of all). On other systems, this drops
+ * back from the inherently platform-sensitive concept of a default browser and simply attempts
+ * to launch Netscape via a shell command.
+ *
+ * This code is Copyright 1999-2001 by Eric Albert (ejalbert@cs.stanford.edu) and may be
+ * redistributed or modified in any form without restrictions as long as the portion of this
+ * comment from this paragraph through the end of the comment is not removed. The author
+ * requests that he be notified of any application, applet, or other binary that makes use of
+ * this code, but that's more out of curiosity than anything and is not required. This software
+ * includes no warranty. The author is not repsonsible for any loss of data or functionality
+ * or any adverse or unexpected effects of using this software.
+ *
+ * Credits:
+ *
Steven Spencer, JavaWorld magazine (Java Tip 66)
+ *
Thanks also to Ron B. Yeh, Eric Shapiro, Ben Engber, Paul Teitlebaum, Andrea Cantatore,
+ * Larry Barowski, Trevor Bedzek, Frank Miedrich, and Ron Rabakukk
+ *
+ * @author Eric Albert (ejalbert@cs.stanford.edu)
+ * @version 1.4b1 (Released June 20, 2001)
+ */
+public class BrowserLauncher {
+
+ /**
+ * The Java virtual machine that we are running on. Actually, in most cases we only care
+ * about the operating system, but some operating systems require us to switch on the VM. */
+ private static int jvm;
+
+ /** The browser for the system */
+ private static Object browser;
+
+ /**
+ * Caches whether any classes, methods, and fields that are not part of the JDK and need to
+ * be dynamically loaded at runtime loaded successfully.
+ *
+ * Note that if this is false, openURL() will always return an
+ * IOException.
+ */
+ private static boolean loadedWithoutErrors;
+
+ /** The com.apple.mrj.MRJFileUtils class */
+ private static Class mrjFileUtilsClass;
+
+ /** The com.apple.mrj.MRJOSType class */
+ private static Class mrjOSTypeClass;
+
+ /** The com.apple.MacOS.AEDesc class */
+ private static Class aeDescClass;
+
+ /** The (int) method of com.apple.MacOS.AETarget */
+ private static Constructor aeTargetConstructor;
+
+ /** The (int, int, int) method of com.apple.MacOS.AppleEvent */
+ private static Constructor appleEventConstructor;
+
+ /** The (String) method of com.apple.MacOS.AEDesc */
+ private static Constructor aeDescConstructor;
+
+ /** The findFolder method of com.apple.mrj.MRJFileUtils */
+ private static Method findFolder;
+
+ /** The getFileCreator method of com.apple.mrj.MRJFileUtils */
+ private static Method getFileCreator;
+
+ /** The getFileType method of com.apple.mrj.MRJFileUtils */
+ private static Method getFileType;
+
+ /** The openURL method of com.apple.mrj.MRJFileUtils */
+ private static Method openURL;
+
+ /** The makeOSType method of com.apple.MacOS.OSUtils */
+ private static Method makeOSType;
+
+ /** The putParameter method of com.apple.MacOS.AppleEvent */
+ private static Method putParameter;
+
+ /** The sendNoReply method of com.apple.MacOS.AppleEvent */
+ private static Method sendNoReply;
+
+ /** Actually an MRJOSType pointing to the System Folder on a Macintosh */
+ private static Object kSystemFolderType;
+
+ /** The keyDirectObject AppleEvent parameter type */
+ private static Integer keyDirectObject;
+
+ /** The kAutoGenerateReturnID AppleEvent code */
+ private static Integer kAutoGenerateReturnID;
+
+ /** The kAnyTransactionID AppleEvent code */
+ private static Integer kAnyTransactionID;
+
+ /** The linkage object required for JDirect 3 on Mac OS X. */
+ private static Object linkage;
+
+ /** The framework to reference on Mac OS X */
+ private static final String JDirect_MacOSX = "/System/Library/Frameworks/Carbon.framework/Frameworks/HIToolbox.framework/HIToolbox";
+
+ /** JVM constant for MRJ 2.0 */
+ private static final int MRJ_2_0 = 0;
+
+ /** JVM constant for MRJ 2.1 or later */
+ private static final int MRJ_2_1 = 1;
+
+ /** JVM constant for Java on Mac OS X 10.0 (MRJ 3.0) */
+ private static final int MRJ_3_0 = 3;
+
+ /** JVM constant for MRJ 3.1 */
+ private static final int MRJ_3_1 = 4;
+
+ /** JVM constant for any Windows NT JVM */
+ private static final int WINDOWS_NT = 5;
+
+ /** JVM constant for any Windows 9x JVM */
+ private static final int WINDOWS_9x = 6;
+
+ /** JVM constant for any other platform */
+ private static final int OTHER = -1;
+
+ /**
+ * The file type of the Finder on a Macintosh. Hardcoding "Finder" would keep non-U.S. English
+ * systems from working properly.
+ */
+ private static final String FINDER_TYPE = "FNDR";
+
+ /**
+ * The creator code of the Finder on a Macintosh, which is needed to send AppleEvents to the
+ * application.
+ */
+ private static final String FINDER_CREATOR = "MACS";
+
+ /** The name for the AppleEvent type corresponding to a GetURL event. */
+ private static final String GURL_EVENT = "GURL";
+
+ /**
+ * The first parameter that needs to be passed into Runtime.exec() to open the default web
+ * browser on Windows.
+ */
+ private static final String FIRST_WINDOWS_PARAMETER = "/c";
+
+ /** The second parameter for Runtime.exec() on Windows. */
+ private static final String SECOND_WINDOWS_PARAMETER = "start";
+
+ /**
+ * The third parameter for Runtime.exec() on Windows. This is a "title"
+ * parameter that the command line expects. Setting this parameter allows
+ * URLs containing spaces to work.
+ */
+ private static final String THIRD_WINDOWS_PARAMETER = "\"\"";
+
+ /**
+ * The shell parameters for Netscape that opens a given URL in an already-open copy of Netscape
+ * on many command-line systems.
+ */
+ private static final String NETSCAPE_REMOTE_PARAMETER = "-remote";
+ private static final String NETSCAPE_OPEN_PARAMETER_START = "'openURL(";
+ private static final String NETSCAPE_OPEN_PARAMETER_END = ")'";
+
+ /**
+ * The message from any exception thrown throughout the initialization process.
+ */
+ private static String errorMessage;
+
+ /**
+ * An initialization block that determines the operating system and loads the necessary
+ * runtime data.
+ */
+ static {
+ loadedWithoutErrors = true;
+ String osName = System.getProperty("os.name");
+ if (osName.startsWith("Mac OS")) {
+ String mrjVersion = System.getProperty("mrj.version");
+ String majorMRJVersion = mrjVersion.substring(0, 3);
+ try {
+ double version = Double.valueOf(majorMRJVersion).doubleValue();
+ if (version == 2) {
+ jvm = MRJ_2_0;
+ } else if (version >= 2.1 && version < 3) {
+ // Assume that all 2.x versions of MRJ work the same. MRJ 2.1 actually
+ // works via Runtime.exec() and 2.2 supports that but has an openURL() method
+ // as well that we currently ignore.
+ jvm = MRJ_2_1;
+ } else if (version == 3.0) {
+ jvm = MRJ_3_0;
+ } else if (version >= 3.1) {
+ // Assume that all 3.1 and later versions of MRJ work the same.
+ jvm = MRJ_3_1;
+ } else {
+ loadedWithoutErrors = false;
+ errorMessage = "Unsupported MRJ version: " + version;
+ }
+ } catch (NumberFormatException nfe) {
+ loadedWithoutErrors = false;
+ errorMessage = "Invalid MRJ version: " + mrjVersion;
+ }
+ } else if (osName.startsWith("Windows")) {
+ if (osName.indexOf("9") != -1) {
+ jvm = WINDOWS_9x;
+ } else {
+ jvm = WINDOWS_NT;
+ }
+ } else {
+ jvm = OTHER;
+ }
+
+ if (loadedWithoutErrors) { // if we haven't hit any errors yet
+ loadedWithoutErrors = loadClasses();
+ }
+ }
+
+ /**
+ * This class should be never be instantiated; this just ensures so.
+ */
+ private BrowserLauncher() { }
+
+ /**
+ * Called by a static initializer to load any classes, fields, and methods required at runtime
+ * to locate the user's web browser.
+ * @return true if all intialization succeeded
+ * false if any portion of the initialization failed
+ */
+ private static boolean loadClasses() {
+ switch (jvm) {
+ case MRJ_2_0:
+ try {
+ Class aeTargetClass = Class.forName("com.apple.MacOS.AETarget");
+ Class osUtilsClass = Class.forName("com.apple.MacOS.OSUtils");
+ Class appleEventClass = Class.forName("com.apple.MacOS.AppleEvent");
+ Class aeClass = Class.forName("com.apple.MacOS.ae");
+ aeDescClass = Class.forName("com.apple.MacOS.AEDesc");
+
+ aeTargetConstructor = aeTargetClass.getDeclaredConstructor(new Class [] { int.class });
+ appleEventConstructor = appleEventClass.getDeclaredConstructor(new Class[] { int.class, int.class, aeTargetClass, int.class, int.class });
+ aeDescConstructor = aeDescClass.getDeclaredConstructor(new Class[] { String.class });
+
+ makeOSType = osUtilsClass.getDeclaredMethod("makeOSType", new Class [] { String.class });
+ putParameter = appleEventClass.getDeclaredMethod("putParameter", new Class[] { int.class, aeDescClass });
+ sendNoReply = appleEventClass.getDeclaredMethod("sendNoReply", new Class[] { });
+
+ Field keyDirectObjectField = aeClass.getDeclaredField("keyDirectObject");
+ keyDirectObject = (Integer) keyDirectObjectField.get(null);
+ Field autoGenerateReturnIDField = appleEventClass.getDeclaredField("kAutoGenerateReturnID");
+ kAutoGenerateReturnID = (Integer) autoGenerateReturnIDField.get(null);
+ Field anyTransactionIDField = appleEventClass.getDeclaredField("kAnyTransactionID");
+ kAnyTransactionID = (Integer) anyTransactionIDField.get(null);
+ } catch (ClassNotFoundException cnfe) {
+ errorMessage = cnfe.getMessage();
+ return false;
+ } catch (NoSuchMethodException nsme) {
+ errorMessage = nsme.getMessage();
+ return false;
+ } catch (NoSuchFieldException nsfe) {
+ errorMessage = nsfe.getMessage();
+ return false;
+ } catch (IllegalAccessException iae) {
+ errorMessage = iae.getMessage();
+ return false;
+ }
+ break;
+ case MRJ_2_1:
+ try {
+ mrjFileUtilsClass = Class.forName("com.apple.mrj.MRJFileUtils");
+ mrjOSTypeClass = Class.forName("com.apple.mrj.MRJOSType");
+ Field systemFolderField = mrjFileUtilsClass.getDeclaredField("kSystemFolderType");
+ kSystemFolderType = systemFolderField.get(null);
+ findFolder = mrjFileUtilsClass.getDeclaredMethod("findFolder", new Class[] { mrjOSTypeClass });
+ getFileCreator = mrjFileUtilsClass.getDeclaredMethod("getFileCreator", new Class[] { File.class });
+ getFileType = mrjFileUtilsClass.getDeclaredMethod("getFileType", new Class[] { File.class });
+ } catch (ClassNotFoundException cnfe) {
+ errorMessage = cnfe.getMessage();
+ return false;
+ } catch (NoSuchFieldException nsfe) {
+ errorMessage = nsfe.getMessage();
+ return false;
+ } catch (NoSuchMethodException nsme) {
+ errorMessage = nsme.getMessage();
+ return false;
+ } catch (SecurityException se) {
+ errorMessage = se.getMessage();
+ return false;
+ } catch (IllegalAccessException iae) {
+ errorMessage = iae.getMessage();
+ return false;
+ }
+ break;
+ case MRJ_3_0:
+ try {
+ Class linker = Class.forName("com.apple.mrj.jdirect.Linker");
+ Constructor constructor = linker.getConstructor(new Class[]{ Class.class });
+ linkage = constructor.newInstance(new Object[] { BrowserLauncher.class });
+ } catch (ClassNotFoundException cnfe) {
+ errorMessage = cnfe.getMessage();
+ return false;
+ } catch (NoSuchMethodException nsme) {
+ errorMessage = nsme.getMessage();
+ return false;
+ } catch (InvocationTargetException ite) {
+ errorMessage = ite.getMessage();
+ return false;
+ } catch (InstantiationException ie) {
+ errorMessage = ie.getMessage();
+ return false;
+ } catch (IllegalAccessException iae) {
+ errorMessage = iae.getMessage();
+ return false;
+ }
+ break;
+ case MRJ_3_1:
+ try {
+ mrjFileUtilsClass = Class.forName("com.apple.mrj.MRJFileUtils");
+ openURL = mrjFileUtilsClass.getDeclaredMethod("openURL", new Class[] { String.class });
+ } catch (ClassNotFoundException cnfe) {
+ errorMessage = cnfe.getMessage();
+ return false;
+ } catch (NoSuchMethodException nsme) {
+ errorMessage = nsme.getMessage();
+ return false;
+ }
+ break;
+ default:
+ break;
+ }
+ return true;
+ }
+
+ /**
+ * Attempts to locate the default web browser on the local system. Caches results so it
+ * only locates the browser once for each use of this class per JVM instance.
+ * @return The browser for the system. Note that this may not be what you would consider
+ * to be a standard web browser; instead, it's the application that gets called to
+ * open the default web browser. In some cases, this will be a non-String object
+ * that provides the means of calling the default browser.
+ */
+ private static Object locateBrowser() {
+ if (browser != null) {
+ return browser;
+ }
+ switch (jvm) {
+ case MRJ_2_0:
+ try {
+ Integer finderCreatorCode = (Integer) makeOSType.invoke(null, new Object[] { FINDER_CREATOR });
+ Object aeTarget = aeTargetConstructor.newInstance(new Object[] { finderCreatorCode });
+ Integer gurlType = (Integer) makeOSType.invoke(null, new Object[] { GURL_EVENT });
+ Object appleEvent = appleEventConstructor.newInstance(new Object[] { gurlType, gurlType, aeTarget, kAutoGenerateReturnID, kAnyTransactionID });
+ // Don't set browser = appleEvent because then the next time we call
+ // locateBrowser(), we'll get the same AppleEvent, to which we'll already have
+ // added the relevant parameter. Instead, regenerate the AppleEvent every time.
+ // There's probably a way to do this better; if any has any ideas, please let
+ // me know.
+ return appleEvent;
+ } catch (IllegalAccessException iae) {
+ browser = null;
+ errorMessage = iae.getMessage();
+ return browser;
+ } catch (InstantiationException ie) {
+ browser = null;
+ errorMessage = ie.getMessage();
+ return browser;
+ } catch (InvocationTargetException ite) {
+ browser = null;
+ errorMessage = ite.getMessage();
+ return browser;
+ }
+ case MRJ_2_1:
+ File systemFolder;
+ try {
+ systemFolder = (File) findFolder.invoke(null, new Object[] { kSystemFolderType });
+ } catch (IllegalArgumentException iare) {
+ browser = null;
+ errorMessage = iare.getMessage();
+ return browser;
+ } catch (IllegalAccessException iae) {
+ browser = null;
+ errorMessage = iae.getMessage();
+ return browser;
+ } catch (InvocationTargetException ite) {
+ browser = null;
+ errorMessage = ite.getTargetException().getClass() + ": " + ite.getTargetException().getMessage();
+ return browser;
+ }
+ String[] systemFolderFiles = systemFolder.list();
+ // Avoid a FilenameFilter because that can't be stopped mid-list
+ for(int i = 0; i < systemFolderFiles.length; i++) {
+ try {
+ File file = new File(systemFolder, systemFolderFiles[i]);
+ if (!file.isFile()) {
+ continue;
+ }
+ // We're looking for a file with a creator code of 'MACS' and
+ // a type of 'FNDR'. Only requiring the type results in non-Finder
+ // applications being picked up on certain Mac OS 9 systems,
+ // especially German ones, and sending a GURL event to those
+ // applications results in a logout under Multiple Users.
+ Object fileType = getFileType.invoke(null, new Object[] { file });
+ if (FINDER_TYPE.equals(fileType.toString())) {
+ Object fileCreator = getFileCreator.invoke(null, new Object[] { file });
+ if (FINDER_CREATOR.equals(fileCreator.toString())) {
+ browser = file.toString(); // Actually the Finder, but that's OK
+ return browser;
+ }
+ }
+ } catch (IllegalArgumentException iare) {
+ errorMessage = iare.getMessage();
+ return null;
+ } catch (IllegalAccessException iae) {
+ browser = null;
+ errorMessage = iae.getMessage();
+ return browser;
+ } catch (InvocationTargetException ite) {
+ browser = null;
+ errorMessage = ite.getTargetException().getClass() + ": " + ite.getTargetException().getMessage();
+ return browser;
+ }
+ }
+ browser = null;
+ break;
+ case MRJ_3_0:
+ case MRJ_3_1:
+ browser = ""; // Return something non-null
+ break;
+ case WINDOWS_NT:
+ browser = "cmd.exe";
+ break;
+ case WINDOWS_9x:
+ browser = "command.com";
+ break;
+ case OTHER:
+ default:
+ browser = "netscape";
+ break;
+ }
+ return browser;
+ }
+
+ /**
+ * Attempts to open the default web browser to the given URL.
+ * @param url The URL to open
+ * @throws IOException If the web browser could not be located or does not run
+ */
+ public static void openURL(String url) throws IOException {
+ if (!loadedWithoutErrors) {
+ throw new IOException("Exception in finding browser: " + errorMessage);
+ }
+ Object browser = locateBrowser();
+ if (browser == null) {
+ throw new IOException("Unable to locate browser: " + errorMessage);
+ }
+
+ switch (jvm) {
+ case MRJ_2_0:
+ Object aeDesc = null;
+ try {
+ aeDesc = aeDescConstructor.newInstance(new Object[] { url });
+ putParameter.invoke(browser, new Object[] { keyDirectObject, aeDesc });
+ sendNoReply.invoke(browser, new Object[] { });
+ } catch (InvocationTargetException ite) {
+ throw new IOException("InvocationTargetException while creating AEDesc: " + ite.getMessage());
+ } catch (IllegalAccessException iae) {
+ throw new IOException("IllegalAccessException while building AppleEvent: " + iae.getMessage());
+ } catch (InstantiationException ie) {
+ throw new IOException("InstantiationException while creating AEDesc: " + ie.getMessage());
+ } finally {
+ aeDesc = null; // Encourage it to get disposed if it was created
+ browser = null; // Ditto
+ }
+ break;
+ case MRJ_2_1:
+ Runtime.getRuntime().exec(new String[] { (String) browser, url } );
+ break;
+ case MRJ_3_0:
+ int[] instance = new int[1];
+ int result = ICStart(instance, 0);
+ if (result == 0) {
+ int[] selectionStart = new int[] { 0 };
+ byte[] urlBytes = url.getBytes();
+ int[] selectionEnd = new int[] { urlBytes.length };
+ result = ICLaunchURL(instance[0], new byte[] { 0 }, urlBytes,
+ urlBytes.length, selectionStart,
+ selectionEnd);
+ if (result == 0) {
+ // Ignore the return value; the URL was launched successfully
+ // regardless of what happens here.
+ ICStop(instance);
+ } else {
+ throw new IOException("Unable to launch URL: " + result);
+ }
+ } else {
+ throw new IOException("Unable to create an Internet Config instance: " + result);
+ }
+ break;
+ case MRJ_3_1:
+ try {
+ openURL.invoke(null, new Object[] { url });
+ } catch (InvocationTargetException ite) {
+ throw new IOException("InvocationTargetException while calling openURL: " + ite.getMessage());
+ } catch (IllegalAccessException iae) {
+ throw new IOException("IllegalAccessException while calling openURL: " + iae.getMessage());
+ }
+ break;
+ case WINDOWS_NT:
+ case WINDOWS_9x:
+ // Add quotes around the URL to allow ampersands and other special
+ // characters to work.
+ Process process = Runtime.getRuntime().exec(new String[] { (String) browser,
+ FIRST_WINDOWS_PARAMETER,
+ SECOND_WINDOWS_PARAMETER,
+ THIRD_WINDOWS_PARAMETER,
+ '"' + url + '"' });
+ // This avoids a memory leak on some versions of Java on Windows.
+ // That's hinted at in .
+ try {
+ process.waitFor();
+ process.exitValue();
+ } catch (InterruptedException ie) {
+ throw new IOException("InterruptedException while launching browser: " + ie.getMessage());
+ }
+ break;
+ case OTHER:
+ // Assume that we're on Unix and that Netscape is installed
+
+ // First, attempt to open the URL in a currently running session of Netscape
+ process = Runtime.getRuntime().exec(new String[] { (String) browser,
+ NETSCAPE_REMOTE_PARAMETER,
+ NETSCAPE_OPEN_PARAMETER_START +
+ url +
+ NETSCAPE_OPEN_PARAMETER_END });
+ try {
+ int exitCode = process.waitFor();
+ if (exitCode != 0) { // if Netscape was not open
+ Runtime.getRuntime().exec(new String[] { (String) browser, url });
+ }
+ } catch (InterruptedException ie) {
+ throw new IOException("InterruptedException while launching browser: " + ie.getMessage());
+ }
+ break;
+ default:
+ // This should never occur, but if it does, we'll try the simplest thing possible
+ Runtime.getRuntime().exec(new String[] { (String) browser, url });
+ break;
+ }
+ }
+
+ /**
+ * Methods required for Mac OS X. The presence of native methods does not cause
+ * any problems on other platforms.
+ */
+ private native static int ICStart(int[] instance, int signature);
+ private native static int ICStop(int[] instance);
+ private native static int ICLaunchURL(int instance, byte[] hint, byte[] data, int len,
+ int[] selectionStart, int[] selectionEnd);
+}
diff --git a/src/de/memtext/util/ClipboardUtils.java b/src/de/memtext/util/ClipboardUtils.java
new file mode 100644
index 0000000..4507219
--- /dev/null
+++ b/src/de/memtext/util/ClipboardUtils.java
@@ -0,0 +1,323 @@
+package de.memtext.util;
+/*
+ * ClipboardUtils written by Meikel Bisping.
+ * May freely be redistributed and adapted.
+ * For comments write to M.Bisping at gmx.de
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL MEIKEL BISPING OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.ClipboardOwner;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.StringSelection;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import javax.imageio.ImageIO;
+import javax.swing.JOptionPane;
+
+/**
+ Utility class that allows Strings, Images or other Transferables (rtf)
+ to be placed in the clipboard.
+ If an exception occurs a warning message is shown.
+ Examples
+ In your application just call
+ String txt="some text";
+ ClipboardUtils.setContents(txt,null);
+
+ some JComponent
+ JPanel panel=new MyPanel();
+ Clipboardutils.setContentsImageContents(panel,null);
+
+ */
+public class ClipboardUtils {
+ private final static Clipboard CLIPBOARD = Toolkit.getDefaultToolkit().getSystemClipboard();
+
+ private ClipboardUtils() {
+ }
+
+ /**
+ * Sets the current contents of the clipboard to the specified StringBuffer and registers the specified clipboard owner as the owner of the new contents
+ * @param content
+ * @param owner
+ * @return boolean false if exception occurred
+ */
+ public static boolean setContents(
+ StringBuffer content,
+ ClipboardOwner owner) {
+ return setContents(content.toString(), owner);
+ }
+
+ /**
+ * Sets the current contents of the clipboard to the specified image and registers the specified clipboard owner as the owner of the new contents
+ * @param content
+ * @param owner
+ * @return boolean false if exception occurred
+ */
+ public static boolean setContents(Image image,ClipboardOwner owner)
+ {
+ return setContents(new ImageTransferable(image),owner);
+ }
+ /**
+ * Sets the current contents of the clipboard to the specified StringBuffer and registers the specified clipboard owner as the owner of the new contents
+ * @param content
+ * @param owner
+ * @return boolean false if exception occurred
+ */
+ public static boolean setContents(String content, ClipboardOwner owner) {
+ return setContents(new StringSelection(content), null);
+
+
+ }
+
+ /**
+ * Sets the current contents of the clipboard to an graphical image of the component
+ * and registers the specified clipboard owner as the owner of the new contents
+ * This method isn't just called setContents(Component comp, ClipboardOwner owner)
+ * because Components might implement the Transferable Interface themselves which
+ * would lead to confusion with the setContents(Transferable trans,ClipboardOwner owner)-method.
+ * @param Component comp
+ * @return boolean false if exception occurred
+ */
+ public static boolean setImageContents(
+ Component comp,
+ ClipboardOwner owner) {
+ return setContents(new ImageTransferable(comp), owner);
+ }
+
+ public static void setImageAndRtfContents(Image image,
+ ByteArrayOutputStream outStream,
+ ClipboardOwner owner)
+ {
+ ByteArrayInputStream byteInputStream =
+ new ByteArrayInputStream(outStream.toByteArray());
+ setContents(new ImageAndRtfTransferable(image,byteInputStream),owner);
+ }
+ /**
+ * Fills the clipboard with a RTF-Transferable.
+ *
+ * @param ByteArrayOutputStream - an rtf in form of ByteArrayOutputStream
+ */
+ public static void setRtfContents(
+ ByteArrayOutputStream outStream,
+ ClipboardOwner owner) {
+ ByteArrayInputStream byteInputStream =
+ new ByteArrayInputStream(outStream.toByteArray());
+ setContents(new RtfTransferable(byteInputStream), owner);
+ }
+
+ /**
+ * Sets the current contents of the clipboard to the specified transferable object and registers the specified clipboard owner as the owner of the new contents.
+ * Shows warning message if an exception occured
+ * @param contents
+ * @return boolean false if an exception occured
+ */
+ public static boolean setContents(
+ Transferable contents,
+ ClipboardOwner owner) {
+ boolean result = true;
+ try {
+ CLIPBOARD.setContents(contents, owner);
+ } catch (IllegalStateException e) {
+ showWarning(e);
+ result = false;
+ }
+ return result;
+ }
+ /**
+ * Draws a given component into a buffered image and returns that image.
+ * Can be used to copy to images of components to the clipboard
+ * @param Component comp
+ * @return BufferedImage
+ */
+ public static BufferedImage toBufferedImage(Component comp) {
+ BufferedImage tempImage =
+ new BufferedImage(
+ comp.getSize().width,
+ comp.getSize().height,
+ BufferedImage.TYPE_INT_RGB);
+ Graphics tempGraphics = tempImage.getGraphics();
+ Graphics2D g2d = (Graphics2D) tempImage.getGraphics();
+ comp.paint(tempGraphics);
+ return tempImage;
+ }
+
+ /**
+ * Turns a BufferedImage into a jpg and then into an array of bytes,
+ * which can be useful for generating rtf
+
+ * @param image - a buffered image
+ * @return byte[] array of bytes containing the image
+ * @throws IOException
+ */
+ public static byte[] toByteArray(BufferedImage image) throws IOException {
+ ByteArrayOutputStream outstream = new ByteArrayOutputStream();
+ ImageIO.write(image, "jpg", outstream);
+ return outstream.toByteArray();
+ }
+
+ private static void showWarning(Exception e) {
+ JOptionPane.showMessageDialog(
+ null,
+ "Couldn't copy to clipboard.\n" + e.toString(),
+ "Problem",
+ JOptionPane.WARNING_MESSAGE);
+ }
+ public static Object getContents() {
+ String[] s = ImageIO.getWriterFormatNames();
+ for (int i = 0; i < s.length; i++)
+ System.out.println(s[i]);
+ System.exit(-1);
+ Object result = CLIPBOARD.getContents(null);
+ Transferable t = (Transferable) result;
+ DataFlavor[] d = t.getTransferDataFlavors();
+ for (int i = 1; i < d.length; i++) {
+ System.out.println(d[i]);
+ }
+ try {
+ Object o =
+ t.getTransferData(
+ new DataFlavor("text/rtf;representationclass=java.io.InputStream"));
+ int i = 1;
+ } catch (UnsupportedFlavorException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+ int i = 1;
+ return result;
+ }
+ public static void main(String args[]) {
+test();
+ //getContents();
+ }
+ private static void test()
+ {
+ try {
+ // Die Daten aus dem SystemClipboard holen
+ Transferable data = Toolkit.getDefaultToolkit().
+ getSystemClipboard().getContents(null);
+ // Die unterschiedlichen Repräsentationen holen
+ DataFlavor[] df = data.getTransferDataFlavors();
+ for (int i = 0; i < df.length; i++) {
+ System.out.println(df[i].getHumanPresentableName()+" "+df[i].getMimeType());
+
+ }
+ } catch (Throwable ta) { ta.printStackTrace (); }
+ }
+
+}
+class ImageAndRtfTransferable extends ImageTransferable
+{
+ private ByteArrayInputStream stream;
+ public DataFlavor rtfDataFlavor;
+ ImageAndRtfTransferable(Component comp,ByteArrayInputStream stream) {
+ super(comp);
+ initRTF(stream);
+ }
+ ImageAndRtfTransferable(Image image,ByteArrayInputStream stream) {
+ super(image);
+ initRTF(stream);
+ }
+ private void initRTF(ByteArrayInputStream stream)
+ {
+ try {
+ rtfDataFlavor =
+ new DataFlavor("text/rtf; class=java.io.InputStream");
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+ this.stream = stream;
+ }
+ public DataFlavor[] getTransferDataFlavors() {
+ return new DataFlavor[] {DataFlavor.imageFlavor, rtfDataFlavor };
+ }
+
+ public boolean isDataFlavorSupported(DataFlavor flavor) {
+ return flavor.equals(rtfDataFlavor)||flavor.equals(DataFlavor.imageFlavor);
+ }
+
+ public Object getTransferData(DataFlavor flavor)
+ throws UnsupportedFlavorException {
+ if (!isDataFlavorSupported(flavor)) {
+ throw new UnsupportedFlavorException(flavor);
+ }
+ Object res=null;
+ if (flavor.equals(rtfDataFlavor)) res= stream;
+ if (flavor.equals(DataFlavor.imageFlavor)) res= image;
+ return res;
+ }
+}
+class ImageTransferable implements Transferable {
+ protected Image image;
+ ImageTransferable(Component comp) {
+ image = ClipboardUtils.toBufferedImage(comp);
+ }
+ ImageTransferable(Image image) {
+ this.image = image;
+ }
+ public DataFlavor[] getTransferDataFlavors() {
+ return new DataFlavor[] { DataFlavor.imageFlavor };
+ }
+
+ public boolean isDataFlavorSupported(DataFlavor flavor) {
+ return DataFlavor.imageFlavor.equals(flavor);
+ }
+
+ public Object getTransferData(DataFlavor flavor)
+ throws UnsupportedFlavorException {
+ if (!isDataFlavorSupported(flavor)) {
+ throw new UnsupportedFlavorException(flavor);
+ }
+ return image;
+ }
+
+}
+class RtfTransferable implements Transferable {
+ public DataFlavor rtfDataFlavor;
+ private ByteArrayInputStream stream;
+ RtfTransferable(ByteArrayInputStream stream) {
+ try {
+ rtfDataFlavor =
+ new DataFlavor("text/rtf; class=java.io.InputStream");
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+ this.stream = stream;
+ }
+ public DataFlavor[] getTransferDataFlavors() {
+ return new DataFlavor[] { rtfDataFlavor };
+ }
+
+ public boolean isDataFlavorSupported(DataFlavor flavor) {
+ return flavor.equals(rtfDataFlavor);
+ }
+
+ public Object getTransferData(DataFlavor flavor)
+ throws UnsupportedFlavorException {
+ if (!isDataFlavorSupported(flavor)) {
+ throw new UnsupportedFlavorException(flavor);
+ }
+ return stream;
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/CollUtils.java b/src/de/memtext/util/CollUtils.java
new file mode 100644
index 0000000..4322d5e
--- /dev/null
+++ b/src/de/memtext/util/CollUtils.java
@@ -0,0 +1,24 @@
+package de.memtext.util;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+public class CollUtils {
+
+ private CollUtils() {
+ super();
+ }
+
+ public static String toSeparatedList(Collection coll, char separator) {
+ StringBuffer result = new StringBuffer();
+ for (Iterator it = coll.iterator(); it.hasNext();) {
+ Object element = it.next();
+ result.append(element.toString() + separator);
+ }
+ if (coll.size() > 0)
+ StringUtils.deleteLastChar(result);
+ return result.toString();
+ }
+}
+
+//Created on 27.05.2004 at 20:37:35
\ No newline at end of file
diff --git a/src/de/memtext/util/ColorUtils.java b/src/de/memtext/util/ColorUtils.java
new file mode 100644
index 0000000..54e04dd
--- /dev/null
+++ b/src/de/memtext/util/ColorUtils.java
@@ -0,0 +1,17 @@
+package de.memtext.util;
+
+import java.awt.Color;
+
+public class ColorUtils {
+
+ private ColorUtils() {
+ super();
+ }
+
+public static Color getRandomColor(int maxR,int maxG,int maxB)
+{
+ return new Color(NumberUtils.getRandomInt(maxR),NumberUtils.getRandomInt(maxG),NumberUtils.getRandomInt(maxB));
+}
+}
+
+//Created on 30.11.2003 at 15:01:27
\ No newline at end of file
diff --git a/src/de/memtext/util/ComponentUtils.java b/src/de/memtext/util/ComponentUtils.java
new file mode 100644
index 0000000..9dd68f6
--- /dev/null
+++ b/src/de/memtext/util/ComponentUtils.java
@@ -0,0 +1,32 @@
+package de.memtext.util;
+
+import javax.swing.JComponent;
+
+public class ComponentUtils {
+
+ private ComponentUtils() {
+ }
+
+ /**
+ *
+ * @param comp
+ * @param container
+ * @return -1 if not found
+ */
+ public static int getPositionOnComponent(
+ JComponent comp,
+ JComponent container) {
+ int i = 0;
+ int result = -1;
+ while (i < container.getComponentCount()) {
+ if (comp == container.getComponent(i)) {
+ result = i;
+ break;
+ }
+ i++;
+ }
+ return result;
+ }
+}
+
+//Created on 16.11.2003
\ No newline at end of file
diff --git a/src/de/memtext/util/CryptUtils.java b/src/de/memtext/util/CryptUtils.java
new file mode 100644
index 0000000..68ae405
--- /dev/null
+++ b/src/de/memtext/util/CryptUtils.java
@@ -0,0 +1,278 @@
+package de.memtext.util;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.StringTokenizer;
+
+import javax.crypto.Cipher;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.SecretKeySpec;
+import org.apache.commons.codec.digest.Crypt;
+/**
+ *
+ *
+ */
+public class CryptUtils {
+ private static byte key[] = { (byte) 255, (byte) 221, (byte) 127,
+ (byte) 109, (byte) 129 };
+ private static final byte[] KEY_DATA = { -108, -50, -5, -75, -98, 28, -116,
+ 107 };
+ private static final SecretKeySpec KEY = new SecretKeySpec(KEY_DATA, "DES");
+ private static Cipher desCipher;
+ static final String key2 = "secretKey12349739873560303";
+ private static MessageDigest md5;
+ public static String geheimnis1 = "A thing of beauty is a joy for ever: Its loveliness increases; it will never Pass into nothingness; but still will keep A bower quiet for us, and a sleep Full of sweet dreams, and health, and quiet breathing.";
+
+ private CryptUtils() {
+ }
+
+ public static String decryptSimple(String d) {
+ byte[] tmp;
+ tmp = d.getBytes();
+ int size = (byte) (tmp[0] ^ key[0 % key.length]);
+ int index = (byte) (tmp[1] ^ key[1 % key.length]);
+ byte de[] = new byte[size];
+ for (int i = index; i < (size + index); i++) {
+ de[i - index] = (byte) (tmp[i] ^ key[i % key.length]);
+ }
+ return new String(de);
+ }
+
+ /**
+ * Encodes a String using SHA
+ *
+ * @param txt -
+ * String to be encode
+ * @return encoded String In the unprobable event of the SHA algorithm not
+ * being available the stack trace is printed and the program
+ * halted.
+ */
+ public static String encodeSHA(String txt) {
+ MessageDigest sha = null;
+ try {
+ sha = MessageDigest.getInstance("SHA-1");
+ } catch (NoSuchAlgorithmException e) {
+ e.printStackTrace();
+ System.exit(-1);
+ }
+
+ byte[] buf = txt.getBytes();
+ byte[] digest = null;
+ StringBuffer encrypted = new StringBuffer();
+ String value;
+ int n;
+ sha.update(buf);
+ digest = sha.digest();
+
+ for (int i = 0; i < digest.length; i++) {
+ n = (int) digest[i];
+ if (n < 0)
+ n += 256;
+ value = Integer.toHexString(n);
+ if (n < 16)
+ value = "0" + value;
+ encrypted.append(value);
+ }
+ return encrypted.toString();
+ }
+ public static String encodeSHA512(String txt) {
+ if (txt ==null || txt.length() > 1000) {
+ throw new RuntimeException("Passwort ist ungültig");
+ }
+
+ byte txtArray[] = txt.getBytes();
+
+ return Crypt.crypt(txtArray, "$6$0q5233a66a3e9bea16f3139bfe4f6ce50ced591deafbc4b9ef56d6ae60fe9c4b22aa78dbd704bde57c");
+ }
+ public static String encryptSimple(String s) {
+ int i = 0;
+ byte pad[] = s.getBytes();
+ int blockSize = Math.max((((pad.length / 8) + 1) * 8 + 2), 24);
+ int startIndex = (int) (Math.random() * (blockSize - pad.length - 2)) + 2;
+ byte tmp[] = new byte[blockSize];
+
+ tmp[0] = (byte) (((byte) pad.length) ^ key[(0) % key.length]);
+ tmp[1] = (byte) (((byte) startIndex) ^ key[(1) % key.length]);
+
+ for (i = startIndex; i < (pad.length + startIndex); i++) {
+ tmp[i] = (byte) (pad[i - startIndex] ^ key[(i) % key.length]);
+ }
+
+ for (int j = i; j < tmp.length; j++) {
+ tmp[j] = (byte) ((byte) (Math.random() * 255) ^ key[(i)
+ % key.length]);
+ }
+ for (int j = 2; j < startIndex; j++) {
+ tmp[j] = (byte) ((byte) (Math.random() * 255) ^ key[(i)
+ % key.length]);
+ }
+ return new String(tmp);
+ }
+
+ public static void main(String a[]) {
+
+ try {
+ System.out.println(encodeSHA512(a[0]));
+
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ public static String encodeMD5(String text) throws NoSuchAlgorithmException {
+ if (md5 == null)
+ md5 = MessageDigest.getInstance("MD5");
+ byte[] digest = null;
+ digest = md5.digest(text.getBytes());
+ String trans = null;
+ String byteStr;
+ StringBuffer buf = new StringBuffer();
+ for (int i = 0; i <= digest.length - 1; i++) {
+ byteStr = Integer.toHexString(digest[i]);
+ switch (byteStr.length()) {
+ case 1:
+ trans = "0" + Integer.toHexString(digest[i]);
+ break;
+ case 2:
+ trans = Integer.toHexString(digest[i]);
+ break;
+ case 8:
+ trans = (Integer.toHexString(digest[i])).substring(6, 8);
+ break;
+ }
+ buf.append(trans);
+ }
+ return buf.toString();
+ }
+
+ public static String decryptStringDES(String aValue) throws Exception {
+ if (aValue == null)
+ return null;
+ if (desCipher == null)
+ initDesCipher();
+ desCipher.init(Cipher.DECRYPT_MODE, KEY);
+ byte[] encrypted = makeArrayDES(aValue);
+ byte[] decrypted = desCipher.doFinal(encrypted);
+ String result = new String(decrypted);
+ return result;
+
+ }
+
+ public static String encryptStringDES(String aValue) throws Exception {
+ if (aValue == null)
+ return null;
+ if (desCipher == null)
+ initDesCipher();
+
+ desCipher.init(Cipher.ENCRYPT_MODE, KEY);
+ byte[] values = aValue.getBytes();
+ byte[] encrypted = desCipher.doFinal(values);
+ return makeStringDES(encrypted);
+
+ }
+
+ /**
+ * Creates a String from the given array which can be used to store the
+ * array in a text file
+ *
+ * @see #makeArrayDES(String)
+ */
+ private static String makeStringDES(byte[] values) {
+ StringBuffer buff = new StringBuffer(values.length * 3);
+ for (int i = 0; i < values.length; i++) {
+ buff.append('#');
+ buff.append(values[i]);
+ }
+ return buff.toString();
+ }
+
+ /**
+ * Internal method which converts an "Array String" into a byte array which
+ * can be used for decoding
+ *
+ * @see #makeString(byte[])
+ */
+ private static byte[] makeArrayDES(String values) {
+ StringTokenizer tok = new StringTokenizer(values, "#");
+ byte[] result = new byte[tok.countTokens()];
+ byte b;
+ String c;
+ int i = 0;
+ while (tok.hasMoreTokens()) {
+ c = tok.nextToken();
+ try {
+ b = Byte.parseByte(c);
+ result[i] = b;
+ i++;
+ } catch (NumberFormatException e) {
+ return new byte[1];
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Help method for creating the DES key.
+ */
+ private static void createKey() {
+ /*
+ * try { KeyGenerator keygen = KeyGenerator.getInstance("DES");
+ * SecretKey desKey = keygen.generateKey();
+ *
+ * byte[] keyvalue = desKey.getEncoded(); System.out.print("byte[]
+ * KEY_DATA = {"); for (int i = 0; i < keyvalue.length; i++) {
+ * System.out.print(keyvalue[i]); if (i < keyvalue.length - 1)
+ * System.out.print(","); } System.out.println("};"); } catch (Exception
+ * e) { e.printStackTrace(); }
+ */
+ }
+
+ private static void initDesCipher() throws NoSuchAlgorithmException,
+ NoSuchPaddingException {
+ java.security.Security
+ .addProvider(new com.sun.crypto.provider.SunJCE());
+ desCipher = Cipher.getInstance("DES");
+
+ }
+
+ public static String simpleEncryptString2(String str) {
+ StringBuffer sb = new StringBuffer(str);
+
+ int lenStr = str.length();
+
+ for (int i = 0; i < lenStr; i++) {
+
+ sb.setCharAt(i, (char) (str.charAt(i) + 1));
+ }
+
+ return sb.toString();
+ }
+
+ public static String simpleDecryptString2(String str) {
+ StringBuffer sb = new StringBuffer(str);
+
+ int lenStr = str.length();
+
+ for (int i = 0; i < lenStr; i++) {
+
+ sb.setCharAt(i, (char) (str.charAt(i) - 1));
+ }
+
+ return sb.toString();
+ }
+
+ public static String decryptStringDES_UTF8(String aValue) throws Exception {
+ if (aValue == null)
+ return null;
+ if (desCipher == null)
+ initDesCipher();
+ desCipher.init(Cipher.DECRYPT_MODE, KEY);
+ byte[] encrypted = makeArrayDES(aValue);
+ byte[] decrypted = desCipher.doFinal(encrypted);
+ String result = new String(decrypted,"UTF-8");
+ return result;
+ }
+
+}
diff --git a/src/de/memtext/util/DSAHandler.java b/src/de/memtext/util/DSAHandler.java
new file mode 100644
index 0000000..29cddc6
--- /dev/null
+++ b/src/de/memtext/util/DSAHandler.java
@@ -0,0 +1,170 @@
+package de.memtext.util;
+
+import java.io.ByteArrayOutputStream;
+import java.security.InvalidKeyException;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.SignatureException;
+import java.security.interfaces.DSAPrivateKey;
+import java.security.interfaces.DSAPublicKey;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.Hashtable;
+import java.util.StringTokenizer;
+
+public class DSAHandler {
+ private Signature dsa;
+ private Signature dsa2;
+ private PrivateKey privateKey;
+ private PublicKey publicKey;
+
+ public DSAHandler(String privateKeyEncoded) throws InvalidKeyException,
+ NoSuchAlgorithmException, InvalidKeySpecException {
+ this(privateKeyEncoded, null);
+ }
+
+ public DSAHandler(String privateKeyEncoded, String publicKeyEncoded)
+ throws NoSuchAlgorithmException, InvalidKeySpecException,
+ InvalidKeyException {
+ dsa = Signature.getInstance("SHA1withDSA");
+
+ //create Private Key Object
+ PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(
+ getBytes(privateKeyEncoded));
+ KeyFactory keyFactory = KeyFactory.getInstance("DSA");
+ privateKey = keyFactory.generatePrivate(keyspec);
+ dsa.initSign(privateKey);
+
+ if (publicKeyEncoded != null) {
+ dsa2 = Signature.getInstance("SHA1withDSA");
+ //public key recreated
+ X509EncodedKeySpec xkeyspec = new X509EncodedKeySpec(
+ getBytes(publicKeyEncoded));
+ KeyFactory keyFactory2 = KeyFactory.getInstance("DSA");
+ publicKey = keyFactory2.generatePublic(xkeyspec);
+ dsa2.initVerify(publicKey);
+ }
+ }
+
+ private static String getString(byte[] bytes) {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < bytes.length; i++) {
+ byte b = bytes[i];
+ sb.append((int) (0x00FF & b));
+ if (i + 1 < bytes.length) {
+ sb.append("-");
+ }
+ }
+ return sb.toString();
+ }
+
+ private static byte[] getBytes(String str) {
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ StringTokenizer st = new StringTokenizer(str, "-", false);
+ while (st.hasMoreTokens()) {
+ int i = Integer.parseInt(st.nextToken());
+ bos.write((byte) i);
+ }
+ return bos.toByteArray();
+ }
+
+ public String sign(String data) throws NoSuchAlgorithmException,
+ InvalidKeySpecException, InvalidKeyException, SignatureException {
+ dsa.update(data.getBytes());
+ byte[] signature = dsa.sign();
+ String signed = getString(signature);
+ return signed;
+ }
+
+ public boolean verify(String data, String signed)
+ throws NoSuchAlgorithmException, InvalidKeySpecException,
+ InvalidKeyException, SignatureException {
+ if (dsa2 == null)
+ throw new IllegalStateException(
+ "no public key passed for verification");
+ dsa2.update(data.getBytes());
+ boolean verifies = false;
+ try {
+ if (signed==null) signed="";
+ verifies= dsa2.verify(getBytes(signed));
+ }
+ catch (Exception e)
+ {
+ verifies=false;
+ }
+ return verifies;
+ }
+
+public static Hashtable generateKeyPair() throws Exception {
+Hashtable table=new Hashtable();
+
+ KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");
+ gen.initialize(1024);
+ KeyPair kp = gen.generateKeyPair();
+ DSAPrivateKey privateKey = (DSAPrivateKey) kp.getPrivate();
+ String privateKeyEncoded=getString(privateKey.getEncoded());
+ table.put("privatekey",privateKeyEncoded);
+ //System.out.println("private:\n" + privateKeyEncoded);
+ DSAPublicKey publicKey = (DSAPublicKey) kp.getPublic();
+ String encodedPublicKey = getString(publicKey.getEncoded());
+ table.put("publickey",encodedPublicKey);
+ //System.out.println("public:\n" + encodedPublicKey);
+ // System.out.println("public key:\n"+kp.getPublic()+"\nprivate
+ // key:\n"+kp.getPrivate());
+
+ return table;
+ } public static void test() throws InvalidKeyException,
+ NoSuchAlgorithmException, InvalidKeySpecException,
+ SignatureException {
+ DSAHandler dsa = new DSAHandler(
+ "48-130-1-75-2-1-0-48-130-1-44-6-7-42-134-72-206-56-4-1-48-130-1-31-2-129-129-0-253-127-83-129-29-117-18-41-82-223-74-156-46-236-228-231-246-17-183-82-60-239-68-0-195-30-63-128-182-81-38-105-69-93-64-34-81-251-89-61-141-88-250-191-197-245-186-48-246-203-155-85-108-215-129-59-128-29-52-111-242-102-96-183-107-153-80-165-164-159-159-232-4-123-16-34-194-79-187-169-215-254-183-198-27-248-59-87-231-198-168-166-21-15-4-251-131-246-211-197-30-195-2-53-84-19-90-22-145-50-246-117-243-174-43-97-215-42-239-242-34-3-25-157-209-72-1-199-2-21-0-151-96-80-143-21-35-11-204-178-146-185-130-162-235-132-11-240-88-28-245-2-129-129-0-247-225-160-133-214-155-61-222-203-188-171-92-54-184-87-185-121-148-175-187-250-58-234-130-249-87-76-11-61-7-130-103-81-89-87-142-186-212-89-79-230-113-7-16-129-128-180-73-22-113-35-232-76-40-22-19-183-207-9-50-140-200-166-225-60-22-122-139-84-124-141-40-224-163-174-30-43-179-166-117-145-110-163-127-11-250-33-53-98-241-251-98-122-1-36-59-204-164-241-190-168-81-144-137-168-131-223-225-90-229-159-6-146-139-102-94-128-123-85-37-100-1-76-59-254-207-73-42-4-22-2-20-99-162-225-203-33-237-32-121-170-46-64-177-141-247-95-155-123-240-65-44",
+ "48-130-1-184-48-130-1-44-6-7-42-134-72-206-56-4-1-48-130-1-31-2-129-129-0-253-127-83-129-29-117-18-41-82-223-74-156-46-236-228-231-246-17-183-82-60-239-68-0-195-30-63-128-182-81-38-105-69-93-64-34-81-251-89-61-141-88-250-191-197-245-186-48-246-203-155-85-108-215-129-59-128-29-52-111-242-102-96-183-107-153-80-165-164-159-159-232-4-123-16-34-194-79-187-169-215-254-183-198-27-248-59-87-231-198-168-166-21-15-4-251-131-246-211-197-30-195-2-53-84-19-90-22-145-50-246-117-243-174-43-97-215-42-239-242-34-3-25-157-209-72-1-199-2-21-0-151-96-80-143-21-35-11-204-178-146-185-130-162-235-132-11-240-88-28-245-2-129-129-0-247-225-160-133-214-155-61-222-203-188-171-92-54-184-87-185-121-148-175-187-250-58-234-130-249-87-76-11-61-7-130-103-81-89-87-142-186-212-89-79-230-113-7-16-129-128-180-73-22-113-35-232-76-40-22-19-183-207-9-50-140-200-166-225-60-22-122-139-84-124-141-40-224-163-174-30-43-179-166-117-145-110-163-127-11-250-33-53-98-241-251-98-122-1-36-59-204-164-241-190-168-81-144-137-168-131-223-225-90-229-159-6-146-139-102-94-128-123-85-37-100-1-76-59-254-207-73-42-3-129-133-0-2-129-129-0-173-249-1-200-111-178-86-229-143-74-255-43-195-147-70-225-219-229-126-18-191-233-96-18-139-198-134-117-53-214-109-204-84-10-165-5-208-23-187-189-12-129-242-38-74-59-245-208-115-104-100-38-2-237-201-242-68-84-199-34-253-135-233-35-46-192-95-85-93-226-159-194-23-25-50-186-177-113-140-77-147-218-209-108-87-115-217-101-168-171-255-157-90-185-229-138-1-222-202-241-10-92-15-49-82-233-242-155-109-55-62-42-106-241-168-142-149-42-55-200-129-217-229-191-192-100-51-181");
+ String test = "abc";
+ System.out.println(dsa.verify(test, dsa.sign(test)));
+ test = "abc2";
+ System.out.println(dsa.verify(test, dsa.sign(test)));
+ }
+
+ public static void test_alt() {
+ try {
+ KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");
+ gen.initialize(1024);
+ KeyPair kp = gen.generateKeyPair();
+ DSAPrivateKey privateKey = (DSAPrivateKey) kp.getPrivate();
+ System.out.println("private:\n"
+ + getString(privateKey.getEncoded()));
+
+ String privateKeyEncoded = getString(privateKey.getEncoded());
+ //create Private Key Object
+ //X509EncodedKeySpec keyspec = new X509EncodedKeySpec(
+ // getBytes(privateKeyEncoded));
+ PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(
+ getBytes(privateKeyEncoded));
+ KeyFactory keyFactory = KeyFactory.getInstance("DSA");
+ PrivateKey privateKey2 = keyFactory.generatePrivate(keyspec);
+ System.out.println(privateKey2);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static void main(String[] a) {
+ try {
+ test();
+ // generateKeyPair();
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ System.out.println("Es ist ein Fehler aufgetreten: " + e);
+ }
+ }
+}
+
+//Created on 19.10.2006 at 16:16:00
diff --git a/src/de/memtext/util/DateUtils.java b/src/de/memtext/util/DateUtils.java
new file mode 100644
index 0000000..66b1ba0
--- /dev/null
+++ b/src/de/memtext/util/DateUtils.java
@@ -0,0 +1,209 @@
+package de.memtext.util;
+import java.sql.Date;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+/**
+ * Singleton which helps in Date Conversions
+ * ! Chaos manche Methode arbeiten mit java.util.Date manche mit java.sql.Date
+ */
+public class DateUtils {
+ protected static DateFormat df = new SimpleDateFormat("dd.MM.yy");
+ protected static DateFormat dfLong = new SimpleDateFormat("dd.MM.yyyy");
+
+ protected static DateFormat dfUS = new SimpleDateFormat("yyyy-MM-dd");
+ protected static DateFormat dfDateTimeUS =
+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+ //international Version 1.12.03 DateFormat.getDateInstance(DateFormat.SHORT);
+ protected static DateFormat dfTime = new SimpleDateFormat("hh:mm:ss");
+ protected static DateFormat dfDateTime =
+ new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
+
+ protected static DateFormat dfDay = new SimpleDateFormat("dd");
+ protected static DateFormat dfMonth = new SimpleDateFormat("MM");
+ protected static DateFormat dfYear = new SimpleDateFormat("yyyy");
+ /**
+ * static initializer
+ */
+ static {
+ df.setLenient(true);
+ dfLong.setLenient(false);
+ }
+
+ protected DateUtils() {
+ }
+ /**
+ * Gets the day as a String from a date
+ * @param date
+ * @return String in format dd
+ */
+ public static String getNowString()
+ {
+ return TimeUtils.getNowString();
+ }
+ public static String getDay(Date date) {
+ return dfDay.format(date);
+ }
+ public static String getMonth(Date date) {
+ return dfMonth.format(date);
+ }
+ public static String getYear(Date date) {
+ return dfYear.format(date);
+ }
+ public static String toCommaSeparatedList(Date date) {
+ return getDay(date) + "," + getMonth(date) + "," + getYear(date);
+ }
+ /**
+ * Can be used when sure, not Exception thrown
+ * @param datestr
+ * @return
+ */
+ public static java.util.Date create(String datestr)
+ {
+ java.util.Date d=null;
+ try {
+ d=parse(datestr);
+ } catch (ParseException e) {
+
+ }
+ return d;
+ }
+ /**
+ * Erwartet einen String im Format dd.mm.yyyy oder dd.mm.yy und gibt
+ * ein java.sql.Date Objekt zurück
+ * Aufruf Date x=DateUtils.parse("1.1.2000");
+ * wenn "" oder null übergeben wird, wird eine ParseException
+ * geworfen
+ */
+ public static Date parse(String dateStr) throws ParseException {
+ if (dateStr.equals("") || dateStr==null)
+ throw new ParseException("\"\" is unparseable", 0);
+ java.util.Date dt = df.parse(dateStr);
+ return new java.sql.Date(dt.getTime());
+
+ }
+ /**
+ * Erwartet einen String im Format dd.mm.yyyy oder dd.mm.yy und gibt
+ * ein java.sql.Date Objekt zurück
+ * Aufruf Date x=DateUtils.parse("1.1.2000");
+ * wenn "" oder null übergeben wird, wird eine ParseException
+ * geworfen
+ */
+ public static Date parseStrict(String dateStr) throws ParseException {
+ if (dateStr.equals("") || dateStr==null)
+ throw new ParseException("\"\" is unparseable", 0);
+ java.util.Date dt = dfLong.parse(dateStr);
+ return new java.sql.Date(dt.getTime());
+
+ }
+ /**
+ * Formatiert ein Date-Objekt als String in das Format dd.mm.yyyy
+ * Aufruf DateUtils.format(date);
+ */
+ public static String format(Date date) {
+ if (date == null)
+ return null;
+ else
+ return dfLong.format(date);
+ }
+
+ public static boolean isToday(String dateStr) throws ParseException
+ {
+ Date d=parse(dateStr);
+ return format(d).equals(format(new java.util.Date()));
+ }
+ public static boolean isValidDate(String dateString) {
+ boolean result = true;
+ try {
+ Date d = DateUtils.parse(dateString);
+ if (d.getYear()>10000) result=false;
+ } catch (ParseException e) {
+ result = false;
+ }
+ return result;
+ }
+ public static boolean isDateInFuture(Date date) {
+ return date.getTime()>new java.util.Date().getTime();
+ }
+ public static boolean isDateInFuture(java.util.Date date) {
+ return date.getTime()>new java.util.Date().getTime();
+ }
+ public static boolean isValidDateStrict(String dateString) {
+ boolean result = true;
+ try {
+ Date d = DateUtils.parseStrict(dateString);
+ if (d.getYear()>10000) result=false;
+ } catch (ParseException e) {
+ result = false;
+ }
+ return result;
+ }
+ /**
+ * Liefert das aktuelle Datum als String zurück.
+ * @return aktuelles Datum als String dd.mm.yyyy
+ */
+
+ public static String getTodayString() {
+ return format(new java.sql.Date(new java.util.Date().getTime()));
+
+ }
+ public static void main(String a[]) {
+
+
+
+ }
+ public static String formatGerman(java.util.Date date)
+ {
+ return DateFormat.getDateInstance(DateFormat.MEDIUM,java.util.Locale.GERMANY).format(date);
+ }
+ public static String formatUS(java.util.Date date) {
+ if (date == null)
+ return null;
+ else {
+ return dfUS.format(date);
+ }
+ }
+ public static java.util.Date dateTimeParse(String dateStr)
+ throws ParseException {
+ if (dateStr.equals("") || dateStr == null)
+ return null;
+ else
+ return dfDateTime.parse(dateStr);
+ }
+ /**
+ * Formatiert ein Date-Objekt als String in das Format dd.MM.yyyy HH:mm:ss
+ * Aufruf DateUtils.format(date);
+ */
+ public static String dateTimeFormat(java.util.Date date) {
+ if (date == null)
+ return null;
+ else
+ return dfDateTime.format(date);
+ }
+ /**
+ * Formartiert ein Date-Objekt als String in das Format yyyy-mm-dd
+ * @param date
+ * @return String yyyy-mm-dd
+ */
+ public static String dateTimeFormatUS(java.util.Date date) {
+ if (date == null)
+ return null;
+ else {
+ return dfDateTimeUS.format(date);
+ }
+ }
+ public static java.util.Date makeFutureDate(Date date, int daysLater)
+ {
+ Calendar dateOnCalendar = Calendar.getInstance();
+ dateOnCalendar.setTime(date);
+ dateOnCalendar.add(5, daysLater);
+ return dateOnCalendar.getTime();
+ }
+ public static String format(java.util.Date date) {
+ if (date == null)
+ return null;
+ else
+ return dfLong.format(date);
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/DialogElement.java b/src/de/memtext/util/DialogElement.java
new file mode 100644
index 0000000..902f75c
--- /dev/null
+++ b/src/de/memtext/util/DialogElement.java
@@ -0,0 +1,41 @@
+package de.memtext.util;
+import java.awt.FlowLayout;
+
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+public class DialogElement extends JPanel {
+
+ private JTextField ta;
+
+ public DialogElement(String lbltext) {
+ this(lbltext, null);
+ }
+ public DialogElement(String lbltext, Object element) {
+ this.setLayout(new FlowLayout());
+ this.add(new JLabel(lbltext));
+ int cols=10;
+ if (element!=null) cols=element.toString().length()+2;
+ ta = new JTextField(cols);
+ this.add(ta);
+ setElement(element);
+ }
+ public void setElement(Object element) {
+ if (element != null)
+ ta.setText(element.toString());
+ }
+ public Integer getIntegerValue() {
+ Integer erg = null;
+ try {
+ erg = new Integer(ta.getText());
+ } catch (Exception e) {
+ erg = null;
+ }
+ return erg;
+ }
+
+ public String getStringValue() {
+ String erg = ta.getText();
+ return erg;
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/EqualsUtil.java b/src/de/memtext/util/EqualsUtil.java
new file mode 100644
index 0000000..cf5d735
--- /dev/null
+++ b/src/de/memtext/util/EqualsUtil.java
@@ -0,0 +1,78 @@
+package de.memtext.util;
+
+/**
+* Collected methods which allow easy implementation of equals.
+*
+* Example use case in a class called Car:
+*
+public boolean equals(Object that){
+ //check for self-comparison
+ if ( this == aThat ) return true;
+
+ //use instanceof instead of getClass here for two reasons
+ //1. if need be, it can match any supertype, and not just one class;
+ //2. it renders an explict check for "that == null" redundant, since
+ //it does the check for null already - "null instanceof [type]" always
+ //returns false. (See Effective Java by Joshua Bloch.)
+ if ( !(aThat instanceof Car) ) return false;
+ //Alternative to the above line :
+ //if ( aThat == null || aThat.getClass() != this.getClass() ) return false;
+
+ Car thatCar = (Car)that;
+ return
+ EqualsUtil.areEqual(this.fName, that.fName) &&
+ EqualsUtil.areEqual(this.fNumDoors, that.fNumDoors) &&
+ EqualsUtil.areEqual(this.fGasMileage, that.fGasMileage) &&
+ EqualsUtil.areEqual(this.fColor, that.fColor) &&
+ Arrays.equals(this.fMaintenanceChecks, that.fMaintenanceChecks); //array!
+}
+*
+*
+* Arrays are not handled by this class.
+* This is because the Arrays.equals methods should be used for
+* array fields.
+*/
+public final class EqualsUtil {
+
+ static public boolean areEqual(boolean aThis, boolean aThat){
+ //System.out.println("boolean");
+ return aThis == aThat;
+ }
+
+ static public boolean areEqual(char aThis, char aThat){
+ //System.out.println("char");
+ return aThis == aThat;
+ }
+
+ static public boolean areEqual(long aThis, long aThat){
+ /*
+ * Implementation Note
+ * Note that byte, short, and int are handled by this method, through
+ * implicit conversion.
+ */
+ //System.out.println("long");
+ return aThis == aThat;
+ }
+
+ static public boolean areEqual(float aThis, float aThat){
+ //System.out.println("float");
+ return Float.floatToIntBits(aThis) == Float.floatToIntBits(aThat);
+ }
+
+ static public boolean areEqual(double aThis, double aThat){
+ //System.out.println("double");
+ return Double.doubleToLongBits(aThis) == Double.doubleToLongBits(aThat);
+ }
+
+ /**
+ * Possibly-null object field.
+ *
+ * Includes type-safe enumerations and collections, but does not include
+ * arrays. See class comment.
+ */
+ static public boolean areEqual(Object aThis, Object aThat){
+ //System.out.println("Object");
+ return aThis == null ? aThat == null : aThis.equals(aThat);
+ }
+}
+//Created on 21.03.2005 at 12:05:58
\ No newline at end of file
diff --git a/src/de/memtext/util/ExceptionHandler.java b/src/de/memtext/util/ExceptionHandler.java
new file mode 100644
index 0000000..8c7f710
--- /dev/null
+++ b/src/de/memtext/util/ExceptionHandler.java
@@ -0,0 +1,140 @@
+package de.memtext.util;
+
+import java.util.logging.Logger;
+
+import de.memtext.widgets.WarningMessage;
+
+/**
+* Helps to create an easy-to-use standard way to handle exceptions.
+* One can decide whether a GUI-message about the error is wanted (default),
+* but this can also be turned off (then you only get the error on the console).
+* Second, one can decide if a hard exit (System.exit) is wanted to stop
+* the program. The default is true, but in special cases or applets this
+* behaviour can be turned off as well.
+* Subclasses can add extra code to be executed by overriding doBeforeEnd()
+ */
+public class ExceptionHandler {
+ private boolean isApplication=true;
+ private WarningMessage warningMessage = new WarningMessage(null, "", "Problem");
+ private boolean withGui, isExitWanted;
+ private String additionalInfo;
+ private Logger logger;
+ /**
+ * Creats a default exception handler,
+ * which shows a gui-message and calls System.exit afterwards.
+ * *
+ */
+ public ExceptionHandler() {
+ this(true, true);
+ }
+ /**
+ * does hard exit
+ * @param withGui
+ */
+ public ExceptionHandler(boolean withGui) {
+ this(withGui, true);
+ }
+ public ExceptionHandler(boolean withGui, boolean isExitWanted) {
+ this.withGui = withGui;
+ this.isExitWanted = isExitWanted;
+ }
+
+ public void handle(Throwable e) {
+ handle("",e);
+ }
+ public void handle(String txt,Throwable e) {
+ String msg=e.toString()+" "+txt;
+ if (additionalInfo!=null) msg+="\n"+additionalInfo;
+ if (withGui) {
+ warningMessage.setMsg(msg);
+ warningMessage.show();
+ }
+ System.out.println(msg);
+ if (logger!=null) logger.severe(msg);
+ e.printStackTrace();
+ if (isExitWanted) {
+ doBeforeEnd();
+ if (isApplication) System.exit(1);
+ }
+ }
+
+ /**
+ * can be overriden to perfom some tasks before end
+ */
+ protected void doBeforeEnd() {
+ }
+
+ /**
+ * @return
+ */
+ public boolean isExitWanted() {
+ return isExitWanted;
+ }
+
+ /**
+ * @return
+ */
+ public boolean isWithGui() {
+ return withGui;
+ }
+
+ /**
+ * @param b
+ */
+ public void setExitWanted(boolean b) {
+ isExitWanted = b;
+ }
+
+ /**
+ * @param b
+ */
+ public void setWithGui(boolean b) {
+ withGui = b;
+ }
+
+ /**
+ * @return
+ */
+ public boolean isApplication() {
+ return isApplication;
+ }
+
+ /**
+ * @param b
+ */
+ public void setApplication(boolean b) {
+ isApplication = b;
+ }
+
+ public void clearAdditionalInfo()
+ {
+ additionalInfo=null;
+ }
+ /**
+ * @return
+ */
+ public String getAdditionalInfo() {
+ return additionalInfo;
+ }
+
+ /**
+ * Passes some additional information to the exception handler
+ * You can set it before special parts of your programms, if
+ * something goes wrong, not only the exception, but also the
+ * additional info is printed out.
+ * after the special part you can call clearAdditionalInfo
+ * @param info String with additional information
+ */
+ public void setAdditionalInfo(String info) {
+ additionalInfo = info;
+ }
+
+ public Logger getLogger() {
+ return logger;
+ }
+
+ public void setLogger(Logger logger) {
+ this.logger = logger;
+ }
+
+}
diff --git a/src/de/memtext/util/FMParser.java b/src/de/memtext/util/FMParser.java
new file mode 100644
index 0000000..fbdc47d
--- /dev/null
+++ b/src/de/memtext/util/FMParser.java
@@ -0,0 +1,46 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.util.HashMap;
+
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+
+public class FMParser {
+ protected static Configuration cfg = new Configuration();
+
+ public static void main(String[] args) {
+ if (args.length!=2)
+ {
+ System.err.println("FMParser Vorlage Outfile");
+ System.exit(1);
+ }
+ try {
+ File fvorlage=new File(args[0]);
+ File outfile=new File(args[1]);
+ cfg.setDirectoryForTemplateLoading(new File(fvorlage.getParent()));
+ //cfg.setWhitespaceStripping(true);
+ Template t = cfg.getTemplate(fvorlage.getName());
+
+
+ FileWriter out = new FileWriter(outfile);
+ //use FileWriter if you want output in a file
+ //new FileWriter("testoutput.txt");
+
+ // Merge the data-model and the template
+ t.process(new HashMap(), out);
+ out.close();
+ }
+ catch (Exception e)
+ {
+
+ System.err.println(e.toString());
+ System.exit(1);
+
+ }
+
+ }
+}
+
+//Created on 23.02.2006 at 09:19:39
\ No newline at end of file
diff --git a/src/de/memtext/util/FMProcessor.java b/src/de/memtext/util/FMProcessor.java
new file mode 100644
index 0000000..53eff4c
--- /dev/null
+++ b/src/de/memtext/util/FMProcessor.java
@@ -0,0 +1,168 @@
+package de.memtext.util;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.File;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.HashMap;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+
+import de.memtext.widgets.UneditableTextArea;
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+
+/**
+ * A Swing Gui which allows testing FreeMarker process actions. You specifity a
+ * template file
+ */
+public class FMProcessor extends JFrame {
+ protected Configuration cfg = new Configuration();
+ protected JTextField tfPath, tfTemplate;
+ protected JTextArea txtTemplate, txtResult;
+ private Object rootMap;
+
+ public FMProcessor(String title) {
+ super(title);
+ JPanel top = new JPanel();
+ top.add(new JLabel("Path:"));
+ tfPath = new JTextField(30);
+ top.add(tfPath);
+ top.add(new JLabel("Template:"));
+ tfTemplate = new JTextField(10);
+ top.add(tfTemplate);
+ JButton process = new JButton("process");
+ process.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+
+ process();
+ }
+ });
+ top.add(process);
+ this.getContentPane().add(top, BorderLayout.NORTH);
+ txtResult = new UneditableTextArea();
+ txtTemplate = new UneditableTextArea();
+
+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+ txtTemplate.setPreferredSize(new Dimension(screenSize.width / 2 - 100,
+ screenSize.height - 300));
+ JSplitPane jsp = new JSplitPane();
+ jsp.setLeftComponent(new JScrollPane(txtTemplate));
+ jsp.setRightComponent(new JScrollPane(txtResult));
+
+ this.getContentPane().add(jsp, BorderLayout.CENTER);
+
+ jsp.setDividerLocation(0.5);
+
+ this.addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent we) {
+ System.exit(0);
+ }
+ });
+ this.setSize(screenSize.width-50,screenSize.height-100);
+ }
+
+ /**
+ * Method for building the data model this is called before processing You
+ * can change or override it in subclasses
+ *
+ */
+ protected void buildDataModel() {
+ HashMap map = new HashMap();
+ map.put("DATABASE_ABBR", "PG");
+ map.put("MB_MACRO","<#macro mb> MB makro is there ");
+
+
+ //final command to set the root map that is to be used during
+ //processing
+ setRootMap(map);
+ }
+
+ /**
+ * set the root map that is to be used during processing
+ *
+ * @param rootMap
+ */
+ protected void setRootMap(Object rootMap) {
+ this.rootMap = rootMap;
+ }
+
+ /**
+ * First the data model is built, then the template is loaded, template and
+ * data are merge and the result is written to the right text pane
+ *
+ */
+ protected void process() {
+ try {
+ buildDataModel();
+ // Get the template object
+ File dir = new File(tfPath.getText());
+
+ cfg.setDirectoryForTemplateLoading(dir);
+ cfg.setWhitespaceStripping(true);
+ Template t = cfg.getTemplate(tfTemplate.getText());
+
+ Writer out = new StringWriter();
+ t.dump(out);
+ txtTemplate.setText(out.toString());
+ out.close();
+
+ out = new StringWriter();
+ //use FileWriter if you want output in a file
+ //new FileWriter("testoutput.txt");
+
+ // Merge the data-model and the template
+ t.process(rootMap, out);
+ out.close();
+
+ txtResult.setText(out.toString());
+ txtResult.setCaretPosition(0);
+ } catch (Exception e) {
+ JOptionPane.showMessageDialog(this, e.toString());
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Sets the default path that the gui should display
+ *
+ * @param path
+ */
+ protected void setDefaultPath(String path) {
+ tfPath.setText(path);
+ }
+
+ /**
+ * Default Template file that the Gui presents
+ *
+ * @param filename
+ */
+ protected void setDefaultTemplate(String filename) {
+ tfTemplate.setText(filename);
+ }
+
+ public static void main(String[] args) {
+ FMProcessor app = new FMProcessor("FMProcessor");
+ app.setDefaultPath("e:/mb/diss/workspace/SuperX");
+ app.setDefaultTemplate("test1.ftl");
+String x;
+
+ app.show();
+ }
+}
+
+//Created on 12.02.2005 at 11:57:39
diff --git a/src/de/memtext/util/FileDeleterThread.java b/src/de/memtext/util/FileDeleterThread.java
new file mode 100644
index 0000000..a1f1d01
--- /dev/null
+++ b/src/de/memtext/util/FileDeleterThread.java
@@ -0,0 +1,34 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.Iterator;
+
+/**
+ * Deletes a collection of files after a given amount of seconds
+ */
+public class FileDeleterThread extends Thread {
+ private Collection files;
+ private int secs;
+
+ public FileDeleterThread(Collection files, int secs) {
+ this.files = files;
+ this.secs = secs;
+ }
+
+ public void run() {
+ try {
+ Thread.sleep(secs * 1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ if (files!=null)
+ for (Iterator it = files.iterator(); it.hasNext();) {
+ File f = (File) it.next();
+ f.delete();
+ }
+ }
+
+}
+
+//Created on 27.10.2004 at 12:19:42
diff --git a/src/de/memtext/util/FileUtils.java b/src/de/memtext/util/FileUtils.java
new file mode 100644
index 0000000..90003c2
--- /dev/null
+++ b/src/de/memtext/util/FileUtils.java
@@ -0,0 +1,292 @@
+package de.memtext.util;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.Vector;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+/**
+* Functionality to add suffixes to filenames and to copy files
+*
+ */
+public class FileUtils {
+
+ // don't instantiate
+ private FileUtils() {
+ }
+
+ /**
+ * returns how old in minutes
+ * @param f
+ * @return
+ */
+ public static int getHowOld(File f)
+ {
+ long now=new java.util.Date().getTime();
+ return (int) ((now-f.lastModified())/(1000*60));
+ }
+
+ /**
+ * Removes the suffix of a filename
+ * For example getFileNameWithoutSuffix("test.txt") would return
+ * test
+ * @param String filename
+ * @return
+ */
+ public static String getFileNameWithoutSuffix(String filename) {
+ int index = filename.indexOf(".");
+ if (index == -1)
+ throw new IllegalArgumentException(filename + " doesn't contain .");
+ filename =filename.substring(0, index);
+
+
+ return filename;
+ }
+ /**
+ * Addes a suffix to a filename before the usual .
+ * For example addToEndOfFileName("test.txt","1") would return
+ * test1.txt
+ * @param String filename
+ * @param suffix
+ * @return
+ */
+ public static String addToEndOfFileName(String filename, String suffix) {
+ int index = filename.indexOf(".");
+ if (index == -1)
+ throw new IllegalArgumentException(filename + " doesn't contain .");
+ filename =
+ filename.substring(0, index)
+ + suffix
+ + filename.substring(index, filename.length());
+
+ return filename;
+ }
+
+
+
+ /**
+ *
+ * @param dir - directory to search in
+ * @param beginning - required beginning of file name, may be null
+ * @param endings - a single ending like .htm or more .htm|.html
+ * @return File[] - array only files, no directories are returned
+ */
+ static public File[] getFileList(File dir,String beginning,String endings)
+ {
+ FilenamesFilter filt=new FilenamesFilter(null,endings,beginning);
+ filt.setAllDirsAccepted(false);
+ return dir.listFiles(filt);
+ }
+ /**
+ * Creates a copy of a file
+ * @param String source
+ * @param String target
+ * @throws Exception
+ */
+ static public void copyFile(String source, String target)
+ throws IOException {
+ copyFile(new File(source), new File(target));
+ }
+ /**
+ * Creates a copy of a file
+ * @param File source
+ * @param File target
+ * @throws Exception
+ */
+ static public void copyFile(File source, File target) throws IOException {
+ FileInputStream is = null;
+ FileOutputStream os = null;
+
+ BufferedInputStream in = null;
+ BufferedOutputStream out = null;
+
+ try {
+ is = new FileInputStream(source);
+ os = new FileOutputStream(target);
+
+ in = new BufferedInputStream(is);
+ out = new BufferedOutputStream(os);
+
+ int buffer_size = 32768;
+ byte[] buffer = new byte[buffer_size];
+
+ int len = in.read(buffer, 0, buffer_size);
+ while (len != -1) {
+ out.write(buffer, 0, len);
+ len = in.read(buffer, 0, buffer_size);
+ }
+ in.close();
+ is.close();
+ out.close();
+ os.close();
+ } catch (FileNotFoundException fe) {
+ throw new FileNotFoundException(
+ "Die Datei " + source + " konnte nicht gefunden werden!");
+ } catch (IOException e) {
+ throw new IOException("Couldn't copy file " + e.toString());
+ }
+ }
+ public static void createZipFile(String pathToZipUp, String pathToSaveTo) {
+
+ createZipFile(pathToZipUp, "", pathToSaveTo);
+ }
+
+ public static void createZipFile(
+ String pathToZipUp,
+ String relPath,
+ String pathToSaveTo) {
+ try {
+ FileOutputStream fos = new FileOutputStream(pathToSaveTo);
+ ZipOutputStream zos = new ZipOutputStream(fos);
+
+ zos.setMethod(ZipOutputStream.DEFLATED);
+
+ if (!relPath.equals("")&&pathToZipUp.lastIndexOf("\\") + 1 != pathToZipUp.length())
+ pathToZipUp += "\\";
+ System.out.println(pathToZipUp + relPath);
+ File f = new File(pathToZipUp + relPath);
+ String[] files = f.list();
+ if (pathToZipUp.lastIndexOf("\\") + 1 != pathToZipUp.length())
+ pathToZipUp += "\\";
+ for (int y = 0; y < files.length; y++) {
+ //build fully qualified path for each file in directory
+ //check for / at the end of the path
+ String fullpath = pathToZipUp;
+ if (!relPath.equals(""))
+ fullpath += relPath + "\\";
+ fullpath += files[y];
+ File aFile = new File(fullpath);
+
+ if (aFile.isDirectory()) {
+ //recursive call to include all files in the subdirectories
+ // Vector subDir = new Vector();
+ // subDir.addElement(fullpath);
+ if (relPath.equals(""))
+ relPath = files[y];
+ else
+ relPath += "\\" + files[y];
+ createZipFile(fullpath, relPath, pathToSaveTo);
+ } else {
+ byte[] temp = new byte[files[y].length()];
+
+ try {
+ FileInputStream fis = new FileInputStream(aFile);
+
+ CRC32 crc32 = new CRC32();
+ int n;
+
+ while ((n = fis.read(temp)) > -1) {
+ crc32.update(temp, 0, n);
+ }
+
+ fis.close();
+ String shortName =
+ files[y].substring(fullpath.length());
+ ZipEntry ze = new ZipEntry(shortName);
+ ze.setSize(aFile.length());
+ ze.setTime(aFile.lastModified());
+ ze.setCrc(crc32.getValue());
+ zos.putNextEntry(ze);
+ fis = new FileInputStream(aFile);
+
+ while ((n = fis.read(temp)) > -1) {
+ zos.write(temp, 0, n);
+ }
+
+ fis.close();
+ zos.closeEntry();
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ }
+ } //end for loop
+ zos.close();
+
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return;
+ }
+ public static void main(String a[]) {
+ List l=getFileList("/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf","mo*.xsl,g*.xsl");
+ for (Iterator it=l.iterator();it.hasNext();)
+ {
+ System.out.println(it.next());
+ }
+ }
+ public static void download(URL url,File targetFile) throws IOException {
+ URLConnection conn = url.openConnection();
+ InputStream inStream = conn.getInputStream();
+ FileOutputStream os = new FileOutputStream(targetFile);
+
+ BufferedInputStream bufferedInStream = new BufferedInputStream(inStream);
+ BufferedOutputStream bufferedOutStream = new BufferedOutputStream(os);
+
+ int buffer_size = 32768;
+ byte[] buffer = new byte[buffer_size];
+
+ int len = inStream.read(buffer, 0, buffer_size);
+ while (len != -1) {
+ bufferedOutStream.write(buffer, 0, len);
+ len = bufferedInStream.read(buffer, 0, buffer_size);
+ }
+ bufferedInStream.close();
+ inStream.close();
+ bufferedOutStream.close();
+ os.close();
+ }
+ public static String removeProblemChars(String name) {
+ String result=name.replace('\\','-');
+ result=result.replace('/','-');
+ result=StringUtils.replace(result, " - ", "-");
+ result=StringUtils.replace(result, " -", "-");
+ result=StringUtils.replace(result, "- ", "-");
+ result=result.replace(' ','_');
+ result=result.replace('*','_');
+ result=result.replace('?','_');
+ result=result.replace(',','_');
+ return result;
+ }
+
+ public static List getFileList(String dir,String regex)
+ {
+ List resultFiles=new LinkedList();
+ File fDir = new File(dir);
+ File[] files = fDir.listFiles();
+
+ StringTokenizer st=new StringTokenizer(regex,",");
+ while (st.hasMoreTokens())
+ {
+ String pattern=st.nextToken();
+ pattern=pattern.replace(".", "\\."); //escape the dot first
+ pattern=pattern.replace("?", ".?").replace("*", ".*");
+
+ for (File file : files) {
+ if (file.getName().matches(pattern)) resultFiles.add(file);
+ }
+ }
+ return resultFiles;
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/FilenamesFilter.java b/src/de/memtext/util/FilenamesFilter.java
new file mode 100644
index 0000000..5525bb7
--- /dev/null
+++ b/src/de/memtext/util/FilenamesFilter.java
@@ -0,0 +1,67 @@
+package de.memtext.util;
+
+import java.io.File;
+import javax.swing.filechooser.FileFilter;
+import java.util.StringTokenizer;
+/**
+ * A FilenameFilter which filters one or more endings.
+ */
+public class FilenamesFilter extends FileFilter implements java.io.FileFilter{
+ private String description, endings,beginning;
+ private boolean isAllDirsAccepted=true;
+ /**
+ * endings e.g. ".gif" or ".gif|.jpg|.bmp"
+ * @param endings
+ */
+ public FilenamesFilter(String description, String endings) {
+ this(description,endings,null);
+ }
+
+ public FilenamesFilter(String description, String endings,String beginning) {
+ this.description = description;
+ this.endings = endings;
+ this.beginning=beginning;
+ }
+
+ public boolean accept(File file) {
+ boolean result = false;
+ if (file.isDirectory()&&isAllDirsAccepted) result=true;
+ if (beginning==null)
+ {
+ if (isEndingOk(file.getName()))
+ result=true;
+ }
+ else
+ { if (file.getName().startsWith(beginning)&&isEndingOk(file.getName()))
+ result=true;
+ }
+
+ return result;
+
+ }
+ private boolean isEndingOk(String filename)
+ {
+ boolean result=false;
+ for (StringTokenizer st = new StringTokenizer(endings, "|");
+ st.hasMoreTokens();
+ ) {
+ String ending = st.nextToken();
+ if (filename.endsWith(ending)) {
+ result = true;
+ break;
+ }
+ }
+ return result;
+ }
+ public String getDescription() {
+ return description;
+ }
+ public boolean isAllDirsAccepted() {
+ return isAllDirsAccepted;
+ }
+ public void setAllDirsAccepted(boolean isDirAccepted) {
+ this.isAllDirsAccepted = isDirAccepted;
+ }
+}
+
+//Created on 14.05.2004 at 14:29:47
\ No newline at end of file
diff --git a/src/de/memtext/util/FontUtils.java b/src/de/memtext/util/FontUtils.java
new file mode 100644
index 0000000..cd781c1
--- /dev/null
+++ b/src/de/memtext/util/FontUtils.java
@@ -0,0 +1,14 @@
+package de.memtext.util;
+
+import java.awt.Font;
+
+public final class FontUtils {
+ public static final Font SANSSERIF10=new Font("SansSerif",Font.PLAIN,10);
+ public static final Font SANSSERIF12=new Font("SansSerif",Font.PLAIN,12);
+public static final Font SANSSERIF14BOLD=new Font("SansSerif",Font.BOLD,14);
+ private FontUtils() {
+ }
+
+}
+
+//Created on 18.03.2004 at 10:09:38
\ No newline at end of file
diff --git a/src/de/memtext/util/FreeMarkerApp.java b/src/de/memtext/util/FreeMarkerApp.java
new file mode 100644
index 0000000..d0697c9
--- /dev/null
+++ b/src/de/memtext/util/FreeMarkerApp.java
@@ -0,0 +1,52 @@
+package de.memtext.util;
+import java.util.*;
+import java.io.*;
+import freemarker.template.*;
+
+/**
+ * This application does not do anything useful, just prints "Hello World!" as a
+ * message from FreeMarker.
+ */
+public class FreeMarkerApp {
+ private Configuration cfg;
+
+ public FreeMarkerApp() {
+ // - Create a configuration instance
+ cfg = new Configuration();
+ }
+
+ protected void process()
+ {
+ try {
+ // Build the data-model
+ Map root = new HashMap();
+ root.put("message", "Hello World!");
+
+ // Get the template object
+
+ String tt="Here's a special message from FreeMarker for you\n ${message}\n That's all folks!";
+
+ Template t = new Template("text",new StringReader(tt),cfg);
+
+
+ Writer out = new StringWriter();
+ //use FileWriter if you want output in a file
+ //new FileWriter("testoutput.txt");
+
+ // Merge the data-model and the template
+
+ t.process(root, out);
+ out.close();
+
+ System.out.println(out.toString());
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static void main(String args[])
+ {
+ FreeMarkerApp app=new FreeMarkerApp();
+ app.process();
+}
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/GetOpts.java b/src/de/memtext/util/GetOpts.java
new file mode 100644
index 0000000..2231ea9
--- /dev/null
+++ b/src/de/memtext/util/GetOpts.java
@@ -0,0 +1,152 @@
+package de.memtext.util;
+
+import java.util.StringTokenizer;
+
+/**
+ * Method to analyse
+ */
+public class GetOpts {
+ private static String[] arguments = null;
+
+ //don't instantiate
+ private GetOpts() {
+
+ }
+
+ /**
+ * If you pass the arguments you want to analyse to this static helper class
+ * using setOpts, you can later use the short form of the methods e.g.
+ * isPresent(String option) without having to pass the arguments again.
+ *
+ * @param args
+ */
+ public static void setOpts(String args[]) {
+ arguments = args;
+ }
+
+ /**
+ * checks if the arguments passed before by setOpts contain the given option
+ *
+ * @param String
+ * option
+ * @return true if arguments contain the option, i.e. one String which
+ * starts with the option-String
+ */
+ public static boolean isPresent(String option) {
+ if (arguments == null)
+ throw new IllegalStateException(
+ "must either use setOpts before or call the long version of this method");
+ return isPresent(arguments, option);
+ }
+
+ /**
+ * checks if the arguments contain the given option
+ *
+ * @param args
+ * @param String
+ * option
+ * @return true if arguments contain the option, i.e. one String which
+ * starts with the option-String
+ */
+ public static boolean isPresent(String args[], String option) {
+ boolean result = false;
+ for (int i = 0; i < args.length; i++)
+ if (args[i] != null && args[i].startsWith(option))
+ result = true;
+ return result;
+ }
+
+ /**
+ * Gets a named option from the arguments passed before with setOps. E.g.
+ * getOpt("--log") would return the "--log:true" in the arguments
+ *
+ * @param option -
+ * name/start of the option
+ * @return String whole option
+ */
+ public static String getOpt(String option) {
+ if (arguments == null)
+ throw new IllegalStateException(
+ "must either use setOpts before or call the long version of this method");
+ return getOpt(option, arguments);
+ }
+
+ /**
+ * Gets a named option from the arguments. E.g. getOpt("--log") would return
+ * the "--log:true" in the arguments
+ *
+ * @param option -
+ * name/start of the option
+ * @return String whole option
+ */
+ public static String getOpt(String option, String args[]) {
+ if (args == null)
+ throw new IllegalStateException("args must not be null");
+ String result = null;
+ for (int i = 0; i < args.length; i++)
+ if (args[i].startsWith(option))
+ result = args[i];
+ if (result == null)
+ throw new RuntimeException("Option " + option + " not found!");
+ return result;
+ }
+
+ /**
+ * Gets the value of an option from the arguments passed before with setOpts
+ * if for example, you ask getValue("--log:") and the arguments passed
+ * before with setOpts contain a String "--log:true") "true" is returned
+ *
+ * @param String
+ * option
+ * @return String value of the option
+ */
+ public static String getValue(String option) {
+ if (arguments == null)
+ throw new IllegalStateException(
+ "must either use setOpts before or call the long version of this method");
+ return getValue(option, arguments);
+ }
+
+ /**
+ * Gets the value of an option, if for example, you ask getValue("--log:")
+ * and the arguments passed before with setOpts contain a String
+ * "--log:true") "true" is returned
+ *
+ * @param String
+ * option
+ * @return String value of the option
+ */
+ public static String getValue(String option, String args[]) {
+ String result = "";
+ String raw = getOpt(option, args);
+ int pos = option.length();
+ if (raw.charAt(pos) == ':')
+ pos++;
+ result = raw.substring(pos, raw.length());
+ return result;
+ }
+
+ /**
+ * Prüft, ob alle notwendigen Optionen angegeben sind, z.B. String
+ * "-loggingProperties:,-dbProperties" übergeben, die beiden müssen dabei
+ * sein
+ *
+ * @param options
+ * z.B. "-loggingProperties:,-dbProperties,..."
+ * @return null - alles OK, ansonsten String mit den fehlenden Optionen
+ */
+ public static String isAllRequiredOptionsPresent(String options) {
+ String result = null;
+ StringTokenizer st = new StringTokenizer(options, ",");
+ for (; st.hasMoreTokens();) {
+ String optionName = st.nextToken();
+ if (!isPresent(optionName)) {
+ if (result == null)
+ result = optionName;
+ else
+ result += "," + optionName;
+ }
+ }
+ return result;
+ }
+}
diff --git a/src/de/memtext/util/HashCodeUtil.java b/src/de/memtext/util/HashCodeUtil.java
new file mode 100644
index 0000000..1c0d103
--- /dev/null
+++ b/src/de/memtext/util/HashCodeUtil.java
@@ -0,0 +1,119 @@
+package de.memtext.util;
+import java.lang.reflect.Array;
+
+/**
+* Collected methods which allow easy implementation of hashCode.
+*
+* Example use case:
+*
+* public int hashCode(){
+* int result = HashCodeUtil.SEED;
+* //collect the contributions of various fields
+* result = HashCodeUtil.hash(result, fPrimitive);
+* result = HashCodeUtil.hash(result, fObject);
+* result = HashCodeUtil.hash(result, fArray);
+* return result;
+* }
+*
+*/
+public final class HashCodeUtil {
+
+ /**
+ * An initial value for a hashCode, to which is added contributions
+ * from fields. Using a non-zero value decreases collisons of hashCode
+ * values.
+ */
+ public static final int SEED = 23;
+ private static boolean isDebug=false;
+
+ /**
+ * booleans.
+ */
+ public static int hash( int aSeed, boolean aBoolean ) {
+if (isDebug) System.out.println("boolean...");
+ return firstTerm( aSeed ) + ( aBoolean ? 1 : 0 );
+ }
+
+ /**
+ * chars.
+ */
+ public static int hash( int aSeed, char aChar ) {
+ if (isDebug) System.out.println("char...");
+ return firstTerm( aSeed ) + (int)aChar;
+ }
+
+ /**
+ * ints.
+ */
+ public static int hash( int aSeed , int aInt ) {
+ /*
+ * Implementation Note
+ * Note that byte and short are handled by this method, through
+ * implicit conversion.
+ */
+ if (isDebug) System.out.println("int...");
+ return firstTerm( aSeed ) + aInt;
+ }
+
+ /**
+ * longs.
+ */
+ public static int hash( int aSeed , long aLong ) {
+ if (isDebug) System.out.println("long...");
+ return firstTerm(aSeed) + (int)( aLong ^ (aLong >>> 32) );
+ }
+
+ /**
+ * floats.
+ */
+ public static int hash( int aSeed , float aFloat ) {
+ return hash( aSeed, Float.floatToIntBits(aFloat) );
+ }
+
+ /**
+ * doubles.
+ */
+ public static int hash( int aSeed , double aDouble ) {
+ return hash( aSeed, Double.doubleToLongBits(aDouble) );
+ }
+
+ /**
+ * aObject is a possibly-null object field, and possibly an array.
+ *
+ * If aObject is an array, then each element may be a primitive
+ * or a possibly-null object.
+ */
+ public static int hash( int aSeed , Object aObject ) {
+ int result = aSeed;
+ if ( aObject == null) {
+ result = hash(result, 0);
+ }
+ else if ( ! isArray(aObject) ) {
+ result = hash(result, aObject.hashCode());
+ }
+ else {
+ int length = Array.getLength(aObject);
+ for ( int idx = 0; idx < length; ++idx ) {
+ Object item = Array.get(aObject, idx);
+ //recursive call!
+ result = hash(result, item);
+ }
+ }
+ return result;
+ }
+
+
+ /// PRIVATE ///
+ private static final int fODD_PRIME_NUMBER = 37;
+
+ private static int firstTerm( int aSeed ){
+ return fODD_PRIME_NUMBER * aSeed;
+ }
+
+ private static boolean isArray(Object aObject){
+ return aObject.getClass().isArray();
+ }
+}
+
+
+//Created on 21.03.2005 at 11:57:34
\ No newline at end of file
diff --git a/src/de/memtext/util/HideThread.java b/src/de/memtext/util/HideThread.java
new file mode 100644
index 0000000..4b4490b
--- /dev/null
+++ b/src/de/memtext/util/HideThread.java
@@ -0,0 +1,24 @@
+package de.memtext.util;
+
+import java.awt.Window;
+
+public class HideThread extends Thread
+{
+ private int secs;
+ private Window w;
+ public HideThread(Window w,int secs)
+ {
+ this.secs=secs;
+ this.w=w;
+ }
+ public void run()
+ {
+ try {
+ Thread.sleep(secs*1000);
+ if (w.isVisible()) w.hide();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+}
+//Created on 11.10.2004 at 09:58:39
\ No newline at end of file
diff --git a/src/de/memtext/util/HsqlUtils.java b/src/de/memtext/util/HsqlUtils.java
new file mode 100644
index 0000000..2c59fde
--- /dev/null
+++ b/src/de/memtext/util/HsqlUtils.java
@@ -0,0 +1,66 @@
+package de.memtext.util;
+
+import java.text.FieldPosition;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+/**
+ * Helping methods for work with hsql
+ */
+public class HsqlUtils {
+/**
+ * HsqlUtils constructor comment.
+ */
+
+ private static SimpleDateFormat AmericanDateFormat=new SimpleDateFormat("yyyy-MM-dd");
+
+private HsqlUtils() {
+}
+public static String adapt(String in)
+{
+ String result=in;
+ if (result!=null) result=result.replaceAll("'","''");
+ return result;
+}
+public static String test()
+{
+ return "'test'";
+}
+/**
+ * Gets a date String in the format needed by Hsql
+ * @param dateStr - String to be transformed (e.g. "1.1.2004")
+ * @return String - in the format for Hsql ("01-01-2004")
+ */
+public static String getDateForHsql(String dateStr)
+{
+ Date date=null;
+ try
+ {
+ date=de.memtext.util.DateUtils.parse(dateStr);
+ }
+ catch (Exception e)
+ {
+ System.out.println(e.toString());
+ }
+ return getDateForHsql(date);
+}
+/**
+* Gets a date String in the format needed by Hsql
+
+ * @param Date - java.util.Date object to be transformed
+ * @return String - in the format for Hsql ("01-01-2004")
+ */
+public static String getDateForHsql(Date date)
+{
+ StringBuffer result=new StringBuffer("'");
+ if (date!=null)
+ {
+ AmericanDateFormat.format(date,result,new FieldPosition(0));
+ result.append("'");
+ }
+ return date==null?null:result.toString();
+}
+public static void main(String a[])
+{
+ System.out.println(getDateForHsql("1.1.2000"));
+}
+}
diff --git a/src/de/memtext/util/HtmlUtils.java b/src/de/memtext/util/HtmlUtils.java
new file mode 100644
index 0000000..7536f2d
--- /dev/null
+++ b/src/de/memtext/util/HtmlUtils.java
@@ -0,0 +1,69 @@
+/*
+ * Created on 01.08.2003
+
+ */
+package de.memtext.util;
+
+import java.applet.Applet;
+
+/**
+ * helping methods for HTML
+ */
+public class HtmlUtils {
+/**
+ * Incomplete method which transforms java escape sequences into Html
+ * e.g. \n to
+ * @param txt
+ * @return
+ */
+public static String adapt(StringBuffer txt)
+{
+ if (txt==null) return null;
+ StringUtils.replace(txt,"\n","
");
+ StringUtils.replace(txt,"ä","ä");
+ StringUtils.replace(txt,"Ä","Ä");
+ StringUtils.replace(txt,"ö","ö");
+ StringUtils.replace(txt,"Ö","Ö");
+ StringUtils.replace(txt,"ü","ü");
+ StringUtils.replace(txt,"Ü","Ü");
+ StringUtils.replace(txt,"ß","ß");
+ return txt.toString();
+}
+/**
+ * Incomplete method which transforms java escape sequences into Html
+ * e.g. \n to
+ * @param txt
+ * @return
+ */
+public static String adapt(String txt)
+{
+ String result=null;
+ if (txt!=null) result=adapt(new StringBuffer(txt));
+ return result;
+}
+/*
+ * the docBase shouldn't contain the html file that holds the applet some
+ * browsers don't behave accordingly, trying to correct that here
+ */
+public static String getCorretDocBase(Applet applet) {
+ String docBase = applet.getDocumentBase().toString();
+
+ if (docBase.indexOf(".htm") > 0 || docBase.indexOf(".jsp") > 0|| docBase.indexOf(".jnlp")>0) {
+ int posSeparator = docBase.lastIndexOf("/");
+ // System.out.print("correcting docbase: shouldn't be "+docBase);
+ // System.out.print( "INFO: korrigiere docbase: sollte nicht " +
+ // docBase + " sein");
+ docBase = docBase.substring(0, posSeparator + 1);
+ // System.out.println(" sondern " + docBase);
+ }
+ if (!docBase.substring(docBase.length() - 1, docBase.length()).equals(
+ "/")) {
+ //System.out.println( "docBase doesn't end with /, " + docBase + "
+ // trying to correct it by clipping");
+ int posSeparator = docBase.lastIndexOf("/");
+ docBase = docBase.substring(0, posSeparator + 1);
+ // System.out.println(docBase);
+ }
+ return docBase;
+}
+}
diff --git a/src/de/memtext/util/IconUtils.java b/src/de/memtext/util/IconUtils.java
new file mode 100644
index 0000000..cfff7ff
--- /dev/null
+++ b/src/de/memtext/util/IconUtils.java
@@ -0,0 +1,23 @@
+package de.memtext.util;
+
+import javax.swing.ImageIcon;
+
+public class IconUtils {
+ private static ClassLoader cl;
+ static {
+ IconUtils s = new IconUtils();
+ cl = s.getClass().getClassLoader();
+ }
+ /**
+ * See StandardIcons
+ *
+ */
+ private IconUtils() {
+ super();
+ }
+ public static ImageIcon get(String pathAndName) {
+ return new ImageIcon(cl.getResource(pathAndName));
+ }
+}
+
+//Created on 29.02.2004 at 15:01:39
\ No newline at end of file
diff --git a/src/de/memtext/util/JDomUtils.java b/src/de/memtext/util/JDomUtils.java
new file mode 100644
index 0000000..a3c75b7
--- /dev/null
+++ b/src/de/memtext/util/JDomUtils.java
@@ -0,0 +1,66 @@
+/*
+ * Created on 20.06.2003
+ *
+ * To change the template for this generated file go to
+ * Window>Preferences>Java>Code Generation>Code and Comments
+ */
+package de.memtext.util;
+/*
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import org.jdom.Document;
+import org.jdom.JDOMException;
+import org.jdom.input.DOMBuilder;
+import org.jdom.input.SAXBuilder;
+*/
+/**
+ * @author MB
+ *
+ watch OUT FOR EXCEPTION!
+ */
+public class JDomUtils extends ObjectWithExceptionHandler {
+
+ /**
+ *
+
+ private JDomUtils() {
+
+ }
+ public static Document build(String xmlfile) {
+ SAXBuilder builder = new SAXBuilder();
+ Document doc = null;
+ try {
+ doc = builder.build(new File(xmlfile));
+ } catch (JDOMException e) {
+ // handle(e);
+ } catch (IOException e) {
+ // handle(e);
+ }
+ return doc;
+ }
+ public static Document build(org.w3c.dom.Document domDocument) {
+ DOMBuilder builder = new DOMBuilder();
+ System.out.println(domDocument.getDoctype());
+ Document doc = builder.build(domDocument);
+ return doc;
+ }
+ public static void saveXML(Document doc, String filename) {
+ org.jdom.output.XMLOutputter out =
+ new org.jdom.output.XMLOutputter(" ", true, "ISO-8859-1");
+ out.setTextNormalize(true);
+ BufferedWriter bw;
+ try {
+ bw = new BufferedWriter(new FileWriter(filename));
+ if (doc!=null&&doc.getDocType()!=null) out.output(doc.getDocType(), bw);
+ out.output(doc, bw);
+ bw.close();
+ } catch (IOException e) {
+ // handle(e);
+ }
+
+ }
+ */
+}
diff --git a/src/de/memtext/util/JarUtils.java b/src/de/memtext/util/JarUtils.java
new file mode 100644
index 0000000..c55d644
--- /dev/null
+++ b/src/de/memtext/util/JarUtils.java
@@ -0,0 +1,58 @@
+/*
+ * Created on 12.08.2003
+ *
+ * To change the template for this generated file go to
+ * Window>Preferences>Java>Code Generation>Code and Comments
+ */
+package de.memtext.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.jar.JarFile;
+import java.util.zip.ZipEntry;
+
+/**
+ DOESN'T WORK
+ */
+public class JarUtils {
+
+ /**
+ *
+ */
+ private JarUtils() {
+ }
+public static ZipEntry getEntry(String jarfile,String sourcefile) throws IOException
+{
+ File jf=new File(jarfile);
+ JarFile jf2=new JarFile(jf);
+ ZipEntry entry=jf2.getEntry(sourcefile);
+ if (entry!=null) throw new IOException("Entry "+sourcefile+" not found in jar: "+jarfile);
+return entry;
+}
+/**
+ * format xx.jar:file.zzz
+ * @param url
+ * @return
+ */
+public static InputStream getInputStream(String url) throws IOException
+{
+int colonpos=url.indexOf(':');
+if (colonpos==-1) throw new IllegalArgumentException("format must be xx.jar:file.zzz");
+String jarfile=url.substring(0,colonpos);
+String sourcefile=url.substring(colonpos+1);
+return getInputStream(jarfile,sourcefile);
+}
+public static InputStream getInputStream(String jarfile,String sourcefile) throws IOException
+{
+ File jf=new File(jarfile);
+ if (!jf.canRead()) throw new IOException("Cannot read from file "+jarfile);
+ JarFile jf2=new JarFile(jf);
+ ZipEntry entry=jf2.getEntry(sourcefile);
+ if (entry!=null) throw new IOException("Entry "+sourcefile+" not found in jar: "+jarfile);
+
+
+ return jf2.getInputStream(entry);
+
+}
+}
diff --git a/src/de/memtext/util/LicenseTester.java b/src/de/memtext/util/LicenseTester.java
new file mode 100644
index 0000000..4beb207
--- /dev/null
+++ b/src/de/memtext/util/LicenseTester.java
@@ -0,0 +1,147 @@
+package de.memtext.util;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+
+
+public class LicenseTester {
+
+ private LicenseTester() {
+ }
+
+
+ private static double[][] versionCodes = { { 0.9, 56 },{ 1.0, 456 }, { 1.1, 1785 },
+ { 1.2, 2004 }, {2.0, 204 } };
+/**
+ *
+ * @param softwareId //100 Situ, 200 Joolap
+ * @param version
+ * @param eing
+ * @return
+ */
+ public static boolean isOk(int softwareId, double version,String eing) {
+ //100 Situ
+ boolean result = false;
+ try {
+ String name = eing.substring(0, eing.indexOf('*'));
+ String code = eing.substring(eing.indexOf('*') + 1);
+ String nameCode=code.substring(0,code.indexOf('*'));
+ String versionCode=code.substring(code.indexOf('*') + 1);
+ if (nameCode.equals(encryptName(softwareId,name)))
+ {
+ if (version<=getVersion(softwareId,name,versionCode))
+ result=true;
+ }
+ //if (code.equals(encrypt(softwareId,name))
+ // result = true;
+ } catch (Exception e) {
+ }
+ return result;
+ }
+/**
+ *
+ * @param softwareId //100 Situ, 200 Joolap
+ * @param version
+ * @param name
+ * @return
+ */
+ private static String encrypt(int softwareId, double version, String name) {
+ return name+"*"+encryptName(softwareId,name)+"*"+encryptVersion(softwareId,name,version);
+ }
+// 100 Situ, 200 Joolap
+ private static double getVersion(int softwareId, String name,
+ String encryptedVersionString) {
+ double version = -1;
+ try {
+ int sum = Integer.parseInt(encryptedVersionString);
+
+ sum += 42373;
+
+ if (sum % 1573!=0) sum=-1;
+ sum /= 1573;
+
+ sum -= getNameSum(softwareId, name);
+ for (int i = 0; i < versionCodes.length; i++) {
+ if (versionCodes[i][1] == sum)
+ version = versionCodes[i][0];
+ }
+
+ } catch (NumberFormatException e) {
+ // do nothing
+ }
+ return version;
+
+ }
+// 100 Situ, 200 Joolap
+ private static String encryptVersion(int softwareId, String name,
+ double version) {
+ double versionCode = -1;
+ for (int i = 0; i < versionCodes.length; i++) {
+ if (versionCodes[i][0] == version)
+ versionCode = versionCodes[i][1];
+ }
+ if (versionCode == -1)
+ throw new IllegalArgumentException(
+ "cannot encrypt -no version code found in class LicenceTester");
+ int sum = (int) (getNameSum(softwareId, name) + versionCode);
+ sum *= 1573;
+ sum -= 42373;
+ return "" + sum;
+ }
+// 100 Situ, 200 Joolap
+ private static String encryptName(int softwareId, String name) {
+ int sum = getNameSum(softwareId, name);
+ return (sum + 1308) + "-" + sum + "-" + (sum * 2);
+ }
+// 100 Situ, 200 Joolap
+ private static int getNameSum(int softwareId, String name) {
+ int sum = 1308;
+ for (int i = 0; i < name.length(); i++) {
+ sum += name.charAt(i);
+ }
+ sum += softwareId*13;
+ return sum;
+ }
+
+ private static void batch(String filename)
+ {
+ try {
+ FileReader fr=new FileReader(new File(filename));
+ BufferedReader bfr = new BufferedReader(fr);
+ String line;
+ StringBuffer result=new StringBuffer();
+ while ((line = bfr.readLine()) != null) {
+ //100 Situ, 200 Joolap
+
+ String crpt = encrypt(200, 1.1,line);
+ System.out.println(crpt);
+
+
+ }
+ bfr.close();
+ fr.close();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+ public static void main(String args[]) {
+ // batch("e:/mb/Arbeit/FIRMA/joolap/LizenznehmerBW.txt");
+ String test = "SZST";
+ System.out.println(encrypt(100,0.9,test));
+ System.out.println("Ok:"+isOk(100,0.9d,"VPS*4165-2857-5714*4539776"));
+ //100 Situ, 200 Joolap
+ test="Hochschule Karlsruhe";
+ String crpt = encrypt(200, 1.1,test);
+ System.out.println(crpt);
+
+
+ System.out.println(isOk(200,0.9,crpt));
+
+
+ }
+}
+
+//Created on 09.07.2004 at 16:18:56
diff --git a/src/de/memtext/util/LogUtils.java b/src/de/memtext/util/LogUtils.java
new file mode 100644
index 0000000..21553a4
--- /dev/null
+++ b/src/de/memtext/util/LogUtils.java
@@ -0,0 +1,170 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.FileHandler;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+
+/**
+ *
+ * helping methods for using the java.util.logging system
+ */
+public class LogUtils {
+ private static ConsoleHandler rawConsoleHandler = new ConsoleHandler();
+ static {
+ RawFormatter rf = new RawFormatter();
+ rf.setTimeWanted(true);
+ rawConsoleHandler.setFormatter(rf);
+ }
+
+ private LogUtils() {
+ }
+
+ /**
+ * Inits a logger to print out on the console only the actually logged text
+ * (no time&date) and sets the level to Warning.
+ *
+ * @param loggername
+ */
+ public static void initRaw(String loggername) {
+ initRaw(Logger.getLogger(loggername));
+ }
+
+ public static void initRaw(Logger logger) {
+ logger.addHandler(rawConsoleHandler);
+ logger.setUseParentHandlers(false);
+ logger.setLevel(Level.WARNING);
+ }
+
+ /**
+ * Inits a logger to write to a file only the actually logged text (no
+ * time&date) . When finishing
+ * close(loggername) should be called
+ *
+ * @param loggername
+ * @param tryLckDeletion -
+ * should the method try to delete left over lck files currently
+ * only works for single lck files
+ */
+ public static void initRawFile(String loggername, String filename,
+ int maxKB, int count, boolean append, boolean tryLckDeletion)
+ throws SecurityException, IOException {
+ if (tryLckDeletion) {
+ if (count > 1)
+ throw new IllegalArgumentException(
+ "tryLckDeletion doesn't work for >1 file");
+ File f = new File(filename + ".lck");
+ if (f.exists())
+ f.delete();
+ }
+ if (count > 1)
+ filename = FileUtils.addToEndOfFileName(filename, "%g");
+ Handler fh = new FileHandler(filename, maxKB * 1024, count, append);
+ fh.setFormatter(new RawFormatter());
+
+ Logger.getLogger(loggername).addHandler(fh);
+ Logger.getLogger(loggername).setUseParentHandlers(false);
+ }
+
+ public static void initRawFileDateTime(String loggername, String filename,
+ int maxKB, int count, boolean append, boolean tryLckDeletion)
+ throws SecurityException, IOException {
+ if (tryLckDeletion) {
+ if (count > 1)
+ throw new IllegalArgumentException(
+ "tryLckDeletion doesn't work for >1 file");
+ File f = new File(filename + ".lck");
+ if (f.exists())
+ f.delete();
+ }
+ if (count > 1)
+ filename = FileUtils.addToEndOfFileName(filename, "%g");
+ Handler fh = new FileHandler(filename, maxKB * 1024, count, append);
+ fh.setFormatter(new DateTimeFormatter());
+
+ Logger.getLogger(loggername).addHandler(fh);
+ Logger.getLogger(loggername).setUseParentHandlers(false);
+ }
+
+ /**
+ * closes a logger. important for file loggers
+ *
+ * @param loggername
+ */
+ public static void close(String loggername) {
+ Handler[] h = Logger.getLogger(loggername).getHandlers();
+ for (int i = 0; i < h.length; i++) {
+ h[i].close();
+ }
+
+ }
+
+ public static void main(String args[]) {
+ try {
+ initRawFile("superx_10000", "d:\\temp\\superx_10000.log", 2000, 1,
+ true, true);
+ } catch (SecurityException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ Logger.getLogger("superx_10000").log(Level.SEVERE, "sql: öalskjf");
+
+ }
+}
+
+class DateTimeFormatter extends SimpleFormatter
+{
+ public String format(LogRecord record) {
+ String result =
+
+ DateUtils.getTodayString()+" "+DateUtils.getNowString()
+
+
+ + ":" + record.getMessage() + "\n";
+
+ return result;
+ }
+
+ public String formatMessage(LogRecord record) {
+ return format(record);
+
+ }
+}
+
+class RawFormatter extends SimpleFormatter {
+ private boolean isTimeWanted = true;
+
+ public String format(LogRecord record) {
+ String result = "";
+ if (isTimeWanted) {
+ String milli="."+new java.util.Date().getTime();
+ int pos=milli.length()-3;
+ milli=milli.substring(pos);
+ result =
+ //DateUtils.getTodayString()+" "+
+ DateUtils.getNowString()+
+ "."+milli
+
+ + ":" + record.getMessage() + "\n";
+
+ } else
+ result = record.getMessage() + "\n";
+ return result;
+ }
+
+ public String formatMessage(LogRecord record) {
+ return format(record);
+
+ }
+
+ public void setTimeWanted(boolean isTimeWanted) {
+ this.isTimeWanted = isTimeWanted;
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/MailUtils.java b/src/de/memtext/util/MailUtils.java
new file mode 100644
index 0000000..f725d76
--- /dev/null
+++ b/src/de/memtext/util/MailUtils.java
@@ -0,0 +1,42 @@
+package de.memtext.util;
+
+import java.io.IOException;
+
+import javax.mail.BodyPart;
+import javax.mail.Message;
+import javax.mail.MessagingException;
+import javax.mail.internet.MimeMultipart;
+
+public class MailUtils {
+
+ public static String getTextFromMimeMultipart(
+ MimeMultipart mimeMultipart) throws MessagingException, IOException{
+ String result = "";
+ int count = mimeMultipart.getCount();
+ for (int i = 0; i < count; i++) {
+ BodyPart bodyPart = mimeMultipart.getBodyPart(i);
+ if (bodyPart.isMimeType("text/plain")) {
+ result = result + "\n" + bodyPart.getContent();
+ break; // without break same text appears twice in my tests
+ } else if (bodyPart.isMimeType("text/html")) {
+ String html = (String) bodyPart.getContent();
+ // result = result + "\n" + org.jsoup.Jsoup.parse(html).text();
+ result = result + "\n" + html;
+ } else if (bodyPart.getContent() instanceof MimeMultipart){
+ result = result + getTextFromMimeMultipart((MimeMultipart)bodyPart.getContent());
+ }
+ }
+ return result;
+ }
+
+ public static String getContent(Message m) throws MessagingException, IOException {
+ String result=null;
+ if (m.isMimeType("text/plain")) {
+ result = m.getContent().toString();
+ } else if (m.isMimeType("multipart/*")) {
+ MimeMultipart mimeMultipart = (MimeMultipart) m.getContent();
+ result = MailUtils.getTextFromMimeMultipart(mimeMultipart);
+ }
+ return result;
+ }
+}
diff --git a/src/de/memtext/util/ManTool.java b/src/de/memtext/util/ManTool.java
new file mode 100644
index 0000000..9d231be
--- /dev/null
+++ b/src/de/memtext/util/ManTool.java
@@ -0,0 +1,208 @@
+package de.memtext.util;
+
+import java.sql.Connection;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+import de.memtext.db.ConnectionCreator;
+import de.memtext.db.DbUtils;
+
+public class ManTool {
+private final String REPORT="KENN_PBV_ASTAT4";
+private final String GROUPING="KENN_VTS_POSLEIT";
+
+
+private final String IDSTART="KENN_ASTAT_VTS_KANZ";
+private final String NAMESTART="Verwaltungs-,technisches und sonstiges Personal Kanzler/in";
+private final String WHERESTART="ef35='5'";
+//private final String WHERESTART="ef='2' and ef15::smallint<50 and ef16::smallint>=4) ";
+
+
+
+private final String TIMEUNIT="J";
+private final String FLD_JAHR="jahr";
+private final String FROMCLAUSE="kenn_pbv_astat";
+private final String AGGRFUNCTION="count(*)";
+private int manCatalogueTid=-1;
+private int manCatalogueRptTid=-1;
+private int manCatalogueRptSort=-1;
+private int incrementRptSort=10;
+private String dbprops;
+
+ManTool(String dbprops)
+{
+ this.dbprops=dbprops;
+}
+
+ private void run()
+ {
+ initTids();
+ List varianten=new ArrayList();
+ varianten.add(new Variante("","","",null,null));
+ varianten.add(new Variante("_W"," (weiblich)","and ef23=2",null,null));
+ for (Variante v:varianten)
+ {
+ System.out.println(v.toSql());
+ manCatalogueTid++;
+ manCatalogueRptTid++;
+ manCatalogueRptSort=manCatalogueRptSort+incrementRptSort;
+ }
+ }
+ private void initTids()
+ {
+ Connection con;
+ try {
+ con = ConnectionCreator.getConnectionCryptPassword(dbprops,
+ "driverName", "connectionURL", "connectionName",
+ "connectionPassword");
+ Statement stm=con.createStatement();
+ manCatalogueTid=DbUtils.getInt(stm, "select max(tid) from man_catalogue")+1;
+ manCatalogueRptTid=DbUtils.getInt(stm, "select max(tid) from man_catalogue_rpt")+1;
+ manCatalogueRptSort=DbUtils.getInt(stm, "select max(sortnr) from man_catalogue_rpt where report_id='"+REPORT+"'")+10;
+ } catch (Exception e) {
+ System.out
+ .println("ERROR: Verbindung konnte nicht aufgebaut werden.\n"
+ + e);
+ System.exit(1);
+ }
+
+ }
+ class Variante{
+ private String idSuffix,nameSuffix,whereSuffix,replaceSource,replaceTarget;
+ Variante(String idSuffix,String nameSuffix,String whereSuffix,String replaceSource,String replaceTarget)
+ {
+ this.idSuffix=idSuffix;
+ this.nameSuffix=nameSuffix;
+ this.whereSuffix=whereSuffix;
+ this.replaceSource=replaceSource;
+ this.replaceTarget=replaceTarget;
+
+ }
+ String toSql()
+ {
+ String id=IDSTART+idSuffix;
+ String name=NAMESTART+nameSuffix;
+ String whereclause=WHERESTART+" "+whereSuffix;
+ if (replaceSource!=null&&replaceTarget!=null)
+ {
+ whereclause=StringUtils.replace(whereclause, replaceSource, replaceTarget);
+ }
+ whereclause=StringUtils.replace(whereclause, "'", "''");
+ String sql = "INSERT INTO man_catalogue \n" +
+ "( \n" +
+ " tid, \n" +
+ " id, \n" +
+ " shortname, \n" +
+ " name, \n" +
+ " description, \n" +
+ " timeunit, \n" +
+ " decimalplaces, \n" +
+ " sqlchunk, \n" +
+ " linksub, \n" +
+ " linktimeline, \n" +
+ " restrictedgroupids, \n" +
+ " ismanual, \n" +
+ " requiredfields, \n" +
+ " calcratio, \n" +
+ " gueltig_von, \n" +
+ " gueltig_bis, \n" +
+ " cleanup, \n" +
+ " preparation, \n" +
+ " techdetails, \n" +
+ " moreinfo, \n" +
+ " attrib1, \n" +
+ " fld_semester, \n" +
+ " fld_jahr, \n" +
+ " fld_studiengang, \n" +
+ " fld_institut, \n" +
+ " fld_geschlecht, \n" +
+ " fromclause, \n" +
+ " whereclause, \n" +
+ " aggrfunction, \n" +
+ " cacheing, \n" +
+ " linktable, \n" +
+ " linkmask \n" +
+ ") \n" +
+ "VALUES \n" +
+ "( \n" +
+ manCatalogueTid+ " , \n" +
+ " '"+id+"', \n" +
+ " '"+name+"', \n" +
+ " '"+name+"', \n" +
+ " '"+name+"', \n" +
+ " '"+TIMEUNIT+"', \n" +
+ " 0, \n" +
+ " NULL, \n" +
+ " NULL, \n" +
+ " NULL, \n" +
+ " ' ', \n" +
+ " 0, \n" +
+ " '', \n" +
+ " 0, \n" +
+ " '1900-01-01', \n" +
+ " '3000-12-31', \n" +
+ " NULL, \n" +
+ " NULL, \n" +
+ " NULL, \n" +
+ " NULL, \n" +
+ " 0, \n" +
+ " '', \n" +
+ " '"+FLD_JAHR+"', \n" +
+ " '', \n" +
+ " '', \n" +
+ " '', \n" +
+ " '"+FROMCLAUSE+"', \n" +
+ " '"+whereclause+"', \n" +
+ " '"+AGGRFUNCTION+"', \n" +
+ " 1, \n" +
+ " '', \n" +
+ " '' \n" +
+ "); \n" +
+ "";
+ String sql2 = "INSERT INTO man_catalogue_rpt \n" +
+ "( \n" +
+ " tid, \n" +
+ " report_id, \n" +
+ " catalogue_id, \n" +
+ " description, \n" +
+ " sortnr, \n" +
+ " sortnr2, \n" +
+ " grouping1, \n" +
+ " grouping2, \n" +
+ " valid_from, \n" +
+ " valid_till, \n" +
+ " active \n" +
+ ") \n" +
+ "VALUES \n" +
+ "( \n" +
+ manCatalogueRptTid+" , \n" +
+ " '"+REPORT+"', \n" +
+ " '"+id+"', \n" +
+ " NULL, \n" +
+ manCatalogueRptSort+" , \n" +
+ " 1, \n" +
+ " '"+GROUPING+"', \n" +
+ " ' ', \n" +
+ " '1900-01-01', \n" +
+ " '3000-12-31', \n" +
+ " 1 \n" +
+ "); \n" +
+ "";
+ return sql+"\n"+sql2;
+ }
+ }
+ public static void main(String a[])
+ {
+ if (a.length==1)
+ {
+ ManTool m=new ManTool(a[0]);
+ m.run();
+ }
+ else
+ {
+ System.out.println("Aufruf Pfad zu DB-Properties übergeben");
+ }
+
+ }
+}
diff --git a/src/de/memtext/util/MemoryUtils.java b/src/de/memtext/util/MemoryUtils.java
new file mode 100644
index 0000000..9128926
--- /dev/null
+++ b/src/de/memtext/util/MemoryUtils.java
@@ -0,0 +1,48 @@
+package de.memtext.util;
+public class MemoryUtils {
+private long before;
+ public MemoryUtils() {
+ measureBefore();
+ }
+
+ public void measureBefore()
+ {
+ before=Runtime.getRuntime().freeMemory();
+ }
+
+ public void print(String was)
+ {
+ long after=Runtime.getRuntime().freeMemory();
+ long difference=(after-before)/1024;
+ System.out.println(was +" Speicherbedarf (ungefähr):"+(difference)+" KB");
+ }
+ public static void printfree()
+ {
+ printfree("");
+ }
+ public static void printfree(String txt)
+ {
+ long kb=((Runtime.getRuntime().freeMemory())/1024);
+ long mb=kb/1024;
+
+ System.out.println(txt+" freier Speicher:"+mb+" MB");
+
+ }
+ public static void main(String[] args) {
+ long before=Runtime.getRuntime().freeMemory();
+ int max=4000;
+ String[] test=new String[max];
+ for(int i=0;i maxLength)
+ ret = ret.substring(0, maxLength);
+ return ret;
+ }
+ static public String getMaxLenString(Object x) {
+ String ret = x.toString();
+ if (ret.length() > maxLength)
+ ret = ret.substring(0, maxLength);
+ return ret;
+ }
+ static public String getMaxLenString(String x) {
+ if (x.length() > maxLength)
+ x = x.substring(0, maxLength);
+ return x;
+ }
+
+}
diff --git a/src/de/memtext/util/ObjectWithExceptionHandler.java b/src/de/memtext/util/ObjectWithExceptionHandler.java
new file mode 100644
index 0000000..14ae617
--- /dev/null
+++ b/src/de/memtext/util/ObjectWithExceptionHandler.java
@@ -0,0 +1,25 @@
+package de.memtext.util;
+
+/**
+ * Basis for a singleton which has its own ExceptionHandler.
+ * XmlUtils uses this for example.
+ */
+public class ObjectWithExceptionHandler {
+ private ExceptionHandler exceptionHandler = new ExceptionHandler();
+
+ public ObjectWithExceptionHandler() {
+
+ }
+ public void setExceptionHandler(ExceptionHandler handler) {
+ exceptionHandler = handler;
+ }
+
+ public ExceptionHandler getExceptionHandler() {
+ return exceptionHandler;
+ }
+ public void handle(Throwable e)
+ {
+ exceptionHandler.handle(e);
+ }
+
+}
diff --git a/src/de/memtext/util/OwnThreadActionListener.java b/src/de/memtext/util/OwnThreadActionListener.java
new file mode 100644
index 0000000..cd942c4
--- /dev/null
+++ b/src/de/memtext/util/OwnThreadActionListener.java
@@ -0,0 +1,65 @@
+package de.memtext.util;
+
+import java.awt.Window;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JComponent;
+
+/**
+ * When an action in performed, this ActionListener performs the tasks
+ * in a separate thread, subclases should override run()
+ * call setDefaultCursor() when busy cursor is to be turned off
+ * * example
+ * miResult.addActionListener(new OwnThreadActionListener(this) {
+ public void run() {
+ MBFrame f = new MBFrame("Auswertung");
+ f.setCenter(p);
+
+ --> setDefaultCursor();
+ f.show();
+ }
+ });
+ */
+public class OwnThreadActionListener implements ActionListener, Runnable {
+ private JComponent comp;
+ private Window window;
+ private ActionEvent ae;
+ public OwnThreadActionListener() {
+ }
+ public OwnThreadActionListener(JComponent comp) {
+ this.comp = comp;
+ }
+ public JComponent getComp()
+ {
+ return comp;
+ }
+ public OwnThreadActionListener(Window window) {
+ this.window = window;
+ }
+ /**
+ * Subclasses cannot override actionPerformed, but this method
+ * returns the actionCommand that was sent
+ * @return
+ */
+ public String getActionCommand()
+ {
+ return ae.getActionCommand();
+ }
+ public final void actionPerformed(ActionEvent e) {
+ WindowUtils.setWaitCursor(comp, true);
+ WindowUtils.setWaitCursor(window, true);
+ this.ae=e;
+ new Thread(this).start();
+
+ }
+ //public abstract void perform();
+ public void run() {
+ throw new UnsupportedOperationException("run has to be overriden by subclasses");
+ // perform();
+ }
+ public void setDefaultCursor() {
+ WindowUtils.setWaitCursor(comp, false);
+ WindowUtils.setWaitCursor(window, false);
+ }
+}
diff --git a/src/de/memtext/util/PWChecker.java b/src/de/memtext/util/PWChecker.java
new file mode 100644
index 0000000..ccf033f
--- /dev/null
+++ b/src/de/memtext/util/PWChecker.java
@@ -0,0 +1,38 @@
+package de.memtext.util;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class PWChecker {
+
+ public static void main(String[] args) {
+ System.out.println(hasNumbers("öalsdkj9f"));
+ }
+
+ public static boolean hasNumbers(String check)
+ {
+ Pattern p = Pattern.compile(".*[0-9]+.*");
+ Matcher m = p.matcher(check);
+ return m.matches();
+
+ }
+ public static boolean hasLowerAndUpperCase(String check)
+ {
+ return hasLowerCase(check)&&hasUpperCase(check);
+ }
+ public static boolean hasLowerCase(String check)
+ {
+ Pattern p = Pattern.compile(".*[a-z]+.*");
+ Matcher m = p.matcher(check);
+ return m.matches();
+
+ }
+
+ public static boolean hasUpperCase(String check) {
+ Pattern p = Pattern.compile(".*[A-Z]+.*");
+ Matcher m = p.matcher(check);
+ return m.matches();
+ }
+}
+
+//Created on 20.11.2006 at 09:59:27
\ No newline at end of file
diff --git a/src/de/memtext/util/PlafUtils.java b/src/de/memtext/util/PlafUtils.java
new file mode 100644
index 0000000..9e3c815
--- /dev/null
+++ b/src/de/memtext/util/PlafUtils.java
@@ -0,0 +1,78 @@
+package de.memtext.util;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+
+/**
+ * Helping methods for setting Windows Look & Feel
+ */
+public class PlafUtils {
+ private static final String WIN =
+ "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
+
+ private PlafUtils() {
+ }
+
+ public static void setWindowsLook(JFrame frame) {
+ try {
+ UIManager.setLookAndFeel(WIN);
+ SwingUtilities.updateComponentTreeUI(frame);
+ } catch (Exception e) {
+
+ }
+ }
+
+ public static void setWindowsLook(JComponent comp) {
+ try {
+ UIManager.setLookAndFeel(WIN);
+ SwingUtilities.updateComponentTreeUI(comp);
+ } catch (Exception e) {
+
+ }
+
+ }
+
+ public static void setWindowsLook(java.awt.Component comp)
+ {
+ try {
+ UIManager.setLookAndFeel(WIN);
+ SwingUtilities.updateComponentTreeUI(comp);
+ } catch (Exception e) {
+
+ }
+ }
+ /**
+ Sets a default font for all Swing components
+ sample to use for a single item below
+ **/
+ public static void setDefaultFont(java.awt.Font f)
+ {
+ javax.swing.plaf.FontUIResource fr=new javax.swing.plaf.FontUIResource ( f );
+
+ java.util.Enumeration keys = UIManager.getDefaults().keys();
+ while (keys.hasMoreElements()) {
+ Object key = keys.nextElement();
+ Object value = UIManager.get (key);
+ if (value instanceof javax.swing.plaf.FontUIResource)
+ UIManager.put (key, fr);
+ }
+
+// UIDefaults uiDefaults = UIManager.getDefaults();
+// Enumeration en = uiDefaults.keys();
+// while (en.hasMoreElements())
+// {
+// Object key = en.nextElement();
+// Object val = uiDefaults.get(key);
+// System.out.println("[" + key.toString() + "]:[" +
+// (null != val ? val.toString() : "(null)") +
+// "]");
+// }
+
+ //javax.swing.SwingUtilities.updateComponentTreeUI(this);
+
+ //for particular
+ //UIManager.put("Label.font",new Font("Serif",Font.ITALIC,12));
+
+ }
+}
diff --git a/src/de/memtext/util/PrintUtils.java b/src/de/memtext/util/PrintUtils.java
new file mode 100644
index 0000000..7972847
--- /dev/null
+++ b/src/de/memtext/util/PrintUtils.java
@@ -0,0 +1,268 @@
+package de.memtext.util;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.util.*;
+import javax.print.*;
+import javax.print.attribute.*;
+import javax.print.attribute.standard.*;
+import javax.print.event.*;
+import javax.swing.text.*;
+import javax.swing.*;
+import javax.imageio.*;
+import javax.imageio.stream.*;
+
+/** * Sets up to easily print HTML documents.
+ * It is not necessary to call any of the setter
+ * * methods as they all have default values, they
+ * are provided should you wish to change
+ * * any of the default values.*/
+public class PrintUtils
+{
+ public static int DEFAULT_DPI = 72;
+ public static float DEFAULT_PAGE_WIDTH_INCH = 8.5f;
+ public static float DEFAULT_PAGE_HEIGHT_INCH = 11f;
+ int x = 100;
+ int y = 80;
+ GraphicsConfiguration gc;
+ PrintService[] services;
+ PrintService defaultService;
+ DocFlavor flavor;
+ PrintRequestAttributeSet attributes;
+ Vector pjlListeners = new Vector();
+ Vector pjalListeners = new Vector();
+ Vector psalListeners = new Vector();
+ public PrintUtils()
+ {
+ gc = null;
+ attributes = new HashPrintRequestAttributeSet();
+ flavor = null;
+ defaultService = PrintServiceLookup.lookupDefaultPrintService();
+ services = PrintServiceLookup.lookupPrintServices( flavor, attributes );
+ // do something with the supported docflavors
+ DocFlavor[] df = defaultService.getSupportedDocFlavors();
+ for( int i = 0; i < df.length; i++ )
+
+ // if there is a default service, but no other services
+ if( defaultService != null && ( services == null || services.length == 0 ) )
+ {
+ services = new PrintService[1];
+ services[0] = defaultService;
+ }
+ }
+ /** * Set the GraphicsConfiguration to display the print dialog on.
+ * * * @param gc a GraphicsConfiguration object */
+ public void setGraphicsConfiguration( GraphicsConfiguration gc )
+ {
+ this.gc = gc;
+ }
+
+ public void setServices( PrintService[] services )
+ {
+ this.services = services;
+ }
+
+ public void setDefaultService( PrintService service )
+ {
+ this.defaultService = service;
+ }
+
+ public void setDocFlavor( DocFlavor flavor )
+ {
+ this.flavor = flavor;
+
+ }
+
+ public void setPrintRequestAttributes( PrintRequestAttributeSet attributes )
+ {
+ this.attributes = attributes;
+ }
+
+ public void setPrintDialogLocation( int x, int y )
+ {
+ this.x = x;
+ this.y = y;
+ }
+
+ public void addPrintJobListener( PrintJobListener pjl )
+ {
+ pjlListeners.addElement( pjl );
+ }
+
+ public void removePrintJobListener( PrintJobListener pjl )
+ {
+ pjlListeners.removeElement( pjl );
+ }
+
+ public void addPrintServiceAttributeListener( PrintServiceAttributeListener psal )
+ {
+ psalListeners.addElement( psal );
+ }
+
+ public void removePrintServiceAttributeListener( PrintServiceAttributeListener psal )
+ {
+ psalListeners.removeElement( psal );
+ }
+
+ public boolean printJEditorPane( JEditorPane jep, PrintService ps )
+ {
+ if( ps == null || jep == null )
+ return false;
+
+ // get the root view of the preview pane
+ View rv = jep.getUI().getRootView( jep );
+ // get the size of the view (hopefully the total size of the page to be printed
+ int x = ( int ) rv.getPreferredSpan( View.X_AXIS );
+ int y = ( int ) rv.getPreferredSpan( View.Y_AXIS );
+ // find out if the print has been set to colour mode
+ DocPrintJob dpj = ps.createPrintJob();
+ PrintJobAttributeSet pjas = dpj.getAttributes();
+ // get the DPI and printable area of the page. use default values if not available
+ // use this to get the maximum number of pixels on the vertical axis
+ PrinterResolution pr = ( PrinterResolution ) pjas.get( PrinterResolution.class );
+ int dpi;
+ float pageX, pageY;
+ if( pr != null )
+ dpi = pr.getFeedResolution( PrinterResolution.DPI );
+ else dpi = DEFAULT_DPI;
+
+ MediaPrintableArea mpa = ( MediaPrintableArea ) pjas.get( MediaPrintableArea.class );
+ if( mpa != null )
+ {
+ pageX = mpa.getX( MediaPrintableArea.INCH );
+ pageY = mpa.getX( MediaPrintableArea.INCH );
+ }
+ else
+ {
+ pageX = DEFAULT_PAGE_WIDTH_INCH;
+ pageY = DEFAULT_PAGE_HEIGHT_INCH;
+ }
+ int pixelsPerPageY = ( int ) ( dpi * pageY );
+ // make colour true if the user has selected colour,
+ //and the PrintService can support colour
+ boolean colour = pjas.containsValue( Chromaticity.COLOR );
+ colour = colour & ( ps.getAttribute( ColorSupported.class ) == ColorSupported.SUPPORTED );
+ // create a BufferedImage to draw on
+ int imgMode;
+ if( colour )
+ imgMode = BufferedImage.TYPE_3BYTE_BGR;
+ else
+ imgMode = BufferedImage.TYPE_BYTE_GRAY;
+
+ BufferedImage img = new BufferedImage( x, y, imgMode );
+ Graphics myGraphics = img.getGraphics();
+ myGraphics.setClip( 0, 0, x, y );
+ myGraphics.setColor( Color.WHITE );
+ myGraphics.fillRect( 0, 0, x, y );
+ // call rootView.paint( myGraphics, rect ) to paint the whole image on myGraphics
+ rv.paint( myGraphics, new Rectangle( 0, 0, x, y ) );
+ try {
+ // write the image as a JPEG to the ByteArray so it can be printed
+ Iterator writers = ImageIO.getImageWritersByFormatName( "jpeg" );
+ ImageWriter writer = ( ImageWriter ) writers.next();
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ ImageOutputStream ios = ImageIO.createImageOutputStream( out );
+ writer.setOutput( ios );
+ // get the number of pages we need to print this image
+ int imageHeight = img.getHeight();
+ int numberOfPages = ( int ) ( ( imageHeight / pixelsPerPageY ) + 0.5 );
+ // print each page
+ for( int i = 0; i < numberOfPages; i++ )
+ {
+ int startY = i * pixelsPerPageY;
+ // get a subimage which is exactly the size of one page
+ BufferedImage subImg = img.getSubimage( 0, startY, x, pixelsPerPageY );
+ writer.write( subImg );
+ SimpleDoc sd = new SimpleDoc( out.toByteArray(), DocFlavor.BYTE_ARRAY.JPEG, null );
+ printDocument( sd, ps );
+ // reset the ByteArray so we can start the next page
+ out.reset();
+ }
+ }
+ catch( PrintException e )
+ {
+ System.out.println( "Error printing document." );
+ e.printStackTrace();
+ return false;
+ }
+ catch( IOException e )
+ {
+ System.out.println( "Error creating ImageOutputStream or writing to it." );
+ e.printStackTrace();
+ return false;
+ }
+ // uncomment this code and comment out the 'try-catch' block above
+ // to print to a JFrame instead of to the printer
+ /*
+ JFrame jf = new JFrame();
+ PaintableJPanel jp = new PaintableJPanel();
+ jp.setImage( img );
+ JScrollPane jsp = new JScrollPane( jp );
+ jf.getContentPane().add( jsp );
+ Insets i = jf.getInsets();
+ jf.setBounds( 0, 0, newX, y );
+ jf.setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
+ jf.setVisible( true );*/
+ return true;
+ }
+
+ /** * Print the document to the specified PrintService.
+ * * This method cannot tell if the printing was successful.
+ * You must register a PrintJobListener
+ * @return false if no PrintService is selected in the dialog, true otherwise */
+ public boolean printDocument( Doc doc, PrintService ps ) throws PrintException
+ {
+ if( ps == null )
+ return false;
+
+ addAllPrintServiceAttributeListeners( ps );
+ DocPrintJob dpj = ps.createPrintJob();
+ addAllPrintJobListeners( dpj );
+ dpj.print( doc, attributes );
+ return true;
+ }
+
+ public PrintService showPrintDialog()
+ {
+ return ServiceUI.printDialog( gc, x, y, services, defaultService, flavor, attributes );
+ }
+
+ private void addAllPrintServiceAttributeListeners( PrintService ps )
+ {
+ // add all listeners that are currently added to this object
+ for( int i = 0; i < psalListeners.size(); i++ )
+ {
+ PrintServiceAttributeListener p = ( PrintServiceAttributeListener ) psalListeners.get( i );
+ ps.addPrintServiceAttributeListener( p );
+ }
+ }
+
+ private void addAllPrintJobListeners( DocPrintJob dpj )
+ {
+ // add all listeners that are currently added to this object
+ for( int i = 0; i < pjlListeners.size(); i++ )
+ {
+ PrintJobListener p = ( PrintJobListener ) pjlListeners.get( i );
+ dpj.addPrintJobListener( p ); } }
+
+ // uncomment this also to print to a JFrame instead of a printer
+ /*
+ protected class PaintableJPanel extends JPanel
+ {
+ Image img;
+ protected PaintableJPanel()
+ {
+ super();
+ }
+ public void setImage( Image i )
+ {
+ img = i;
+ }
+
+ public void paint( Graphics g )
+ {
+ g.drawImage( img, 0, 0, this );
+ }
+ }*/
+}
+//Created on 13.04.2005 at 11:15:17
\ No newline at end of file
diff --git a/src/de/memtext/util/PropUtils.java b/src/de/memtext/util/PropUtils.java
new file mode 100644
index 0000000..b3dc537
--- /dev/null
+++ b/src/de/memtext/util/PropUtils.java
@@ -0,0 +1,55 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.NoSuchElementException;
+import java.util.Properties;
+
+/**
+
+ */
+public class PropUtils {
+private static String propFileName;
+ /**
+ * Gets a properties object filled with properties from the specified file
+ * @param propfilename
+ * @return Properties object
+ * @throws IOException
+ */
+ public static Properties getProps(String propfilename) throws IOException {
+ propFileName=propfilename;
+ Properties props = new Properties();
+
+ File propfile = new File(propfilename);
+ if (!propfile.exists()) {
+ throw new FileNotFoundException(
+ "Properties-file " + propfilename + " doesn't exist");
+
+ }
+ FileInputStream is = new FileInputStream(propfile);
+ props.load(is);
+ is.close();
+ return props;
+ }
+
+ /**
+ * Gets the value of a single property out of a properties file and throws
+ * an Exception if that key doesn't exist in the file
+ * used by autotransfer
+ *
+ * @param props - Properties that should contain the key
+ * @param key - name of the key
+ */
+ public static String getProperty(Properties props, String key)
+ throws NoSuchElementException {
+ String result = props.getProperty(key);
+ if (result == null)
+ throw new NoSuchElementException("Couldn't find property \"" + key+"\" in file: "+propFileName);
+ else
+ return result;
+
+ }
+
+}
diff --git a/src/de/memtext/util/ServletHelper.java b/src/de/memtext/util/ServletHelper.java
new file mode 100644
index 0000000..c3d53db
--- /dev/null
+++ b/src/de/memtext/util/ServletHelper.java
@@ -0,0 +1,78 @@
+package de.memtext.util;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.xml.transform.ErrorListener;
+import javax.xml.transform.TransformerException;
+
+import de.superx.servlet.ServletBasics;
+
+/**
+ * Abstrakte Basisklasse für ServletHelper-Objekt, nimmt request und response
+ * und den Logger auf. Objekte, die erweitern müssen (wie bei Thread) run()
+ * aufrufen. Dann wird die Authentifizierung geprüft und wenn die OK ist, wird
+ * die perform()-Methode des eigentlichen Objekts aufgerufen (die z.B. Maske
+ * aufbaut oder Tabelle holt). wenn eine Exception auftritt sorgt run() dafür,
+ * dass der Fehler gemeldet wird. Als Variablen enthält diese Klasse bereits den
+ * StringBuffer returnText mit dem geplanten Rückgabetext. Und userid mit der
+ * UserId (wenn Authentifizierung OK)
+ */
+public abstract class ServletHelper extends ServletBasics{
+
+
+ public ServletHelper(HttpServletRequest request,
+ HttpServletResponse response, String sessiontype)
+ throws IOException {
+ super(request,response,sessiontype);
+ }
+
+ /**
+ * Prüft falls gewünscht die Authentifizierung (existiert eine
+ * superx-Session) danach wird die abstrakte Methode perform aufgerufen. Die
+ * meisten Exceptions werden also Infomeldung an den User weitergegeben
+ *
+ * @param isAuthentificationCheckWanted
+ * @throws IOException
+ */
+ public void run(boolean isAuthentificationCheckWanted) throws IOException,
+ ServletException {
+ try {
+ if (isAuthentificationCheckWanted) {
+ checkSessionType();
+ }
+
+ perform();
+
+ } catch (Exception e) {
+
+ }
+ }
+
+ abstract protected void perform() throws Exception;
+
+ class DummyErrorListener implements ErrorListener {
+
+ public void warning(TransformerException exception)
+ throws TransformerException {
+ }
+
+ public void error(TransformerException exception)
+ throws TransformerException {
+ }
+
+ public void fatalError(TransformerException exception)
+ throws TransformerException {
+ System.out.println(exception);
+ }
+
+ }
+}
+
+//Created on 30.09.2004 at 08:59:42
+
+//Created on 27.02.2006 at 18:50:31
+
+//refactored to servletBasis 10.8.2011
diff --git a/src/de/memtext/util/StringUtils.java b/src/de/memtext/util/StringUtils.java
new file mode 100644
index 0000000..4e5752f
--- /dev/null
+++ b/src/de/memtext/util/StringUtils.java
@@ -0,0 +1,518 @@
+package de.memtext.util;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.text.Normalizer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.StringTokenizer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author MB
+ *
+ * various utils around Strings
+ */
+public class StringUtils {
+ // Latin to ASCII - mostly
+ private static final String TAB_00C0 = "" +
+ "AAAAÄAACEEEEIIII" +
+ "DNOOOOÖ×OUUUÜYTß" +
+ "aaaaäaaceeeeiiii" +
+ "dnooooö÷ouuuüyty" +
+ "AaAaAaCcCcCcCcDd" +
+ "DdEeEeEeEeEeGgGg" +
+ "GgGgHhHhIiIiIiIi" +
+ "IiJjJjKkkLlLlLlL" +
+ "lLlNnNnNnnNnOoOo" +
+ "OoOoRrRrRrSsSsSs" +
+ "SsTtTtTtUuUuUuUu" +
+ "UuUuWwYyYZzZzZzs";
+
+ private static final HashMap LIGATURES = new HashMap(){{
+ put(Character.valueOf('æ'), "ae");
+ put(Character.valueOf('œ'), "oe");
+ put(Character.valueOf('þ'), "th");
+ put(Character.valueOf('ij'), "ij");
+ put(Character.valueOf('ð'), "dh");
+ put(Character.valueOf('Æ'), "AE");
+ put(Character.valueOf('Œ'), "OE");
+ put(Character.valueOf('Þ'), "TH");
+ put(Character.valueOf('Ð'), "DH");
+ put(Character.valueOf('IJ'), "IJ");
+ //TODO
+ }};
+ private StringUtils() {
+ }
+
+
+
+
+ public static String removeAllButUmlauts(String value) {
+ String source=value;
+ value = Normalizer.normalize(value, Normalizer.Form.NFC);
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < source.length(); i++) {
+ char c = source.charAt(i);
+ String l = LIGATURES.get(Character.valueOf(c));
+ if (l != null){
+ sb.append(l);
+ } else if (c < 0xc0 || c == 'Ø') {
+ sb.append(c); // ASCII and C1 control codes
+ } else if (c >= 0xc0 && c <= 0x17f) {
+ c = TAB_00C0.charAt(c - 0xc0); // common single latin letters
+ sb.append(c);
+ } else {
+ // anything else, including Vietnamese and rare diacritics
+ l = Normalizer.normalize(Character.toString(c), Normalizer.Form.NFKD)
+ .replaceAll("[\\p{InCombiningDiacriticalMarks}]+", "");
+ sb.append(l);
+ }
+
+ }
+ return sb.toString();
+ }
+ public static String javascriptUmlautAdapt(String in) {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < in.length(); i++) {
+ char ch = in.charAt(i);
+ switch (ch) {
+
+ case 'ä':
+ // sb.append("ä");
+ sb.append("\\344");
+ break;
+ case 'Ä':
+ // sb.append("Ä");
+ sb.append("\\304");
+ break;
+ case 'ö':
+ // sb.append("ö");
+ sb.append("\\366");
+ break;
+ case 'Ö':
+ // sb.append("Ö");
+ sb.append("\\326");
+ break;
+ case 'ü':
+ // sb.append("ü");
+ sb.append("\\374");
+ break;
+ case 'Ü':
+ // sb.append("Ü");
+ sb.append("\\334");
+ break;
+ case 'ß':
+ // sb.append("ß");
+ sb.append("\\337");
+ break;
+
+ default:
+ sb.append(ch);
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * übertragen von normalen Entitires ä hat zwar bei normalem HTML
+ * geklappt, aber nicht in Methoden new
+ * Option(sichten.selected.name,sichten.selected.value) da war javascript
+ * etwas zu intelligent und hat ä in der Selectbox dann tatsächlich als
+ * ä dargestellt statt ä
+ * http://members.magnet.at/diem/javascript/infosjso.htm
+ *
+ * @param in
+ * @param isJavascriptUmlautEncodingWanted
+ * TODO
+ * @return
+ */
+ public static String jsonAdapt(String in,
+ boolean isJavascriptUmlautEncodingWanted) {
+ StringBuffer sb = new StringBuffer();
+
+ for (int i = 0; i < in.length(); i++) {
+ char ch = in.charAt(i);
+ switch (ch) {
+ case 'ä':
+ // sb.append("ä");
+ if (isJavascriptUmlautEncodingWanted) sb.append("\\344");
+ else sb.append("ä");
+ break;
+ case 'Ä':
+ // sb.append("Ä");
+ if (isJavascriptUmlautEncodingWanted) sb.append("\\304");
+ else sb.append("Ä");
+ break;
+ case 'ö':
+ // sb.append("ö");
+ if (isJavascriptUmlautEncodingWanted) sb.append("\\366");
+ else sb.append("ö");
+ break;
+ case 'Ö':
+ // sb.append("Ö");
+ if (isJavascriptUmlautEncodingWanted) sb.append("\\326");
+ else sb.append("Ö");
+ break;
+ case 'ü':
+ // sb.append("ü");
+ if (isJavascriptUmlautEncodingWanted) sb.append("\\374");
+ else sb.append("ü");
+ break;
+ case 'Ü':
+ // sb.append("Ü");
+ if (isJavascriptUmlautEncodingWanted) sb.append("\\334");
+ else sb.append("Ü");
+ break;
+ case 'ß':
+ // sb.append("ß");
+ if (isJavascriptUmlautEncodingWanted) sb.append("\\337");
+ else sb.append("ß");
+ break;
+ case '"':
+ sb.append("\\\"");
+ break;
+ case '\\':
+ sb.append("\\\\");
+ break;
+ case '\b':
+ sb.append("\\b");
+ break;
+ case '\f':
+ sb.append("\\f");
+ break;
+ case '\n':
+ sb.append("\\n");
+ break;
+ case '\r':
+ sb.append("\\r");
+ break;
+ case '\t':
+ sb.append("\\t");
+ break;
+ case '/':
+ sb.append("\\/");
+ break;
+ default:
+ if (ch >= '\u0000' && ch <= '\u001F') {
+ String ss = Integer.toHexString(ch);
+ sb.append("\\u");
+ for (int k = 0; k < 4 - ss.length(); k++) {
+ sb.append('0');
+ }
+ sb.append(ss.toUpperCase());
+ } else {
+ sb.append(ch);
+ }
+ }
+ }
+ String result=sb.toString();
+ if (isJavascriptUmlautEncodingWanted)
+ result = javascriptUmlautAdapt(result);
+
+ return result;
+
+ }
+
+ /**
+ * @param buf -
+ * StingBuffer in which replacement is to be made
+ * @param token -
+ * String to be replaced
+ * @param newval -
+ * String to value
+ */
+ public static void replace(StringBuffer buf, String token, String newval) {
+ if (token == null)
+ throw new IllegalArgumentException("Token must not be null");
+ if (newval == null)
+ throw new IllegalArgumentException("newval must not be null");
+ if (token.equals(newval))
+ throw new IllegalArgumentException(
+ "token and newval must not be equal");
+ boolean replaced = false;
+ int start = 0;
+ while (!replaced) {
+ start = buf.toString().indexOf(token, start);
+ switch (start) {
+ case -1:
+ replaced = true;
+ break;
+ default:
+ int end = start + token.length();
+ buf.replace(start, end, newval);
+ start = start + newval.length();
+ break;
+ }
+ }
+ }
+
+ static public String nvl(String input, String nvl) {
+ if (input == null)
+ return nvl;
+ else
+ return input;
+ }
+
+ /**
+ * Reads the contents of a file and returns them as a string
+ *
+ * @param filename
+ * @return String with content of files
+ * @throws IOException
+ */
+ public static String readFile(File f) throws IOException {
+ FileReader fr = new FileReader(f);
+ BufferedReader bfr = new BufferedReader(fr);
+ String line;
+ StringBuffer result = new StringBuffer();
+ while ((line = bfr.readLine()) != null) {
+ result.append(line + "\n");
+
+ }
+ bfr.close();
+ fr.close();
+ return result.toString();
+ }
+
+ public static void write(File f, String text) throws IOException {
+ FileWriter fw = new FileWriter(f);
+ BufferedWriter bfw = new BufferedWriter(fw);
+ bfw.write(text);
+ bfw.close();
+ fw.close();
+ }
+
+ /**
+ * Prüft ob Tags <***> enthalten sind, \n wird auch moniert Text javascript
+ * wird auch moniert
+ *
+ * @param source
+ * @return
+ */
+ public static boolean containsTags(String source) {
+
+ // return source.replaceAll("<[^>]+>", "");
+
+ boolean result = false;
+ if (source != null) {
+ int startpos = 0;
+
+ while (source.indexOf("<", startpos) > -1) {
+ startpos = source.indexOf("<", startpos);
+ int tagend = source.indexOf(">", startpos);
+ if (tagend > -1
+ && tagend > startpos + 1
+ && source.substring(startpos, tagend).indexOf(" ") == -1) {
+ result = true;
+ break;
+ } else if (tagend > -1)
+ startpos = tagend + 1;
+ else
+ startpos++;
+ }
+ if (source.indexOf("javascript") > -1)
+ result = true;
+ // gab Probleme mit csv upload
+ // if (source.indexOf("\n")>-1) result=true;
+ if (source.indexOf("\u0000") > -1)
+ result = true;
+ /*
+ * StringTokenizer st = new StringTokenizer(source, " <", true);
+ * while (st.hasMoreTokens()) { String tok = st.nextToken(); int pos =
+ * tok.indexOf(">"); //größer 0 damit nicht ">1996" als tag zählt if
+ * (pos > 0 && tok.substring(0, pos).indexOf(" ") == -1) { result =
+ * true; break; } }
+ */
+ }
+
+ return result;
+ }
+
+ public static String replace(String text, String token, String newval) {
+ StringBuffer buf = new StringBuffer(text);
+ replace(buf, token, newval);
+ return buf.toString();
+ }
+
+ /**
+ * Gets the last char in a String which is not a space so "joolap " would
+ * return p
+ *
+ * @param txt
+ * @return last character which is not space notice the Character wrapper
+ * class is returned, if the entire string consists of spaces, null
+ * is returned
+ */
+ public static Character getLastNonSpaceChar(String txt) {
+ Character result = null;
+ int pos = txt.length() - 1;
+ while (pos > -1) {
+ if (txt.charAt(pos) != ' ') {
+ result = new Character(txt.charAt(pos));
+ break;
+ }
+ pos--;
+ }
+ return result;
+ }
+
+ /**
+ * gets the last char in a StringBuffer
+ *
+ * @param char
+ */
+ public static char getLastChar(StringBuffer buf) {
+ if (buf == null || buf.length() == 0)
+ throw new IllegalArgumentException("Leerer Buffer");
+ return buf.charAt(buf.length() - 1);
+ }
+
+ /**
+ * deletes the last char in a StringBuffer if length > 0
+ *
+ * @param buf
+ * StringBuffer
+ */
+ public static void deleteLastChar(StringBuffer buf) {
+ if (buf.length() > 0)
+ buf.deleteCharAt(buf.length() - 1);
+ }
+
+ /**
+ * deletes last char if length > 0
+ *
+ * @param txt
+ * @return returns String without last char
+ */
+ public static String deleteLastChar(String txt) {
+ String result = txt;
+ if (txt.length() > 0)
+ result = txt.substring(0, txt.length() - 1);
+ return result;
+ }
+
+ public static LinkedList getStringTokenizedList(String source, String delim) {
+ LinkedList result = new LinkedList();
+ StringTokenizer st = new StringTokenizer(source, delim);
+ for (; st.hasMoreTokens();) {
+ Object next = st.nextToken();
+ result.add(next);
+ }
+ return result;
+ }
+
+ public static String toCommaList(Collection c) {
+ StringBuffer msg = new StringBuffer();
+ for (Iterator it = c.iterator(); it.hasNext();) {
+ Object o = it.next();
+ msg.append(o + ",");
+ }
+ if (msg.length() > 1)
+ StringUtils.removeFromEnd(msg, ",", true);
+ return msg.toString();
+ }
+
+ public static void printInt(String x) {
+ for (int i = 0; i < x.length(); i++) {
+ int ch = x.charAt(i);
+ System.out.print(x.charAt(i) + ",");
+ }
+ for (int i = 0; i < x.length(); i++) {
+ int ch = x.charAt(i);
+ System.out.print(ch + ",");
+ }
+ }
+
+ public static String trimLength(String input, int len) {
+ if (input != null) {
+ input = input.substring(0, Math.min(len, input.length()));
+ }
+ return input;
+ }
+
+ public static void main(String a[]) {
+ String value="Dr. Estaña öäü ÄÖÜ ß";
+
+String p=removeAllButUmlauts(value);
+ System.out.println(p);
+ }
+
+ /**
+ * int numberOfCommas = s.replaceAll("[^,]","").length();
+ *
+ * @param base
+ * @param searchFor
+ * @return
+ */
+ public static int count(String base, String searchFor) {
+ int pos = base.indexOf(searchFor);
+ int result = 0;
+ while (pos > -1) {
+ result++;
+ if (pos < base.length() - 1)
+ pos = base.indexOf(searchFor, pos + searchFor.length());
+ else
+ pos = -1;
+ }
+ return result;
+ }
+
+ public static void removeFromEnd(StringBuffer source, String removeIt,
+ boolean isExceptionWanted) {
+ if (source.length() < removeIt.length())
+ throw new IllegalArgumentException("Source: " + source
+ + " is shorter than " + removeIt);
+ if (isExceptionWanted
+ && !source.substring(source.length() - removeIt.length())
+ .equals(removeIt))
+ throw new IllegalArgumentException("Source: " + source
+ + " doesn't end with " + removeIt);
+
+ source.setLength(source.length() - removeIt.length());
+ }
+
+ public static String removeFromEnd(String source, String removeIt,
+ boolean isExceptionWanted) {
+
+ if (source.length() < removeIt.length())
+ throw new IllegalArgumentException("Source: " + source
+ + " is shorter than " + removeIt);
+ if (isExceptionWanted && !source.endsWith(removeIt))
+ throw new IllegalArgumentException("Source: " + source
+ + " doesn't end with " + removeIt);
+ return source.substring(0, source.length() - removeIt.length());
+ }
+
+ public static void removeLastChar(StringBuffer buf) {
+ if (buf.length()>0)
+ buf.setLength(buf.length() - 1);
+ }
+
+ public static String filterOutput(String output) {
+ if (output != null) {
+ output = replace(output, "&", "&");
+ output = replace(output, "<", "<");
+ output = replace(output, ">", ">");
+ output = replace(output, "\"", """);
+ output = replace(output, "\'", "'");
+
+ }
+ return output;
+ }
+
+
+
+
+ public static boolean isNullOrEmpty(String test) {
+
+ return test==null||test.trim().isEmpty();
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/ThreadUtils.java b/src/de/memtext/util/ThreadUtils.java
new file mode 100644
index 0000000..7c8219e
--- /dev/null
+++ b/src/de/memtext/util/ThreadUtils.java
@@ -0,0 +1,18 @@
+package de.memtext.util;
+public class ThreadUtils {
+ private static int previousPriority=-1;
+
+ /**
+ * Sets the current thread to maximum priority
+ */
+ public static void setMaxPrio() {
+ Thread t = Thread.currentThread();
+ previousPriority = t.getPriority();
+ t.setPriority(Thread.MAX_PRIORITY - 1);
+ }
+
+ public static void setPreviousPrio() {
+ if (previousPriority==-1) throw new IllegalStateException("no previous priority found ");
+ Thread.currentThread().setPriority(previousPriority);
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/TimeUtils.java b/src/de/memtext/util/TimeUtils.java
new file mode 100644
index 0000000..5732e1c
--- /dev/null
+++ b/src/de/memtext/util/TimeUtils.java
@@ -0,0 +1,94 @@
+package de.memtext.util;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * Utility to print out how much time was needed for some operations
+ * good for debugging/testing
+ * call de.memtext.util.TimeUtils.start() before length operation()
+ * and print or printSinceStart afterwards
+ */
+public class TimeUtils {
+ private Date start;
+ private static DateFormat timeFormat =new SimpleDateFormat("HH:mm:ss");
+
+ public TimeUtils() {
+ start();
+ }
+ /**
+ * Registers the beginning of an lengthy operation.
+ */
+ public void start() {
+ start = new Date();
+ }
+ /**
+ * prints the text passed as parameter as well as
+ * elapsed time since TimeUtils.start was called and
+ * resets the start time.
+ * If you have two operations O1 and O2
+ * call TimeUtils.start();
+ * O1();
+ * TimeUtils.print("o1 finished");
+ * O2();
+ * TimeUtils.print("o2 finished");
+ *
+ * Output
+ * o1 finished - 3 sec : i.e. time needed for O1
+ * o2 finished - 4 sec : i.e. time needed for O2
+ * the total is 7 seconds
+ *
+ * @param txt
+ */
+ public void print(String txt) {
+ printSinceStart(txt);
+ start(); //new counting
+ }
+
+ /**
+ * prints the text passed as parameter as well as
+ * elapsed time since TimeUtils.start was called. Does not reset
+ * timer.
+ * If you have two operations O1 and O2
+ * call TimeUtils.start();
+ * O1();
+ * TimeUtils.printSinceStart("o1 finished");
+ * O2();
+ * TimeUtils.printSinceStart("o2 finished");
+ *
+ * Output
+ * o1 finished - 3 sec : i.e. time needed for O1
+ * o2 finished - 7 sec : i.e. time needed for O1+O2
+ *
+ * @param txt
+ */
+ public void printSinceStart(String txt) {
+
+ System.out.println(txt + " : " + getSinceStart() );
+ }
+
+ public String getSinceStart() {
+ if (start == null)
+ throw new RuntimeException("must call TimeUtils.start() before printing");
+ Date now = new Date();
+ long dif = now.getTime() - start.getTime();
+ /* long sec=dif/1000;
+ long hundertstel=dif/100;
+ System.out.println(txt+" : "+sec+"."+hundertstel+" sec");*/
+ double res = (double)dif / 1000;
+ return res+" secs";
+ }
+ public static String getNowString()
+ {
+
+ return timeFormat.format(new Date());
+ }
+ public static void main(String a[])
+ {
+
+ }
+ public static String format(java.util.Date time) {
+ return timeFormat.format(time);
+ }
+}
diff --git a/src/de/memtext/util/TransletUtils.java b/src/de/memtext/util/TransletUtils.java
new file mode 100644
index 0000000..79ef455
--- /dev/null
+++ b/src/de/memtext/util/TransletUtils.java
@@ -0,0 +1,67 @@
+package de.memtext.util;
+
+import javax.xml.transform.Templates;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamSource;
+
+public class TransletUtils {
+ private static TransformerFactory tFactory;
+ private static String usedProcessor=null;
+ private TransletUtils() {
+ }
+
+ public static synchronized void initFactory()
+ {
+ tFactory = TransformerFactory.newInstance();
+ }
+ /**
+ *
+ * @param parser
+ * //String value =
+ * "org.apache.xalan.xsltc.trax.TransformerFactoryImpl"; String
+ * value = "net.sf.saxon.TransformerFactoryImpl";
+ *
+ */
+ public static synchronized void initFactory(String preferredParser,
+ String secondaryParser) {
+ try {
+ tFactory = TransformerFactory.newInstance(preferredParser,null);
+ usedProcessor=preferredParser;
+ } catch (javax.xml.transform.TransformerFactoryConfigurationError e) {
+ if (secondaryParser != null) {
+ try {
+ tFactory = TransformerFactory.newInstance(secondaryParser, null);
+ usedProcessor=secondaryParser;
+ } catch (javax.xml.transform.TransformerFactoryConfigurationError e2) {
+ System.err.println("Weder " + preferredParser + " noch "
+ + secondaryParser + " gefunden");
+ e2.printStackTrace();
+ }
+ } else {
+ e.printStackTrace();
+ throw new IllegalStateException("Kein XML Parser "+e);
+ }
+ }
+ }
+
+ public static synchronized Templates createTemplate(String xslInURI)
+ throws TransformerConfigurationException {
+ if (tFactory == null)
+ initFactory("org.apache.xalan.xsltc.trax.TransformerFactoryImpl",
+ "net.sf.saxon.TransformerFactoryImpl");
+ return tFactory.newTemplates(new StreamSource(xslInURI));
+
+ }
+
+ public static void main(String args[]) {
+ System.out.println("javax.xml.transform.TransformerFactory was "+System.getProperty("javax.xml.transform.TransformerFactory"));
+System.getProperties().remove("javax.xml.transform.TransformerFactory");
+ System.out.println("after unsetting "+System.getProperty("javax.xml.transform.TransformerFactory"));
+ }
+ public static String getUsedProcessor() {
+ return usedProcessor;
+ }
+}
+
+//Created on 09.12.2004 at 14:07:47
diff --git a/src/de/memtext/util/TransletWrapper.java b/src/de/memtext/util/TransletWrapper.java
new file mode 100644
index 0000000..90a8be0
--- /dev/null
+++ b/src/de/memtext/util/TransletWrapper.java
@@ -0,0 +1,25 @@
+package de.memtext.util;
+
+import javax.xml.transform.Templates;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+
+import de.memtext.baseobjects.NamedObject;
+/**
+ * name can be file name or other
+ */
+public class TransletWrapper extends NamedObject{
+private Templates templates;
+ public TransletWrapper(String name,Templates templates) {
+ super(name);
+ this.templates=templates;
+ }
+
+
+ public Transformer newTransformer()
+ throws TransformerConfigurationException {
+ return templates.newTransformer();
+ }
+}
+
+//Created on 13.12.2004 at 13:06:49
\ No newline at end of file
diff --git a/src/de/memtext/util/TreeUtils.java b/src/de/memtext/util/TreeUtils.java
new file mode 100644
index 0000000..1d442df
--- /dev/null
+++ b/src/de/memtext/util/TreeUtils.java
@@ -0,0 +1,369 @@
+package de.memtext.util;
+
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreeModel;
+import javax.swing.tree.TreeNode;
+import javax.swing.tree.TreePath;
+
+import de.memtext.baseobjects.IdObjectI;
+import de.memtext.rights.Allowable;
+import de.memtext.tree.TreeEntryI;
+
+public class TreeUtils {
+
+ private TreeUtils() {
+
+ }
+
+ /**
+ * Von einem Knoten so viele Kinder der tiefsten Ebene entfernen, dass es
+ * höchstens maxDescendens Descendents gibt.
+ *
+ * @param node
+ * @param maxDescendents
+ */
+ public static void stripNode(DefaultMutableTreeNode node, int maxDescendents) {
+ while (countDescendents(node) > maxDescendents) {
+ //tiefsten Level entfernen
+ removeLevel(node, node.getLevel() + node.getDepth());
+ }
+ }
+
+ public static int getMaxLevel(DefaultMutableTreeNode node,
+ int maxDescendents) {
+ int maxLevel = node.getDepth();
+ while (countDescendents(node, maxLevel) > maxDescendents) {
+ maxLevel--;
+ if (maxLevel < 0)
+ throw new RuntimeException("");
+ }
+ return maxLevel;
+ }
+
+ /**
+ * Entferne alle Knoten auf einem bestimmten Level
+ *
+ * @param node
+ * @param level
+ */
+ public static void removeLevel(DefaultMutableTreeNode node, int level) {
+ LinkedList removeNodes = new LinkedList();
+ for (Enumeration en = node.preorderEnumeration(); en.hasMoreElements();) {
+ DefaultMutableTreeNode n = (DefaultMutableTreeNode) en
+ .nextElement();
+ if (n.getLevel() == level) {
+ removeNodes.add(n);
+ }
+ }
+ for (Iterator it = removeNodes.iterator(); it.hasNext();) {
+ DefaultMutableTreeNode n = (DefaultMutableTreeNode) it.next();
+ n.removeFromParent();
+ }
+ }
+
+ /**
+ *
+ * @param node
+ * @param maxDepth
+ * -1 für egal
+ * @return
+ */
+ public static int countDescendents(DefaultMutableTreeNode node, int maxDepth) {
+ int result = 0;
+ if (maxDepth < 0 || node.getLevel() + 1 <= maxDepth)
+ result = node.getChildCount();
+ if (maxDepth < 0 || node.getLevel() + 2 <= maxDepth) {
+ for (int i = 0; i < node.getChildCount(); i++) {
+ DefaultMutableTreeNode n = (DefaultMutableTreeNode) node
+ .getChildAt(i);
+ if (!n.isLeaf())
+ result += countDescendents(n, maxDepth);
+ }
+ }
+ return result;
+ }
+
+ public static int countDescendents(DefaultMutableTreeNode node) {
+ return countDescendents(node, -1);
+ }
+
+ public static String toString(DefaultMutableTreeNode root) {
+ StringBuffer buf = new StringBuffer();
+ DefaultMutableTreeNode node;
+ for (Enumeration en = root.preorderEnumeration(); en.hasMoreElements();) {
+ node = (DefaultMutableTreeNode) en.nextElement();
+ for (int i = 0; i < node.getLevel(); i++) {
+ buf.append(" ");
+ }
+ buf.append(node.toString() + "\n");
+ }
+ return buf.toString();
+ }
+
+ private static void quickSort(DefaultMutableTreeNode[] a, int lo0, int hi0,
+ boolean ascending, int posInText) {
+ int lo = lo0;
+ int hi = hi0;
+ DefaultMutableTreeNode mid;
+ DefaultMutableTreeNode T;
+
+ if (hi0 > lo0) {
+ mid = a[(lo0 + hi0) / 2];
+ while (lo <= hi) {
+ if (ascending) {
+ while ((lo < hi0)
+ && (a[lo]
+ .toString()
+ .substring(posInText)
+ .compareTo(
+ mid.toString().substring(posInText)) < 0))
+ ++lo;
+ while ((hi > lo0)
+ && (a[hi]
+ .toString()
+ .substring(posInText)
+ .compareTo(
+ mid.toString().substring(posInText)) > 0))
+ --hi;
+ } else {
+ while ((lo < hi0)
+ && (a[lo]
+ .toString()
+ .substring(posInText)
+ .compareTo(
+ mid.toString().substring(posInText)) > 0))
+ ++lo;
+ while ((hi > lo0)
+ && (a[hi]
+ .toString()
+ .substring(posInText)
+ .compareTo(
+ mid.toString().substring(posInText)) < 0))
+ --hi;
+ }
+ if (lo <= hi) {
+ T = a[lo];
+ a[lo] = a[hi];
+ a[hi] = T;
+ ++lo;
+ --hi;
+ }
+ }
+ if (lo0 < hi)
+ quickSort(a, lo0, hi, ascending, posInText);
+ if (lo < hi0)
+ quickSort(a, lo, hi0, ascending, posInText);
+ }
+ }
+
+ private static void sortChildren(DefaultMutableTreeNode root,
+ boolean ascending, boolean sortByName) {
+ int NmbChildren = root.getChildCount();
+ int startAt = 0; //Could be modified for storting on not-first-char
+ DefaultMutableTreeNode[] arrayOfNodes = new DefaultMutableTreeNode[NmbChildren];
+ //add all of top's children to an array of nodes
+ for (int i = 0; i < NmbChildren; i++) {
+ arrayOfNodes[i] = (DefaultMutableTreeNode) root.getChildAt(i);
+ }
+
+ quickSort(arrayOfNodes, 0, arrayOfNodes.length - 1, ascending, startAt);
+ //Remove all children from top
+ root.setAllowsChildren(false);
+ root.setAllowsChildren(true);
+ //Add the new array of nodes to top
+ for (int i = 0; i < arrayOfNodes.length; i++) {
+ root.add(arrayOfNodes[i]);
+ }
+ }
+
+ /**
+ * Liefert einen String mit Schlüsseln zurück wie 1,11,12,13 oder
+ * '1','12','13' für Strings
+ * neu: ohne Klammern
+ *
+ * @param startNode
+ * @param checkAllowed -
+ * nur hinzufügen, wenn Allowable implementiert wird und erlaubt
+ * ist
+ * @param ignoreErrors
+ * wenn Knoten nicht IdObjectI implementiert ignorieren
+ * @return
+ */
+ public static String getSubordinateKeyList(
+ DefaultMutableTreeNode startNode, boolean checkAllowed,
+ boolean ignoreErrors) {
+ StringBuffer buf = new StringBuffer("");
+ String key;
+ Object node;
+ for (Enumeration en = startNode.breadthFirstEnumeration(); en
+ .hasMoreElements();) {
+ node = en.nextElement();
+ if (checkAllowed
+ && (!(node instanceof Allowable) || !((Allowable) node)
+ .isAllowed()))
+ continue;
+ if (ignoreErrors && !(node instanceof IdObjectI))
+ continue;
+ IdObjectI idObject = (IdObjectI) node;
+ if (idObject.getId() == null)
+ key = "null";
+ else if (idObject.getId() instanceof String)
+ key = "'" + idObject.getId() + "'";
+ else
+ key = idObject.getId().toString();
+ buf.append(key + ",");
+ }
+ if (buf.length()>0&&StringUtils.getLastChar(buf) == ',')
+ StringUtils.removeFromEnd(buf, ",", true);
+ return buf.toString();
+
+ }
+
+ /**
+ * Liefert einen String mit Schlüsseln zurück wie (1,11,12,13) oder
+ * ('1','12','13') für Strings
+ *
+ * @param startNode
+ * @param checkAllowed -
+ * nur hinzufügen, wenn Allowable implementiert wird und erlaubt
+ * ist
+ * @param ignoreErrors
+ * wenn Knoten nicht IdObjectI implementiert ignorieren
+ * @return
+ */
+ public static String getOwnAndParentsKeyList(
+ DefaultMutableTreeNode startNode, boolean checkAllowed,
+ boolean ignoreErrors) {
+ if (checkAllowed) throw new RuntimeException("endlosschleife");
+ StringBuffer buf = new StringBuffer("(");
+ String key="";
+ DefaultMutableTreeNode node = startNode;
+
+ boolean done = false;
+ while (node != null) {
+ if (checkAllowed
+ && (!(node instanceof Allowable) || !((Allowable) node)
+ .isAllowed()))
+ ;
+ else {
+ if (ignoreErrors && !((node instanceof IdObjectI)||node instanceof TreeEntryI))
+ ;
+ else {
+ if (node instanceof IdObjectI)
+ {
+ IdObjectI idObject = (IdObjectI) node;
+ if (idObject.getId() == null)
+ key = "null";
+ else if (idObject.getId() instanceof String)
+ key = "'" + idObject.getId() + "'";
+ else
+ key = idObject.getId().toString();
+ }
+ if (node instanceof TreeEntryI)
+ {
+ TreeEntryI treeEntry = (TreeEntryI) node;
+ if (treeEntry.getOwnKey() == null)
+ key = "null";
+ else if (treeEntry.getOwnKey() instanceof String)
+ key = "'" + treeEntry.getOwnKey() + "'";
+ else
+ key = treeEntry.getOwnKey().toString();
+ }
+
+ buf.append(key + ",");
+ node = (DefaultMutableTreeNode) node.getParent();
+ }
+ }
+ }
+
+ if (StringUtils.getLastChar(buf) == ',')
+ StringUtils.removeFromEnd(buf, ",", true);
+ return buf + ")";
+
+ }
+
+ public static void sort(DefaultMutableTreeNode root) {
+ DefaultMutableTreeNode aNode;
+ for (Enumeration en = root.depthFirstEnumeration(); en
+ .hasMoreElements();) {
+ aNode = (DefaultMutableTreeNode) en.nextElement();
+ if (!aNode.isLeaf())
+ sortChildren(aNode, true, true);
+ }
+ }
+
+ public static void expandAll(JTree tree) {
+ TreeNode root = (TreeNode) tree.getModel().getRoot();
+
+ // Traverse tree from root
+ expandOrCollapseAll(tree, new TreePath(root), true);
+ }
+
+ public static void collapseAll(JTree tree) {
+ TreeNode root = (TreeNode) tree.getModel().getRoot();
+ // Traverse tree from root
+ expandOrCollapseAll(tree, new TreePath(root), false);
+ }
+ public static void collapseAll(JTree tree,DefaultMutableTreeNode node) {
+ expandOrCollapseAll(tree, new TreePath(node), false);
+ }
+ public static void collapseAll(JTree tree,TreePath tp){
+ if (tp==null) return;
+ Object node=tp.getLastPathComponent();
+ TreeModel model=tree.getModel();
+ if (!model.isLeaf(node)){
+ tree.collapsePath(tp);
+ for (int i=0;i=0;i--){
+ collapseAll(tree,tp.pathByAddingChild(model.getChild(node,i)));
+ }
+ tree.collapsePath(tp);
+ }
+
+ }
+ private static void expandOrCollapseAll(JTree tree, TreePath parent,
+ boolean expand) {
+ // Traverse children
+ TreeNode node = (TreeNode) parent.getLastPathComponent();
+ if (node.getChildCount() >= 0) {
+ for (Enumeration e = node.children(); e.hasMoreElements();) {
+ TreeNode n = (TreeNode) e.nextElement();
+ TreePath path = parent.pathByAddingChild(n);
+ expandOrCollapseAll(tree, path, expand);
+ }
+ }
+
+ // Expansion or collapse must be done bottom-up
+ if (expand) {
+ tree.expandPath(parent);
+ } else {
+ tree.collapsePath(parent);
+ }
+ }
+
+ public static String toHierString(Enumeration en, String separator) {
+ StringBuffer result = new StringBuffer();
+
+ for (; en.hasMoreElements();) {
+ DefaultMutableTreeNode anode = (DefaultMutableTreeNode) en
+ .nextElement();
+ result.append(anode + separator);
+
+ }
+ StringUtils.removeFromEnd(result, separator, true);
+ return result.toString();
+ }
+
+ public static String toHierString(DefaultMutableTreeNode node,
+ String separator) {
+ return toHierString(node.preorderEnumeration(), separator);
+ }
+
+}
+
+//Created on 17.12.2003 at 17:18:53
diff --git a/src/de/memtext/util/WindowUtils.java b/src/de/memtext/util/WindowUtils.java
new file mode 100644
index 0000000..d29c318
--- /dev/null
+++ b/src/de/memtext/util/WindowUtils.java
@@ -0,0 +1,159 @@
+package de.memtext.util;
+
+import java.awt.Container;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.Frame;
+import java.awt.Toolkit;
+import java.awt.Window;
+
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+
+/**
+ * Utils for Windows and Frames. setWaitCursor doesn't seem to be perfect yet
+ */
+public class WindowUtils {
+
+ static Cursor waitCursor = new Cursor(Cursor.WAIT_CURSOR);
+ static Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
+
+ //private static CursorUpdateThread cursorUpdateThread = new
+ // CursorUpdateThread();
+ private WindowUtils() {
+ }
+
+ public static void centerDown(Container c)
+ {
+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+ Dimension windowSize = c.getSize();
+ if (windowSize.height > screenSize.height)
+ windowSize.height = screenSize.height;
+ if (windowSize.width > screenSize.width)
+ windowSize.width = screenSize.width;
+ c.setLocation((screenSize.width - windowSize.width) / 2,
+ (screenSize.height - windowSize.height) );
+ }
+ /**
+ * Call WindowUtils.center(o) with any Frame or Dialog that is to be shown
+ * centered on the screen.
+ *
+ * @param container
+ */
+ public static void center(Container c) {
+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+ Dimension windowSize = c.getSize();
+ if (windowSize.height > screenSize.height)
+ windowSize.height = screenSize.height;
+ if (windowSize.width > screenSize.width)
+ windowSize.width = screenSize.width;
+ c.setLocation((screenSize.width - windowSize.width) / 2,
+ (screenSize.height - windowSize.height) / 2);
+ }
+
+ /**
+ * call setWaitCursor(Jcomponent comp,true) to show waiting cursor and
+ * setWaitCursor(Jcomponent comp,false) to turn it off again
+ *
+ * @param comp -
+ * a component
+ * @param on -
+ * true or false, i.e. turn on / off
+ */
+ public static void setWaitCursor(JComponent comp, boolean on) {
+ //wenns Änderungen des Standardcursoraussehens während Runtime gibt,
+ //keine statische Var benutzten
+ if (comp == null)
+ return;
+ Container toplevel = comp.getTopLevelAncestor();
+ if (toplevel != null)
+ if (on)
+ toplevel.setCursor(waitCursor);
+ else
+ toplevel.setCursor(defaultCursor);
+ }
+
+ /**
+ * call setWaitCursor(Window comp,true) to show waiting cursor and
+ * setWaitCursor(Jcomponent comp,false) to turn it off again
+ *
+ * @param comp -
+ * a component
+ * @param on -
+ * true or false, i.e. turn on / off
+ */
+ public static void setWaitCursor(Window comp, boolean isWait) {
+ if (comp != null) {
+ if (isWait)
+ comp.setCursor(new Cursor(Cursor.WAIT_CURSOR));
+ else
+ comp.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
+ }
+
+ }
+
+ public static void maxmizeWidth(java.awt.Window w) {
+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+ w.setSize(new Dimension(screenSize.width, w.getHeight()));
+ }
+
+ public static void maxmizeHeight(java.awt.Window w) {
+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+ w.setSize(new Dimension(w.getWidth(), screenSize.height - 50));
+ }
+
+ /**
+ * Set a Window (Frame/Dialog) to about the maximum size possible
+ *
+ * @param w
+ */
+ public static void maximize(java.awt.Window w) {
+ //java 1.4 JFrame().setExtendedState(JFrame.MAXIMIZED_BOTH)
+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+
+ w.setSize(new Dimension(screenSize.width, screenSize.height - 50));
+ w.setLocation(0, 0);
+ }
+
+ public static void minimize(JFrame f) {
+ //f.setExtendedState(JFrame.m)
+ }
+
+ public static void setThreeQuarterPos(java.awt.Window w) {
+ Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+ w.setSize(new Dimension((int) (screenSize.width * 0.75),
+ (int) (screenSize.height * 0.75)));
+ w.setLocation((int) (screenSize.width * 0.2),
+ (int) (screenSize.height * 0.2));
+ }
+
+ /*
+ *
+ * public static void setDefaultCursor(final JComponent comp) { Runnable
+ * changeCursor = new Runnable() { public void run() {
+ *
+ * Container toplevel = comp.getTopLevelAncestor ();
+ * comp.setCursor(defaultCursor); if (toplevel != null) { toplevel.setCursor
+ * (defaultCursor); } } };
+ *
+ * SwingUtilities.invokeLater(changeCursor); }
+ */
+
+ /*
+ * public static void setWaitCursor(JComponent comp, boolean isWait) { final
+ * Container toplevel = comp.getTopLevelAncestor(); if (toplevel != null) {
+ * if (isWait) toplevel.setCursor(new Cursor(Cursor.WAIT_CURSOR)); else {
+ *
+ * cursorUpdateThread.setContainer(toplevel);
+ * SwingUtilities.invokeLater(cursorUpdateThread); } }
+ * }
+ *
+ * public static void setWaitCursor(Window comp, boolean isWait) { if (comp !=
+ * null) { if (isWait) comp.setCursor(new Cursor(Cursor.WAIT_CURSOR)); else
+ * comp.setCursor(new Cursor(Cursor.DEFAULT_CURSOR)); }
+ * } private static class CursorUpdateThread implements Runnable { private
+ * Container con; public void run() { con.setCursor(new
+ * Cursor(Cursor.DEFAULT_CURSOR)); } public void setContainer(Container
+ * container) { con = container; } }
+ */
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/XMLFileAppender.java b/src/de/memtext/util/XMLFileAppender.java
new file mode 100644
index 0000000..cdb1152
--- /dev/null
+++ b/src/de/memtext/util/XMLFileAppender.java
@@ -0,0 +1,46 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * Eine Beliebige Anzahl von xml-Dateien, wird als eine XML-Datei mit einem
+ * ausgegeben
+ *
+ * @author MB
+ *
+ */
+public class XMLFileAppender {
+
+ public static void main(String[] args) {
+ if (args.length != 3) {
+ System.out.println(
+ "usage XMLFileAppender path files(regex oder Dateiname mehrere mit , getrennt) outputfile");
+ System.exit(0);
+ }
+ System.out.println("XMLFileAppender");
+ try {
+ List files = FileUtils.getFileList(args[0], args[1]);
+ StringBuffer result = new StringBuffer();
+ int i = 0;
+ for (File file : files) {
+ System.out.println(" Lese " + file);
+ String xmlContent = StringUtils.readFile(file);
+ if (i == 0)
+ xmlContent = xmlContent.replaceFirst("<.?xml(.*)>", "\n\n");
+ else
+ xmlContent = xmlContent.replaceFirst("<.?xml(.*)>", "");
+ result.append(xmlContent + "\n");
+ i++;
+ }
+ result.append("\n");
+ System.out.println(" " + i + " Dateien gelesen");
+ System.out.println(" Schreibe " + args[2]);
+ StringUtils.write(new File(args[2]), result.toString());
+ } catch (Exception e) {
+ System.out.println("Fehler bei der Verarbeitung: " + e);
+ System.exit(-1);
+ }
+ }
+}
+// created on 19.12.2017
\ No newline at end of file
diff --git a/src/de/memtext/util/XMLUtils.java b/src/de/memtext/util/XMLUtils.java
new file mode 100644
index 0000000..bb5bfdb
--- /dev/null
+++ b/src/de/memtext/util/XMLUtils.java
@@ -0,0 +1,693 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.w3c.dom.CharacterData;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * A collection of methods dealing with XML. This singleton has an
+ * de.memtext.util.ExceptionHandler which shows a GUI-Message and calls
+ * System.exit(); An inner static class DTDErrorHandler, makes XML parsing
+ * exceptions better readable.
+ */
+public class XMLUtils {
+ private static ExceptionHandler exceptionHandler = new ExceptionHandler();
+ private static DocumentBuilder builder = null;
+ private static Document document = null;
+ private static DocumentBuilderFactory factory;
+
+ private XMLUtils() {
+ }
+
+ // lazy init
+ private static void init() {
+ if (factory == null) {
+ factory = DocumentBuilderFactory.newInstance();
+
+ try {
+ builder = factory.newDocumentBuilder();
+ } catch (ParserConfigurationException e) {
+ handle(e);
+ }
+ builder.setErrorHandler(new DTDErrorHandler());
+ }
+
+ }
+
+ public static Document buildDocument(File f) {
+ return buildDocument(f, false);
+ }
+
+ public static Document buildDocument(File file, boolean isValidating) {
+ init();
+ factory.setValidating(isValidating);
+
+ Document document = null;
+ try {
+ if (!file.canRead())
+ throw new IOException("can't read file "
+ + file.getAbsolutePath());
+ document = builder.parse(file);
+
+ } catch (Throwable e) {
+ handle(e);
+ }
+ return document;
+ }
+
+ public static Document buildDocument(InputStream in, boolean isValidating) {
+ init();
+ factory.setValidating(isValidating);
+
+ try {
+ document = builder.parse(in);
+ } catch (Throwable e) {
+ handle(e);
+ }
+
+ return document;
+ }
+
+ public static Document buildDocumentFromString(String input,
+ boolean isValidating) {
+ init();
+ factory.setValidating(isValidating);
+ InputSource is = new InputSource(new StringReader(input));
+ try {
+ document = builder.parse(is);
+ } catch (Throwable e) {
+ handle(e);
+ }
+
+ return document;
+ }
+ public static Document buildDocumentFromStringWithException(String input,
+ boolean isValidating) throws SAXException, IOException {
+ init();
+ factory.setValidating(isValidating);
+ InputSource is = new InputSource(new StringReader(input));
+
+ document = builder.parse(is);
+
+
+ return document;
+ }
+
+ /**
+ * ohne internen ExceptionHandler
+ *
+ * @param input
+ * @param isValidating
+ * @return
+ */
+ public static Document buildDocumentFromString2(String input,
+ boolean isValidating) throws Exception {
+ init();
+ factory.setValidating(isValidating);
+ InputSource is = new InputSource(new StringReader(input));
+
+ document = builder.parse(is);
+
+ return document;
+ }
+
+ public static Document buildDocumentFromXmlUrl(String url,
+ boolean isValidating) {
+ init();
+ factory.setValidating(isValidating);
+
+ try {
+ document = builder.parse(url);
+ } catch (Throwable e) {
+ handle(e);
+ }
+
+ return document;
+ }
+
+ /**
+ * Checks if a node has an attribute of a given name
+ *
+ * @param node
+ * - the node to be checked
+ * @param attribname
+ * - the name of the attribute to be looked for
+ * @return true if the node has the attribute
+ */
+ public static boolean hasAttrib(Node node, String attribname) {
+ if (node == null)
+ throw new IllegalArgumentException("node is null - can't check");
+ if (attribname == null)
+ throw new IllegalArgumentException(
+ "attribname is null - can't check");
+ NamedNodeMap map = node.getAttributes();
+ boolean result = false;
+ if (map != null && map.getNamedItem(attribname) != null)
+ result = true;
+ return result;
+ }
+
+ /**
+ * Gets the value of a node's attribute
+ *
+ * @param node
+ * - relevant node
+ * @param attribname
+ * - name of the attribute
+ * @return String value of t
+ */
+ public static String getAttribValue(Node node, String attribname) {
+ return getNamedItemValueFromAttribs(node, attribname);
+ }
+
+ public static void setAttribValue(Node node, String name, String value) {
+ Element e = (Element) node;
+ e.setAttribute(name, value);
+
+ }
+
+ /**
+ * Gets the value of the first child of a node, If it contains a
+ * CDATA-Section, the plain text is returned.
+ *
+ * @param node
+ * - relevant node
+ * @return String value of the node
+ * @throws IllegalArgumentException
+ * if node is null, the node has no child or the first child is
+ * neither of TEXT nor of CDATA Type
+ */
+
+ public static String getTheValue(Node node) {
+ String result = "";
+ if (node == null)
+ throw new IllegalArgumentException("Node is null can't get value");
+ Node n = node.getFirstChild();
+ if (n == null)
+ throw new IllegalArgumentException("Node " + node
+ + " can't get value - no child node found");
+ if (n.getNodeType() == Node.TEXT_NODE) {
+ result = n.getNodeValue();
+ }
+ if (n.getNodeType() == Node.CDATA_SECTION_NODE) {
+ CharacterData txt = (CharacterData) n;
+ result = txt.getData();
+ }
+ return result;
+ }
+
+ /**
+ * Gets the text value of all children of a node, If it contains a
+ * CDATA-Section, the plain text is returned.
+ *
+ * @param node
+ * - relevant node
+ * @return String value of the node
+ * @throws IllegalArgumentException
+ * if node is null
+ */
+ public static String getChildNodeValues(Node node) {
+ String result = "";
+ int anz, i;
+ Node child;
+ if (node == null)
+ throw new IllegalArgumentException("Node is null can't get value");
+ NodeList mynodes = node.getChildNodes();
+ anz = mynodes.getLength();
+ for (i = 0; i <= anz; i++) {
+ child = mynodes.item(i);
+ if (child != null) {
+ if (child.getNodeType() == Node.TEXT_NODE) {
+ result += child.getNodeValue();
+ }
+ if (child.getNodeType() == Node.CDATA_SECTION_NODE) {
+ CharacterData txt = (CharacterData) child;
+ result += txt.getData();
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Checks if a node has a value
+ *
+ * @param node
+ * @return true if a value can be obtained (i.e. first child is text or
+ * CDATA)
+ * @throws IllegalArgumentException
+ * if node is null
+ */
+ public static boolean hasValue(Node node) {
+ boolean result = false;
+ if (node == null)
+ throw new IllegalArgumentException("Node is null can't check");
+ if (node.hasChildNodes()) {
+ Node firstChildNode = node.getFirstChild();
+ if (firstChildNode.getNodeType() == Node.TEXT_NODE
+ || firstChildNode.getNodeType() == Node.CDATA_SECTION_NODE)
+ result = true;
+ }
+ return result;
+ }
+
+ /**
+ * Gets an iterator of a node's children, leaving out COMMENT and TEXT_NODES
+ *
+ * @param aNode
+ * @return iterator over node's children which aren't COMMENT and TEXT_NODES
+ */
+ public static Iterator getChildNodeIterator(Node aNode) {
+ List result = new LinkedList();
+ NodeList rawList = aNode.getChildNodes();
+ for (int i2 = 0; i2 < rawList.getLength(); i2++) {
+ Node n = rawList.item(i2);
+ if (n.getNodeType() == Node.TEXT_NODE
+ || n.getNodeType() == Node.COMMENT_NODE)
+ continue;
+ result.add(n);
+ }
+ return result.iterator();
+ }
+
+ /**
+ * Gets the value of a childnode.
+ *
+ * @param node
+ * - parent node
+ * @param name
+ * - name of the child node
+ * @return String value of the child node
+ * @throws IllegalArgumentException
+ * if child not found
+ */
+ public static String getChildNodeValue(Node node, String name) {
+ String result = null;
+ Node childnode = getChildNode(node, name);
+ if (childnode.hasChildNodes())
+ result = childnode.getFirstChild().getNodeValue();
+ return result;
+
+ }
+
+ /**
+ * Gets the number of nodes with a special name that can be found in a
+ * document
+ *
+ * @param document
+ * - the document which is searched
+ * @param name
+ * - name of the nodes to be counted
+ * @return int - number of nodes of a specified name
+ */
+ public static int getNodeCount(Document document, String name) {
+ NodeList list = document.getElementsByTagName(name);
+ return list.getLength();
+ }
+
+ /**
+ * Gets the first node of a special name which is found in a document.
+ *
+ * @param document
+ * - the document which is searched
+ * @param name
+ * - name of the node
+ * @return Node - first node of the given name
+ * @throws IllegalArgumentException
+ * - if no node of the given name found
+ */
+ public static Node getFirstNode(Document document, String name) {
+ if (getNodeCount(document, name) == 0)
+ throw new IllegalArgumentException("No node with name:" + name
+ + " found");
+ NodeList list = document.getElementsByTagName(name);
+ return list.item(0);
+ }
+
+ /**
+ * Gets the value of the first node of a certain name
+ *
+ * @param document
+ * @param nodename
+ * @return
+ * @throws IllegalArgumentException
+ * if no node found or that node has no value
+ */
+ public static String getFirstNodeValue(Document document, String nodename) {
+ Node node = getFirstNode(document, nodename);
+ return getTheValue(node);
+ }
+
+ public static Node getFirstNodeWithNameAndAttrib(Document d, String nodename,
+ String attribname, String attribvalue) {
+ Node result = null;
+ NodeList list = document.getElementsByTagName(nodename);
+ for (int i = 0; i < list.getLength(); i++) {
+ Node n = list.item(0);
+ if (XMLUtils.hasAttrib(n, attribname)
+ && XMLUtils.getAttribValue(n, attribname).equals(
+ attribvalue)) {
+ result = n;
+ break;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Checks if a document has any nodes of a certain name
+ *
+ * @param document
+ * @param name
+ * - name of the nodes to be looked for
+ * @return true - if any nodes of the name found
+ */
+ public static boolean hasANodeWithName(Document document, String name) {
+ return (getNodeCount(document, name) > 0);
+ }
+
+ /**
+ * Checks if a node has any child nodes of a certain name
+ *
+ * @param node
+ * - parent node to be checked
+ * @param name
+ * - name of child node
+ * @return true - if and child nodes with the name found
+ */
+ public static boolean hasChildNode(Node node, String name) {
+ NodeList nl = node.getChildNodes();
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node n = nl.item(i);
+ if (n.getNodeName().equals(name))
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Gets a child of a given node
+ *
+ * @param node
+ * - parent node
+ * @param name
+ * - name of the desired child
+ * @return Node - child of parent node with the specified name
+ * @throws IllegalArgumentException
+ * if child not found
+ */
+ public static Node getChildNode(Node node, String name) {
+ NodeList nl = node.getChildNodes();
+ Node childnode = null;
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node n = nl.item(i);
+ if (n.getNodeName().equals(name))
+ childnode = n;
+ }
+ if (childnode == null)
+ throw new IllegalArgumentException("Node " + node
+ + " doesn't have a child " + name);
+ return childnode;
+ }
+
+ /**
+ * Gets a java.util.List with the values of a node's children where the
+ * children have a certain name
+ *
+ * @param node
+ * - parent node to be checked
+ * @param childnodename
+ * - only values of children with the given name are returned
+ * @return List with values of childnodes with a given name
+ */
+ public static java.util.List getListWithValuesOfNodes(Node node,
+ String childnodename) {
+ Node aNode;
+ String value;
+ java.util.List result = new LinkedList();
+ NodeList nl = node.getChildNodes();
+ for (int i = 0; i < nl.getLength(); i++) {
+ aNode = nl.item(i);
+ if (!aNode.getNodeName().equals(childnodename))
+ continue;
+
+ result.add(aNode.getFirstChild().getNodeValue());
+ }
+ return result;
+ }
+
+ /**
+ * Gets a list with values of attributes of child nodes with a special name
+ *
+ * @param parentNode
+ * @param acceptedChildNodeName
+ * - only child nodes with this name are considered
+ * @param attribName
+ * - the name of the attribute whose value is wanted
+ * @return List with values of attributes of child nodes with a special name
+ */
+ public static java.util.List getListWithAttribOfNodes(Node parentNode,
+ String acceptedChildNodeName, String attribName) {
+ Node aNode;
+ String value;
+ java.util.List result = new LinkedList();
+ NodeList nl = parentNode.getChildNodes();
+ for (int i = 0; i < nl.getLength(); i++) {
+ aNode = nl.item(i);
+ if (!aNode.getNodeName().equals(acceptedChildNodeName))
+ continue;
+ result.add(XMLUtils.getAttribValue(aNode, attribName));
+ }
+ return result;
+ }
+
+ private static String getNamedItemValueFromAttribs(Node node, String name) {
+ String result = "";
+ NamedNodeMap attribs = node.getAttributes();
+ if (attribs == null)
+ throw new RuntimeException("node " + node
+ + " doesn't habe attribs - was looking for attrib:" + name);
+
+ Node node2 = attribs.getNamedItem(name);
+ if (node2 == null)
+ throw new RuntimeException("node " + node
+ + " doesn't habe attribute:" + name);
+ result = node2.getNodeValue();
+ return result;
+ }
+
+ public static void setExceptionHandler(ExceptionHandler handler) {
+ exceptionHandler = handler;
+ }
+
+ static public ExceptionHandler getExceptionHandler() {
+ return exceptionHandler;
+ }
+
+ static public void handle(Throwable e) {
+ exceptionHandler.handle(e);
+ System.out.println(e);
+ }
+
+ public static void main(String a[]) {
+ Document d = XMLUtils.buildDocument(new File("/home/superx/tomcat_sx/webapps/superx/xml/tablle_fo_pdf.xsl"));
+ Node headernode=XMLUtils.getFirstNodeWithNameAndAttrib(d,"fo:static-content","flow-name","xsl-region-before");
+
+ /*String aci = "";
+ String n = "";
+ String cad = "";
+ Charset charset = Charset.forName("ISO-8859-1");
+ CharsetDecoder decoder = charset.newDecoder();
+ CharsetEncoder encoder = charset.newEncoder();
+
+ long iValue;
+ int iCount;
+ System.out.println("tabla de ascii");
+ for (iCount = 65; iCount <= 165; iCount++) {
+ aci = new Character((char) iCount).toString();
+ try {
+ n = new String(aci.getBytes("ISO-8859-1"));
+ ByteBuffer bbuf = encoder.encode(CharBuffer.wrap(aci));
+ CharBuffer cbuf = decoder.decode(bbuf);
+ n = cbuf.toString();
+ } catch (Exception ex) {
+ }
+ iValue = (int) n.charAt(0);
+ System.out
+ .println(" int: " + iCount + " ascii:" + n + " " + iValue);
+ }*/
+ }
+
+ static class DTDErrorHandler implements ErrorHandler {
+ public void warning(SAXParseException error) throws RuntimeException {
+ handle(new RuntimeException("XML-Parse Exception Zeile: "
+ + error.getLineNumber() + "\nDatei: " + error.getSystemId()
+ + "\n" + error.getMessage()));
+ }
+
+ public void error(SAXParseException error) throws RuntimeException {
+ handle(new RuntimeException("XML-Parse Exception Zeile: "
+ + error.getLineNumber() + "\nDatei: " + error.getSystemId()
+ + "\n" + error.getMessage()));
+ }
+
+ public void fatalError(SAXParseException error) throws RuntimeException {
+ // handle( new RuntimeException(
+ System.out.println("XML-Parse Exception Zeile: "
+ + error.getLineNumber() + "\nDatei: " + error.getSystemId()
+ + "\n" + error.getMessage());
+ }
+
+ }
+
+ public static int getChildNodeCount(Node aNode, String name) {
+ int result = 0;
+ NodeList rawList = aNode.getChildNodes();
+ for (int i2 = 0; i2 < rawList.getLength(); i2++) {
+ Node n = rawList.item(i2);
+ if (n.getNodeType() == Node.TEXT_NODE
+ || n.getNodeType() == Node.COMMENT_NODE)
+ continue;
+ if (n.getNodeName().equals(name))
+ result++;
+ }
+ return result;
+ }
+ public static int getChildNodeCount(Node aNode) {
+ int result = 0;
+ NodeList rawList = aNode.getChildNodes();
+ for (int i2 = 0; i2 < rawList.getLength(); i2++) {
+ Node n = rawList.item(i2);
+ if (n.getNodeType() == Node.TEXT_NODE
+ || n.getNodeType() == Node.COMMENT_NODE)
+ continue;
+
+ result++;
+ }
+ return result;
+ }
+
+ public static String removeTroublesomeCharacters(StringBuffer inString) {
+ return removeTroublesomeCharacters(inString.toString());
+
+ }
+
+ public static String removeTroublesomeCharactersXX(String inString) {
+
+ String xx = "";
+ String n = "";
+ long iValue;
+ int iCount;
+ Charset charset = Charset.forName("ISO-8859-1");
+ CharsetDecoder decoder = charset.newDecoder();
+ CharsetEncoder encoder = charset.newEncoder();
+
+ for (iCount = 128; iCount <= 165; iCount++) {
+ xx = new Character((char) iCount).toString();
+ try {
+ n = new String(xx.getBytes("ISO-8859-1"));
+ ByteBuffer bbuf = encoder.encode(CharBuffer.wrap(xx));
+ CharBuffer cbuf = decoder.decode(bbuf);
+ n = cbuf.toString();
+ inString = StringUtils.replace(inString, xx, n);
+ } catch (Exception ex) {
+ System.out.println(ex.toString());
+ }
+ iValue = (int) xx.charAt(0);
+ // System.out.println(" int: " + iCount + " ascii:" + xx + " "
+ // +iValue);
+
+ }
+ for (int i = 0; i < inString.length(); i++) {
+ if (((int) inString.charAt(i)) > 127
+ && ((int) inString.charAt(i)) < 255) {
+ System.out.println("pos " + i + " "
+ + ((int) inString.charAt(i)));
+ }
+ }
+ return inString;
+ }
+
+ /*
+ * Removes control characters and other non-UTF-8 characters The string to process A string with no
+ * control characters or entities above 0x00FD
+ */
+ public static String removeTroublesomeCharacters(String input) {
+ if (input == null)
+ return null;
+ String output = input;
+ int l1 = 150; // long dash
+ int l2 = 151; // long dash
+ int l3 = 132;// schräge Anführungszeichen unten
+ int l4 = 152;// schräge Anführungszeichen oben
+ int l5 = 147;// schräge Anführungszeichen oben
+ int l6 = 148;// schräge Anführungszeichen oben
+ int l7 = 145;// '
+ int l8 = 146;// '
+ int l9 = 128;// EURO-Zeichen
+ int l10 = 133;// a mit apostoph
+ int l11 = 149;// vermurkstes Aufzählungszeichen aus Word
+ output = output.replace((char) l1, '-');
+ output = output.replace((char) l2, '-');
+ output = output.replace((char) l3, '\"');
+ output = output.replace((char) l4, '\"');
+ output = output.replace((char) l5, '\"');
+ output = output.replace((char) l6, '\"');
+ // inString=StringUtils.replace(inString, ""+(char)l3, "„");
+ // inString=StringUtils.replace(inString, ""+(char)l4, "”");
+ // inString=StringUtils.replace(inString, ""+(char)l5, "”");
+ // inString=StringUtils.replace(inString, ""+(char)l6, "”");
+ output = StringUtils.replace(output, "" + (char) l9, "EUR");
+ output = output.replace((char) l7, '\'');
+ output = output.replace((char) l8, '\'');
+ output = output.replace((char) l10, 'à');
+ output = output.replace((char) l11, ' ');
+ output = output.replace((char) 147, ' ');
+ output = output.replace((char) 149, '-'); // AUfzählungszeichen bull
+
+ StringBuilder newString = new StringBuilder();
+ char ch;
+
+ for (int i = 0; i < output.length(); i++) {
+
+ ch = output.charAt(i);
+ // remove any characters outside the valid UTF-8 range as well as
+ // all control characters
+ // except tabs and new lines
+ if ((ch < 0x00FD && ch > 0x001F) || ch == '\t' || ch == '\r'
+ || ch == '\n') {
+ newString.append(ch);
+ }
+ }
+ return newString.toString();
+ //return input;
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/memtext/util/XmlFlatFileMerger.java b/src/de/memtext/util/XmlFlatFileMerger.java
new file mode 100644
index 0000000..f088bf4
--- /dev/null
+++ b/src/de/memtext/util/XmlFlatFileMerger.java
@@ -0,0 +1,170 @@
+package de.memtext.util;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.dom4j.Document;
+import org.dom4j.DocumentException;
+import org.dom4j.Element;
+import org.dom4j.Node;
+import org.dom4j.io.OutputFormat;
+import org.dom4j.io.SAXReader;
+import org.dom4j.io.XMLWriter;
+
+/**
+ * @author brummer
+ *
+ */
+public class XmlFlatFileMerger {
+
+ /**
+ * @param args
+ * @return
+ */
+ public static void main(String[] args) {
+ if (args.length < 5 || args.length > 6)
+ System.exit(0);
+ String dir = args[0];
+ String inPattern = args[1];
+ String outFile = args[2];
+ String xpath = args[3];
+ String attribute = args[4];
+ String encoding = "UTF-8";
+ if (args.length == 6) {
+ encoding = args[5];
+ }
+ flatMergeXmlFiles(dir, inPattern, outFile, xpath, attribute, encoding);
+ }
+
+ /**
+ * @param inDir
+ * @param inPattern
+ * @param outFile
+ * @param xpath
+ * @param mergeAttribute
+ * @return
+ */
+ public static boolean flatMergeXmlFiles(String inDir, String inPattern,
+ String outFile, String xpath, String mergeAttribute, String encoding) {
+ boolean success = false;
+ final Pattern filePattern = Pattern.compile(inPattern);
+ File dir = new File(inDir);
+ if (dir.isDirectory()) {
+ File[] inFiles = dir.listFiles(new FileFilter() {
+ @Override
+ public boolean accept(File pathname) {
+ Matcher m = filePattern.matcher(pathname.getName());
+ return m.matches();
+ }
+ });
+ SAXReader reader = new SAXReader();
+ Map> outNodes = new LinkedHashMap>();
+ Document doc = null;
+ Element root = null;
+ Collection dimensionNames = new HashSet();// Dimensions
+ // nur
+ // einmal
+ // einfuegen
+ for (File inFile : inFiles) {
+ try {
+ doc = reader.read(inFile);
+ } catch (DocumentException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ root = doc.getRootElement();
+ List elements = (List) root.elements();
+ for (Element element : elements) {
+ String type = element.getName();
+ String name = element.attributeValue("name");
+
+ System.out.println(type + " : " + name);
+ if (!outNodes.containsKey(type)) {
+ outNodes.put(type, new HashMap());
+ }
+ //Dimension nur einmal hinzufuegen
+ if (type.equals("Dimension")) {
+ if (dimensionNames.contains(name))
+ {
+ System.out.println("Dimension " + name + " already exists.");
+ Node newDim = element.detach();
+ Node oldDim = outNodes.get(type).get(name);
+ if (!newDim.asXML().equals(oldDim.asXML())) {
+ String msg = "Dimension " + name + " has differing entries in " + inFile.getName() + "! Please fix.";
+ System.out.println(msg);
+ throw new RuntimeException(msg);
+ }
+ }
+ else
+ {
+ outNodes.get(type).put(name, element.detach());
+ dimensionNames.add(name);
+ }
+ } else {
+ outNodes.get(type).put(name, element.detach());
+ }
+ }
+ for (Entry> entry : outNodes
+ .entrySet()) {
+ System.out.println("All elements of type " + entry.getKey()
+ + ":");
+ SortedSet sortedEntries = new TreeSet(entry
+ .getValue().keySet());
+ for (String key : sortedEntries) {
+ System.out.println("Name: " + key);
+ root.add(entry.getValue().get(key).detach());
+ }
+ }
+ }
+ FileOutputStream fos = null;
+ try {
+ fos = new FileOutputStream(dir.getAbsolutePath()
+ + File.separator + outFile);
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ OutputFormat format = OutputFormat.createPrettyPrint();
+ format.setEncoding(encoding);
+ XMLWriter writer = null;
+ try {
+ writer = new XMLWriter(fos, format);
+// writer.setMaximumAllowedCharacter(127);
+ } catch (UnsupportedEncodingException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ try {
+ writer.write(doc);
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ try {
+ writer.flush();
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ success = true;
+ }
+ return success;
+ }
+
+}
diff --git a/src/de/memtext/widgets/BeginnerScreen.java b/src/de/memtext/widgets/BeginnerScreen.java
new file mode 100644
index 0000000..6977b6c
--- /dev/null
+++ b/src/de/memtext/widgets/BeginnerScreen.java
@@ -0,0 +1,32 @@
+package de.memtext.widgets;
+
+import java.awt.Frame;
+import java.awt.HeadlessException;
+
+import javax.swing.JCheckBox;
+
+import de.memtext.dlg.OkDlg;
+/**
+ * Implementing subclasses have to place the checkbox.
+ * If the checkbox was selected when clicking OK the method dontshowAgain is
+ * executed
+ */
+public abstract class BeginnerScreen extends OkDlg {
+ protected JCheckBox cxDontShowAgain =
+ new JCheckBox("Diese Seite nicht mehr zeigen");
+ public BeginnerScreen(Frame owner, String title) throws HeadlessException {
+ super(owner, title);
+
+ }
+
+ final protected void performOk() {
+ if (cxDontShowAgain.isSelected())
+ dontShowAgain();
+ this.hide();
+ }
+
+ abstract protected void dontShowAgain();
+
+}
+
+//Created on 22.06.2004 at 08:40:06
\ No newline at end of file
diff --git a/src/de/memtext/widgets/CardLayoutPanel.java b/src/de/memtext/widgets/CardLayoutPanel.java
new file mode 100644
index 0000000..d2fe5c3
--- /dev/null
+++ b/src/de/memtext/widgets/CardLayoutPanel.java
@@ -0,0 +1,68 @@
+package de.memtext.widgets;
+
+import java.awt.CardLayout;
+import java.awt.Component;
+import java.util.Hashtable;
+
+import javax.swing.JPanel;
+
+/**
+ *
+* Convenience JPanel that uses cardLayout, simply add Containers with
+* cardPanel.add(panel, "name")
+* you can then use first(),last(),next() and show(String name)
+ */
+public class CardLayoutPanel extends JPanel {
+ private CardLayout cardLayout = new CardLayout();
+ private Hashtable tab = new Hashtable();
+ public CardLayoutPanel(boolean arg0) {
+ super(arg0);
+ setLayout(cardLayout);
+ }
+
+ public CardLayoutPanel() {
+ super();
+ setLayout(cardLayout);
+ }
+ public Component getSelectedComponent() {
+ Component comp = null;
+ int ncomponents = this.getComponentCount();
+ for (int i = 0; i < ncomponents; i++) {
+ comp = this.getComponent(i);
+ if (comp.isVisible()) {
+ break;
+ }
+ int i2=1;
+ }
+ return comp;
+ }
+ /**
+ * show the panel with the specified name
+ * @param name
+ */
+ public void show(String name) {
+ cardLayout.show(this, name);
+ }
+
+ /**
+ * show the first panel that was added
+ */
+ public void first() {
+ cardLayout.first(this);
+ }
+
+ /**
+ * show the last panel that was added
+ */
+ public void last() {
+ cardLayout.last(this);
+ }
+
+ /**
+ * * show the next panel that was added
+ */
+ public void next() {
+ cardLayout.next(this);
+ }
+
+}
diff --git a/src/de/memtext/widgets/ConfirmedAction.java b/src/de/memtext/widgets/ConfirmedAction.java
new file mode 100644
index 0000000..9a7dc84
--- /dev/null
+++ b/src/de/memtext/widgets/ConfirmedAction.java
@@ -0,0 +1,70 @@
+package de.memtext.widgets;
+
+import java.awt.event.ActionEvent;
+
+import javax.swing.AbstractAction;
+import javax.swing.Icon;
+import javax.swing.JOptionPane;
+
+/**
+ * An Action that has to be confirmed before it is actually performed.
+ * The default question is "Are you sure" but can be changed with setQuestion()
+ * Subclasses must override actionPerformed and therein call
+ * super.actionPerformed(ae);
+ if (isConfirmed())
+ {
+ }
+ */
+public abstract class ConfirmedAction extends AbstractAction {
+private String question="Are you sure?";
+private boolean isConfirmed=false;
+
+ public ConfirmedAction() {
+ super();
+ }
+
+ public ConfirmedAction(String arg0) {
+ super(arg0);
+ }
+
+ public ConfirmedAction(String arg0, Icon arg1) {
+ super(arg0, arg1);
+ }
+
+
+ public void actionPerformed(ActionEvent arg0) {
+ int result=JOptionPane.showConfirmDialog(null,question,question,JOptionPane.YES_NO_OPTION);
+ if (result!=JOptionPane.YES_OPTION)
+ {
+ isConfirmed=false;
+ return;
+ }
+ else
+ isConfirmed=true;
+ }
+
+/**
+ * Returns the question.
+ * @return String
+ */
+public String getQuestion() {
+ return question;
+}
+
+/**
+ * Sets the question.
+ * @param question The question to set
+ */
+public void setQuestion(String question) {
+ this.question = question;
+}
+
+/**
+ * Returns the isConfirmed.
+ * @return boolean
+ */
+public boolean isConfirmed() {
+ return isConfirmed;
+}
+
+}
diff --git a/src/de/memtext/widgets/DoubleIconLabel.java b/src/de/memtext/widgets/DoubleIconLabel.java
new file mode 100644
index 0000000..13e3876
--- /dev/null
+++ b/src/de/memtext/widgets/DoubleIconLabel.java
@@ -0,0 +1,62 @@
+/*
+ * Created on 20.06.2003
+ *
+ * To change the template for this generated file go to
+ * Window>Preferences>Java>Code Generation>Code and Comments
+ */
+package de.memtext.widgets;
+
+import java.awt.Color;
+import java.awt.Font;
+
+import javax.swing.Icon;
+import javax.swing.JLabel;
+
+/**
+ * A label with two icons , right and left
+ */
+public class DoubleIconLabel extends HorizontalBox {
+ private JLabel lbl,lbl2;
+
+ public DoubleIconLabel(String txt, Icon icon, int alignment) {
+ super();
+ lbl = new JLabel(txt, icon, alignment);
+ add(lbl);
+ lbl2 = new JLabel(icon);
+ addStrut(5);
+ add(lbl2);
+ }
+
+ public DoubleIconLabel(String txt, Icon icon) {
+ this(txt,icon,javax.swing.SwingConstants.LEFT);
+ }
+
+
+ public String getText() {
+ return lbl.getText();
+ }
+
+
+ public void setBackground(Color arg0) {
+ this.setBackground(arg0);
+ lbl.setBackground(arg0);
+ lbl2.setBackground(arg0);
+ }
+
+
+ public void setIcon(Icon arg0) {
+ lbl.setIcon(arg0);
+ lbl2.setIcon(arg0);
+ }
+
+
+ public void setText(String arg0) {
+ lbl.setText(arg0);
+ }
+
+
+ public void setFont(Font arg0) {
+ lbl.setFont(arg0);
+ }
+
+}
diff --git a/src/de/memtext/widgets/EmptyBorderButton.java b/src/de/memtext/widgets/EmptyBorderButton.java
new file mode 100644
index 0000000..6fdd873
--- /dev/null
+++ b/src/de/memtext/widgets/EmptyBorderButton.java
@@ -0,0 +1,46 @@
+package de.memtext.widgets;
+
+import javax.swing.Action;
+import javax.swing.Icon;
+import javax.swing.JButton;
+import javax.swing.border.EmptyBorder;
+
+/**
+ A button with an empty border, size defaults to 5
+ */
+public class EmptyBorderButton extends JButton {
+private int top=5,left=5,bottom=5,right=5;
+
+ public EmptyBorderButton() {
+ super();
+ setBorder(5,5,5,5);
+ }
+
+
+ public EmptyBorderButton(Icon arg0) {
+ super(arg0);
+ setBorder(5,5,5,5);
+ }
+
+
+ public EmptyBorderButton(String arg0) {
+ super(arg0);
+ setBorder(5,5,5,5);
+ }
+
+
+ public EmptyBorderButton(Action arg0) {
+ super(arg0);
+ setBorder(5,5,5,5);
+ }
+
+
+ public EmptyBorderButton(String arg0, Icon arg1) {
+ super(arg0, arg1);
+ setBorder(5,5,5,5);
+ }
+public void setBorder(int top,int left,int bottom,int right)
+{
+ this.setBorder(new EmptyBorder(top,left,bottom,right));
+}
+}
diff --git a/src/de/memtext/widgets/FileOrDirSelectionPanel.java b/src/de/memtext/widgets/FileOrDirSelectionPanel.java
new file mode 100644
index 0000000..e326a16
--- /dev/null
+++ b/src/de/memtext/widgets/FileOrDirSelectionPanel.java
@@ -0,0 +1,48 @@
+package de.memtext.widgets;
+
+import java.awt.event.ActionEvent;
+import java.io.File;
+import java.util.Observer;
+
+import javax.swing.JFileChooser;
+
+import de.memtext.observ.MyObservable;
+
+public class FileOrDirSelectionPanel extends LabeledSelectionPanel {
+ private MyObservable observable=new MyObservable();
+ private JFileChooser chooser = new JFileChooser();
+ public FileOrDirSelectionPanel(String infoText) {
+ super(infoText);
+ }
+
+ public void actionPerformed(ActionEvent ae) {
+
+ int returnVal = chooser.showOpenDialog(this);
+ if (returnVal == JFileChooser.APPROVE_OPTION) {
+ setSelectedObject(chooser.getSelectedFile());
+ setInfoText(chooser.getSelectedFile());
+ observable.markChanged();
+ observable.notifyObservers();
+ }
+
+ }
+ public File getSelectedFile()
+ {
+ return chooser.getSelectedFile();
+ }
+ /**
+ * JFileChooser.FILES_ONLY
+ JFileChooser.DIRECTORIES_ONLY
+ JFileChooser.FILES_AND_DIRECTORIES
+ * @param mode
+ */
+ public void setFileSelectionMode(int mode) {
+ chooser.setFileSelectionMode(mode);
+ }
+
+ public void addObserver(Observer observer) {
+ observable.addObserver(observer);
+ }
+}
+
+//Created on 17.04.2004 at 19:46:44
\ No newline at end of file
diff --git a/src/de/memtext/widgets/FileSelectionPanel.java b/src/de/memtext/widgets/FileSelectionPanel.java
new file mode 100644
index 0000000..0688a7a
--- /dev/null
+++ b/src/de/memtext/widgets/FileSelectionPanel.java
@@ -0,0 +1,47 @@
+package de.memtext.widgets;
+
+import java.awt.event.ActionEvent;
+import java.io.File;
+
+import javax.swing.JFileChooser;
+import javax.swing.filechooser.FileFilter;
+
+/**
+ * A file selection panel.
+ * On the left some text, then a textfield for the file/path and right of
+ * it a button with ... or some text which opens a file selection dialog.
+ * The selected file get be requested with getFileName()
+ *
+ * work in progress
+ */
+public class FileSelectionPanel extends LabeledSelectionPanel {
+
+ private JFileChooser chooser = new JFileChooser();
+
+ public FileSelectionPanel(String txt) {
+ super(txt);
+
+ }
+
+ public void actionPerformed(ActionEvent arg0) {
+ int returnVal = chooser.showOpenDialog(this.getTopLevelAncestor());
+ if (returnVal == JFileChooser.APPROVE_OPTION) {
+ setSelectedObject(chooser.getSelectedFile());
+ setInfoText(chooser.getSelectedFile().getAbsoluteFile());
+ }
+ }
+
+public void setCurrentDir(File dir)
+{
+ chooser.setCurrentDirectory(dir);
+}
+ /**
+ * @param filter
+ */
+ public synchronized void setFileFilter(FileFilter filter) {
+ chooser.setFileFilter(filter);
+ }
+ public File getSelectedFile() {
+ return chooser.getSelectedFile();
+ }
+}
diff --git a/src/de/memtext/widgets/HorizontalBox.java b/src/de/memtext/widgets/HorizontalBox.java
new file mode 100644
index 0000000..9ee5787
--- /dev/null
+++ b/src/de/memtext/widgets/HorizontalBox.java
@@ -0,0 +1,31 @@
+package de.memtext.widgets;
+
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+
+/**
+ * A Horizontal Box - more advanced than simple JPanel with
+ * FlowLayout because Glue and Struts can be applied
+ * see javax.swing.Box
+ */
+public class HorizontalBox extends Box {
+
+ public HorizontalBox() {
+ super(BoxLayout.X_AXIS);
+ }
+ public void addGlue() {
+ this.add(Box.createHorizontalGlue());
+ }
+ public void addStrut(int height) {
+ this.add(Box.createHorizontalStrut(height));
+ }
+ /**
+ * normally full width is used, by this method not
+ */
+/* public void addRespectingPreferredSize(JComponent comp)
+ {
+ JPanel p=new JPanel();
+ p.add(comp);
+ this.add(p);
+ }*/
+}
diff --git a/src/de/memtext/widgets/InfoMessage.java b/src/de/memtext/widgets/InfoMessage.java
new file mode 100644
index 0000000..b497c03
--- /dev/null
+++ b/src/de/memtext/widgets/InfoMessage.java
@@ -0,0 +1,71 @@
+package de.memtext.widgets;
+
+import java.awt.Component;
+
+import javax.swing.JOptionPane;
+
+/**
+ A warning message that can be displayed by calling show()
+ convenience for the JoptionPane method
+ */
+public class InfoMessage {
+ private String msg, title;
+private Component parent;
+ public InfoMessage(Component parent, String msg, String title) {
+ this.parent=parent;
+ this.msg = msg;
+ this.title = title;
+ }
+ public InfoMessage(Component parent, String msg) {
+ this(parent, msg, "");
+ }
+ public void show() {
+ JOptionPane.showMessageDialog(
+ parent,
+ msg,
+ title,
+ JOptionPane.INFORMATION_MESSAGE);
+ }
+ /**
+ * Returns the msg.
+ * @return String
+ */
+ public String getMsg() {
+ return msg;
+ }
+
+ /**
+ * Returns the title.
+ * @return String
+ */
+ public String getTitle() {
+ return title;
+ }
+
+ /**
+ * Sets the msg.
+ * @param msg The msg to set
+ */
+ public void setMsg(String msg) {
+ this.msg = msg;
+ }
+
+ /**
+ * Sets the title.
+ * @param title The title to set
+ */
+ public void setTitle(String title) {
+ this.title = title;
+ }
+ public static void show(Component parent, String text, String title) {
+ JOptionPane.showMessageDialog(
+ parent,
+ text,
+ title,
+ JOptionPane.INFORMATION_MESSAGE);
+ }
+ public static void show(Component parent, StringBuffer msg, String title) {
+ show(parent,msg.toString(), title);
+ }
+
+}
diff --git a/src/de/memtext/widgets/JDirectoryChooser.java b/src/de/memtext/widgets/JDirectoryChooser.java
new file mode 100644
index 0000000..19a843c
--- /dev/null
+++ b/src/de/memtext/widgets/JDirectoryChooser.java
@@ -0,0 +1,63 @@
+package de.memtext.widgets;
+
+import java.awt.Component;
+import java.io.File;
+
+import javax.swing.JFileChooser;
+import javax.swing.filechooser.FileSystemView;
+
+public class JDirectoryChooser extends JFileChooser {
+ private File selectedFile;
+ public JDirectoryChooser() {
+ super();
+ init();
+ }
+
+ public JDirectoryChooser(String arg0) {
+ super(arg0);
+ init();
+ }
+
+ public JDirectoryChooser(File arg0) {
+ super(arg0);
+ init();
+ }
+
+ public JDirectoryChooser(FileSystemView arg0) {
+ super(arg0);
+ init();
+ }
+
+ public JDirectoryChooser(File arg0, FileSystemView arg1) {
+ super(arg0, arg1);
+ init();
+ }
+
+ public JDirectoryChooser(String arg0, FileSystemView arg1) {
+ super(arg0, arg1);
+ init();
+ }
+ public void show(Component parent) {
+ int returnVal = this.showOpenDialog(parent);
+ if (returnVal == JFileChooser.APPROVE_OPTION) {
+ selectedFile = this.getSelectedFile();
+ } else
+ selectedFile = null;
+ }
+ public File getSelectedDirectory() {
+ return selectedFile;
+ }
+ public boolean wasCancelled()
+ {
+ return selectedFile==null;
+ }
+ private void init() {
+ setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+ }
+ public static void main(String[] args) {
+
+
+ }
+}
+
+//Created on 24.10.2003
\ No newline at end of file
diff --git a/src/de/memtext/widgets/LabeledComboBox.java b/src/de/memtext/widgets/LabeledComboBox.java
new file mode 100644
index 0000000..6cbafe8
--- /dev/null
+++ b/src/de/memtext/widgets/LabeledComboBox.java
@@ -0,0 +1,143 @@
+package de.memtext.widgets;
+
+import java.awt.FlowLayout;
+import java.awt.event.ActionListener;
+import java.awt.event.ItemListener;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Vector;
+
+import javax.swing.JComboBox;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+import de.memtext.baseobjects.NamedIdObjectI;
+
+
+public class LabeledComboBox extends HorizontalBox {
+
+ private JLabel lbl = new JLabel();
+ private JComboBox combobox;
+
+ public LabeledComboBox(String lblText)
+ {
+ combobox=new JComboBox();
+ initGui(lblText);
+ }
+ public LabeledComboBox(String lblText, Vector model) {
+
+ combobox = new JComboBox(model);
+ initGui(lblText);
+ }
+
+ public LabeledComboBox(String lblText, Collection elements) {
+ this(lblText, new Vector(elements));
+ }
+
+ /**
+ * A constructor that makes LabeledComboBox also a Decorator
+ * @param lblText
+ * @param combobox
+ */
+ public LabeledComboBox(String lblText,JComboBox combobox)
+ {
+ if (combobox==null)throw new IllegalArgumentException("Combox must not be null");
+ this.combobox=combobox;
+ initGui(lblText);
+
+ }
+ public int getSelectedIntValue()
+ {
+ Integer val=(Integer) this.getSelectedItem();
+ return val.intValue();
+ }
+ public double getSelectedDoubleValue()
+ {
+ Double val=(Double) this.getSelectedItem();
+ return val.doubleValue();
+ }
+ private void initGui(String lblText) {
+ this.setName("lblComboBox-"+lblText);
+ lbl.setText(lblText);
+ JPanel p = new JPanel(new FlowLayout(FlowLayout.LEFT));
+ p.add(lbl);
+ p.add(combobox);
+ combobox.setName("cb-"+lblText);
+ this.add(p);
+ }
+ public void setSelectedIndex(int index) {
+ combobox.setSelectedIndex(index);
+ }
+ public void addItems(Collection col) {
+
+ for (Iterator iter = col.iterator(); iter.hasNext();) {
+ Object element = (Object) iter.next();
+ combobox.addItem(element);
+ }
+
+ }
+ public void removeAllItems() {
+
+ combobox.removeAllItems();
+ }
+
+ public void setEnabled(boolean b) {
+ lbl.setEnabled(b);
+ combobox.setEnabled(b);
+
+ }
+ public void addActionListener(ActionListener al) {
+ combobox.addActionListener(al);
+ }
+
+ public static void main(String a[]) {
+ MBFrame f = new MBFrame("");
+ VerticalBox vb = new VerticalBox();
+ LabeledComboBox b = new LabeledComboBox("bla", new Vector());
+ LabeledComboBox b2 = new LabeledComboBox("bla2", new Vector());
+ vb.add(b);
+ vb.add(b2);
+ f.setCenter(vb);
+ f.pack();
+ f.show();
+ }
+ public Object getSelectedItem() {
+ return combobox.getSelectedItem();
+ }
+ /**
+ * Convienience method that returns the id of the selected
+ * item if it implements NamedIdObjectI
+ * @return Object id
+ * @throws RuntimeException if selected item doesn't implement NamedIdObjectI
+ */
+ public Object getSelectedItemId() {
+ if (!(combobox.getSelectedItem() instanceof NamedIdObjectI))
+ throw new RuntimeException("this function is only available if elements of combobox implement NamedIdObjectI");
+ NamedIdObjectI obj = (NamedIdObjectI) combobox.getSelectedItem();
+ return obj.getId();
+ }
+ public void setSelectedItem(Object object) {
+ combobox.setSelectedItem(object);
+
+ }
+ public void removeActionListener(ActionListener listener) {
+ combobox.removeActionListener(listener);
+ }
+
+ public void addItemListener(ItemListener listener) {
+ combobox.addItemListener(listener);
+ }
+
+ public void setSelectedItemByName(String name) {
+ throw new UnsupportedOperationException("nicht fertig");
+ /* for (int i = 0; i < getItemCount(); i++) {
+
+ }*/
+ }
+
+ public int getItemCount() {
+ return combobox.getItemCount();
+ }
+}
+
+//Created on 16.11.2003
\ No newline at end of file
diff --git a/src/de/memtext/widgets/LabeledPasswordField.java b/src/de/memtext/widgets/LabeledPasswordField.java
new file mode 100644
index 0000000..3effb00
--- /dev/null
+++ b/src/de/memtext/widgets/LabeledPasswordField.java
@@ -0,0 +1,32 @@
+package de.memtext.widgets;
+
+import javax.swing.JPasswordField;
+
+public class LabeledPasswordField extends LabeledTextField {
+
+ public LabeledPasswordField() {
+ super();
+ }
+
+ public LabeledPasswordField(String lblText) {
+ super(lblText);
+ }
+
+ public LabeledPasswordField(String lblText, int length) {
+ super(lblText, length);
+ }
+
+ public LabeledPasswordField(String lblText, Object value) {
+ super(lblText, value);
+ }
+
+ public LabeledPasswordField(String lblText, Object value, int length) {
+ super(lblText, value, length);
+ }
+void initTextField(int length) {
+ textField = new JPasswordField(length);
+}
+
+}
+
+//Created on 19.04.2004 at 11:55:46
\ No newline at end of file
diff --git a/src/de/memtext/widgets/LabeledSelectionPanel.java b/src/de/memtext/widgets/LabeledSelectionPanel.java
new file mode 100644
index 0000000..5934b4c
--- /dev/null
+++ b/src/de/memtext/widgets/LabeledSelectionPanel.java
@@ -0,0 +1,66 @@
+package de.memtext.widgets;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JPanel;
+
+/**
+ * A selection panel.
+ * On the left some text, then a textfield for the selection and right of
+ * it a button with ... or some text which opens a selection dialog.
+ * The selected object get be requested with getSelectedObject
+ *
+ */
+public abstract class LabeledSelectionPanel
+ extends JPanel
+ implements ActionListener {
+ private JButton btn;
+ //private LabeledTextField fileField=new LabeledTextField(Localizer.get("file"));
+ private LabeledTextField infoField;
+ private Object selectedObject;
+
+ public LabeledSelectionPanel(String infoText) {
+ infoField = new LabeledTextField(infoText, "");
+ infoField.setEditable(false);
+ this.add(infoField);
+ btn = new JButton("auswählen");
+ this.add(btn);
+ btn.addActionListener(this);
+ }
+
+ /**
+ * subclasses must override to show dlg and call
+ * setSelectedObject,setInfoText afterwards
+ *
+ */
+ public abstract void actionPerformed(ActionEvent ae);
+ //throw new UnsupportedOperationException("see doc"); }
+ public void setInfoText(Object txt) {
+ infoField.setValue(txt);
+ }
+ public void setSelectedObject(Object sel) {
+ selectedObject = sel;
+ if (sel == null)
+ infoField.setValue("nichts gewählt");
+ else
+ infoField.setValue(sel);
+
+ }
+ public Object getSelectedObject() {
+ return selectedObject;
+ }
+ public void setEnabled(boolean b) {
+ infoField.setEnabled(b);
+ btn.setEnabled(b);
+ }
+ public void setEditable(boolean b) {
+ infoField.setEditable(b);
+
+ }
+ public void makeTextBoxUnselectable() {
+ infoField.makeUnselectable();
+ }
+
+}
diff --git a/src/de/memtext/widgets/LabeledTextField.java b/src/de/memtext/widgets/LabeledTextField.java
new file mode 100644
index 0000000..75f6c7f
--- /dev/null
+++ b/src/de/memtext/widgets/LabeledTextField.java
@@ -0,0 +1,219 @@
+package de.memtext.widgets;
+
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.sql.Date;
+import java.text.ParseException;
+
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.SwingConstants;
+import javax.swing.event.DocumentListener;
+import javax.swing.text.Document;
+import javax.swing.text.Keymap;
+
+import de.memtext.util.DateUtils;
+
+/**
+ A TextField for entering data that has a label to the left
+ so for example Name : .....
+ if more than one is needed see also MultiLineEditPanel
+ * @see MultiLineEditPanel
+ */
+public class LabeledTextField extends JPanel {
+ private WarningMessage wa = new WarningMessage(this,"Ungültige Eingabe");
+ JTextField textField;
+ private JLabel lbl;
+ public LabeledTextField() {
+ this("", "", 30);
+ }
+ public LabeledTextField(String lblText) {
+ this(lblText, "", 30);
+ }
+ public LabeledTextField(String lblText, int length) {
+ this(lblText, "", length);
+ }
+ public LabeledTextField(String lblText, Object value) {
+ this(lblText, value, 30);
+ }
+ public void setLabelFont(Font f)
+ {
+ lbl.setFont(f);
+ }
+ public LabeledTextField(String lblText, Object value, int length) {
+ this.setLayout(new FlowLayout(FlowLayout.LEFT));
+ this.setBackground(null);
+ this.setName("lblTextField-" + lblText);
+ lbl = new JLabel(lblText, SwingConstants.CENTER);
+ initTextField(length);
+ textField.setBackground(null);
+ textField.setName("tf-" + lblText);
+ if (value == null)
+ value = "";
+ textField.setText(value.toString());
+ add(lbl);
+ add(textField);
+ }
+ void initTextField(int length) {
+ textField = new JTextField(length);
+ }
+ /**
+ * get the value entered in the textfield
+ * @return Object - the value entered in the textfield
+ */
+ public Object getValue() {
+
+ return textField.getText();
+ }
+
+ /**
+ *
+ * @return true if nothing entered in the textfield
+ */
+ public boolean isEmpty() {
+ return textField.getText().length() == 0;
+ }
+ /**
+ * the textfield can be exchanged to be a subclass of JTextField
+ * if needed
+ * @param textField
+ */
+ public void setTextField(JTextField textField) {
+ this.textField = textField;
+ }
+ /**
+ * sets the value of the text field
+ * @param value
+ */
+ public void setValue(Object value) {
+ if (value == null)
+ value = "";
+ textField.setText(value.toString());
+ }
+ /**
+ *
+ * @return - the preferred width of the label
+ */
+ public int getPreferredLabelWidth() {
+ return lbl.getPreferredSize().width;
+ }
+ /**
+ * if a special javax.swing.text.Document is needed,
+ * can be set here
+ * @param document
+ */
+ public void setDocument(Document document) {
+ textField.setDocument(document);
+ }
+
+ /**
+ * Method activateUnicodeReplacements
+ * the combinations of c^,s^ etc are replaced
+ * by single character unicode chars if activated
+ */
+ public void activateUnicodeReplacements() {
+ String rememberText = textField.getText();
+ textField.setDocument(new UnicodeReplacerDocument());
+ textField.setText(rememberText);
+ }
+ public void setHorizontalLabelAlignment(int alignment) {
+ lbl.setHorizontalAlignment(alignment);
+ }
+ public void requestFocus() {
+ textField.requestFocus();
+ }
+ public void setFocusable(boolean b) {
+ super.setFocusable(b);
+ textField.setFocusable(b);
+ }
+ public boolean requestFocusInWindow() {
+ return textField.requestFocusInWindow();
+ }
+ public String toString() {
+ return "value: " + textField.getText();
+ }
+ /**
+ * clears the contents of the textfield
+ */
+ public void clear() {
+ textField.setText("");
+ }
+
+ /**
+ * Method setPreferredLabelWidth.
+ * @param maxLabelLength
+ */
+ public void setPreferredLabelWidth(int maxLabelLength) {
+ Dimension dim = lbl.getPreferredSize();
+ dim.width = maxLabelLength;
+ lbl.setPreferredSize(dim);
+ }
+
+ public void setEditable(boolean b) {
+ textField.setEditable(b);
+
+ }
+ public void setEnabled(boolean b) {
+ textField.setEnabled(b);
+ }
+ public void showWarningMessage() {
+ wa.show();
+ }
+ public boolean isIntegerValue() {
+ boolean result = true;
+ if (!textField.getText().equals("")) {
+ try {
+ int in = Integer.parseInt(textField.getText());
+ result = true;
+ } catch (NumberFormatException e) {
+ result = false;
+ }
+ }
+ return result;
+ }
+ public Integer getIntegerValue() {
+ Integer result = null;
+ if (!textField.getText().equals("")) {
+ result = new Integer(Integer.parseInt(textField.getText()));
+ }
+ return result;
+ }
+ /**
+ * shows Warning if not OK
+ * @return true if the entered value is a valid date
+ */
+ public boolean isDateOk() {
+ return DateUtils.isValidDateStrict(getValue().toString());
+ }
+
+ public Date getDateValue() {
+ Date result = null;
+ try {
+ result = (Date) DateUtils.parse(getValue().toString());
+ } catch (ParseException e) {
+ e.printStackTrace();
+ throw new RuntimeException("rums");
+ }
+ return result;
+ }
+
+ public void makeUnselectable() {
+ TextUnselectableDec dec = new TextUnselectableDec();
+ dec.makeUnselectable(textField);
+ }
+ public String getText() {
+ return textField.getText();
+ }
+ public Keymap getKeymap() {
+ return textField.getKeymap();
+ }
+ public void addDocumentListener(DocumentListener listener) {
+ textField.getDocument().addDocumentListener(listener);
+ }
+ public boolean isDateInFuture() throws ParseException {
+ return DateUtils.isDateInFuture(DateUtils.parse(getValue().toString()));
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/memtext/widgets/LogFrame.java b/src/de/memtext/widgets/LogFrame.java
new file mode 100644
index 0000000..1972105
--- /dev/null
+++ b/src/de/memtext/widgets/LogFrame.java
@@ -0,0 +1,50 @@
+package de.memtext.widgets;
+
+/**
+ A JFrame that can be used to log status information onto.
+ */
+public class LogFrame extends MBFrame {
+ private LogPanel logPanel = new LogPanel(500);
+ /**
+ * Constructor for LogFrame.
+ * @throws HeadlessException
+ */
+ public LogFrame() {
+ initialize();
+ }
+ public LogFrame(String title) {
+ super(title);
+ initialize();
+ }
+ private void initialize() {
+ setSystemExitOnClose(false);
+ setCenter(logPanel);
+ setSize(500, 400);
+ de.memtext.util.WindowUtils.center(this);
+ }
+ /**
+ * logs the given txt on the Frame, no new line at the end
+ *
+ */
+ public void log(String txt) {
+ logPanel.log(txt);
+ }
+ public void setTitle(String txt) {
+ super.setTitle(txt);
+ showTitlePanel(txt);
+ }
+ /**
+ * logs the given txt on the Frame, new line at the end
+ *
+ */
+ public void logln(String txt) {
+ logPanel.logln(txt);
+ }
+ public void goToTop()
+ {
+ logPanel.goToTop();
+ }
+ public void clear() {
+ logPanel.clear();
+ }
+}
diff --git a/src/de/memtext/widgets/LogPanel.java b/src/de/memtext/widgets/LogPanel.java
new file mode 100644
index 0000000..dfdb982
--- /dev/null
+++ b/src/de/memtext/widgets/LogPanel.java
@@ -0,0 +1,48 @@
+package de.memtext.widgets;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.Font;
+
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+
+/**
+ A Panel that can be used to log information onto.
+ */
+public class LogPanel extends JPanel {
+ private JTextArea txtArea = new JTextArea();
+
+ public LogPanel(int maxHeight) {
+ super(new BorderLayout());
+ this.add(new JScrollPane(txtArea), BorderLayout.CENTER);
+ this.setPreferredSize(new Dimension(0, maxHeight));
+ //this.setViewportView(txtArea);
+ }
+ public LogPanel() {
+ this(70);
+ }
+ public void setLogFont(Font f) {
+ txtArea.setFont(f);
+ }
+ /**
+ * no new line added
+ * @param txt
+ */
+ public void log(String txt) {
+ txtArea.append(txt);
+ txtArea.setCaretPosition(txtArea.getText().length());
+ }
+public void goToTop()
+{
+ txtArea.setCaretPosition(0);
+}
+ public void logln(String txt) {
+ log(txt + "\n");
+ }
+ public void clear() {
+ txtArea.setText("");
+ }
+
+}
diff --git a/src/de/memtext/widgets/MBFrame.java b/src/de/memtext/widgets/MBFrame.java
new file mode 100644
index 0000000..495be2c
--- /dev/null
+++ b/src/de/memtext/widgets/MBFrame.java
@@ -0,0 +1,157 @@
+package de.memtext.widgets;
+
+import java.awt.BorderLayout;
+import java.awt.GraphicsConfiguration;
+import java.awt.HeadlessException;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.JToolBar;
+import javax.swing.WindowConstants;
+
+/**
+ * A JFrame with some convience. It is automatically disposed of when
+ * closed. By default also System.exit is called when closing, but this
+ * can be turned off with setHardExitWanted(false).
+ * before exiting the method doBeforeExit is called
+ * Some more convience methods
+ */
+public class MBFrame extends JFrame {
+ private boolean isHardExitWanted = true;
+ private TitlePanel titlePanel;
+
+ public MBFrame() throws HeadlessException {
+ super();
+ init();
+ }
+
+ public MBFrame(GraphicsConfiguration arg0) {
+ super(arg0);
+ init();
+ }
+
+ public MBFrame(String arg0) throws HeadlessException {
+ super(arg0);
+ init();
+ }
+
+ public MBFrame(String arg0, GraphicsConfiguration arg1) {
+ super(arg0, arg1);
+ init();
+ }
+ private void init() {
+ this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+ addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent we) {
+ exit();
+ }
+ });
+ }
+ /**
+ * Called when Frame is closing - default is that System.exit(-1);
+ * is also called, this behaviour can be turned off by setHardExitWanted(false)
+ * DefaultCloseOperation is set to Dispose in init
+ */
+ protected final void exit() {
+ if (isExitOk())
+ {
+ doBeforeExit();
+ this.dispose();
+ if (isHardExitWanted)
+ System.exit(0);
+ }
+ }
+ /**
+ * can be overriden by subclasses to add a user confirm dialog
+ * before truely quitting
+ * @return
+ */
+ protected boolean isExitOk()
+ {
+ return true;
+ }
+ /**
+ * can be overriden by subclasses
+ */
+ protected void doBeforeExit() {
+ }
+
+ /**
+ * Convienence method to set some Component in the center of
+ * the content pane
+ * @param comp
+ */
+ public void setCenter(JComponent comp) {
+ this.getContentPane().add(comp, BorderLayout.CENTER);
+ }
+ /**
+ * Convienence method to set some Component in the north of
+ * the content pane
+ * @param comp
+ */
+ public void setNorth(JComponent comp) {
+ this.getContentPane().add(comp, BorderLayout.NORTH);
+ }
+ /**
+ * Convienence method to set some Component in the south of
+ * the content pane
+ * @param comp
+ */
+ public void setSouth(JComponent comp) {
+ this.getContentPane().add(comp, BorderLayout.SOUTH);
+ }
+ /**
+ * Convienence method to set some Component in the east of
+ * the content pane
+ * @param comp
+ */
+ public void setEast(JComponent comp) {
+ this.getContentPane().add(comp, BorderLayout.EAST);
+ }
+ /**
+ * Convienence method to set some Component in the west of
+ * the content pane
+ * @param comp
+ */
+ public void setWest(JComponent comp) {
+ this.getContentPane().add(comp, BorderLayout.WEST);
+ }
+ /**
+ * Convienence method to set a toolbar in the north of
+ * the content pane
+ * @param comp
+ */
+ protected void setToolBar(JToolBar toolbar) {
+ this.getContentPane().add(toolbar, BorderLayout.NORTH);
+ }
+ /**
+ * Returns the isHardExitWanted.
+ * @return boolean
+ */
+ public boolean isHardExitWanted() {
+ return isHardExitWanted;
+ }
+
+ /**
+ * Sets isHardExitWanted, if true System.exit(-1) is called when
+ * the frame is closed
+ * @param isHardExitWanted
+ */
+ public void setSystemExitOnClose(boolean isHardExitWanted) {
+ this.isHardExitWanted = isHardExitWanted;
+ }
+ /**
+ * a TitlePanel with the given text is installed in the north of
+ * the panel
+ * @param txt
+ */
+ public void showTitlePanel(String txt) {
+ if (titlePanel == null) {
+ titlePanel = new TitlePanel(txt);
+ setNorth(titlePanel);
+ } else
+ titlePanel.setTitleText(txt);
+ }
+}
diff --git a/src/de/memtext/widgets/MBToggleButton.java b/src/de/memtext/widgets/MBToggleButton.java
new file mode 100644
index 0000000..64413da
--- /dev/null
+++ b/src/de/memtext/widgets/MBToggleButton.java
@@ -0,0 +1,266 @@
+package de.memtext.widgets;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.DefaultButtonModel;
+import javax.swing.Icon;
+import javax.swing.JButton;
+
+/**
+ A JButton that can toggle between two action commands, captions and
+ images and toolTipText (variant A and B)
+ */
+public class MBToggleButton extends JButton {
+ private String captionA, captionB, actionCommandA, actionCommandB;
+ private Icon imageA, imageB;
+ private String toolTipTextA, toolTipTextB;
+ private boolean isVariantA;
+ private ActionListener listener;
+ public MBToggleButton() {
+ this(null, null, null, null);
+ }
+
+ public MBToggleButton(String captionA, String captionB) {
+ this(captionA, null, captionB, null);
+
+ }
+ public MBToggleButton(Icon iconA, Icon iconB) {
+ this(null, iconA, null, iconB);
+ }
+ public MBToggleButton(
+ String captionA,
+ Icon iconA,
+ String captionB,
+ Icon iconB) {
+ super();
+ MBToggleButtonModel2 model = new MBToggleButtonModel2();
+ /*listener=new ActionListener()
+ {
+ public void actionPerformed(ActionEvent e)
+ {
+ toggle();
+ }
+ };
+ model.addActionListener(listener);*/
+ super.setModel(model);
+ this.setName("MBToggleBtn"+captionA+"/"+captionB);
+ isVariantA=true;
+ setImageA(iconA);
+ setImageB(iconB);
+ this.captionA = captionA;
+ this.captionB = captionB;
+ setVariantA();
+ }
+ public void toggle() {
+ if (isVariantA)
+ setVariantB();
+ else
+ setVariantA();
+
+ // System.out.println("toggling button");
+
+ }
+ public void setVariantA() {
+ super.setText(captionA);
+ super.setActionCommand(actionCommandA);
+ super.setToolTipText(toolTipTextA);
+ super.setIcon(imageA);
+ isVariantA=true;
+ //System.out.println("variant: "+captionA);
+ }
+ public void setVariantB() {
+ super.setText(captionB);
+ super.setActionCommand(actionCommandB);
+ super.setToolTipText(toolTipTextB);
+ super.setIcon(imageB);
+ isVariantA=false;
+ }
+
+ private void updateCurrentVariant() {
+ if (isVariantA)
+ setVariantA();
+ else
+ setVariantB();
+ }
+ /**
+ * Returns the actionCommandA.
+ * @return String
+ */
+ public String getActionCommandA() {
+ return actionCommandA;
+ }
+
+ /**
+ * Returns the actionCommandB.
+ * @return String
+ */
+ public String getActionCommandB() {
+ return actionCommandB;
+ }
+
+ /**
+ * Returns the captionA.
+ * @return String
+ */
+ public String getCaptionA() {
+ return captionA;
+ }
+
+ /**
+ * Returns the captionB.
+ * @return String
+ */
+ public String getCaptionB() {
+ return captionB;
+ }
+
+ /**
+ * Returns the imageA.
+ * @return ImageIcon
+ */
+ public Icon getImageA() {
+ return imageA;
+ }
+
+ /**
+ * Returns the imageB.
+ * @return ImageIcon
+ */
+ public Icon getImageB() {
+ return imageB;
+ }
+
+ /**
+ * Sets the actionCommandA.
+ * @param actionCommandA The actionCommandA to set
+ */
+ public void setActionCommandA(String actionCommandA) {
+ this.actionCommandA = actionCommandA;
+ updateCurrentVariant();
+ }
+
+ /**
+ * Sets the actionCommandB.
+ * @param actionCommandB The actionCommandB to set
+ */
+ public void setActionCommandB(String actionCommandB) {
+ this.actionCommandB = actionCommandB;
+ updateCurrentVariant();
+ }
+
+ /**
+ * Sets the captionA.
+ * @param captionA The captionA to set
+ */
+ public void setCaptionA(String captionA) {
+ this.captionA = captionA;
+ updateCurrentVariant();
+ }
+
+ /**
+ * Sets the captionB.
+ * @param captionB The captionB to set
+ */
+ public void setCaptionB(String captionB) {
+ this.captionB = captionB;
+ updateCurrentVariant();
+ }
+
+ /**
+ * Sets the imageA.
+ * @param imageA The imageA to set
+ */
+ public void setImageA(Icon imageA) {
+ this.imageA = imageA;
+ updateCurrentVariant();
+ }
+
+ /**
+ * Sets the imageB.
+ * @param imageB The imageB to set
+ */
+ public void setImageB(Icon imageB) {
+ this.imageB = imageB;
+ updateCurrentVariant();
+ }
+ /**
+ * if only one actionCommand is needed, this can be installed
+ * @param actionCommand
+ */
+ public void setSingleActionCommand(String actionCommand) {
+ actionCommandA = actionCommandB = actionCommand;
+ updateCurrentVariant();
+ }
+ /**
+ * use setActionCommandA or setActionCommandB
+ */
+ public void setActionCommand(String ac) {
+ throw new UnsupportedOperationException("overriden to avoid inconsistencies. Use setActionCommandA/B or setSingleActionCommand.");
+
+ }
+ /**
+ * setToolTipTextA or setToolTipTextB
+ */
+ public void setToolTipText(String txt) {
+ throw new UnsupportedOperationException("overriden to avoid inconsistencies. Use setToolTipTextA/B");
+ }
+
+ /**
+ * Returns the toolTipTextA.
+ * @return String
+ */
+ public String getToolTipTextA() {
+ return toolTipTextA;
+ }
+
+ /**
+ * Returns the toolTipTextB.
+ * @return String
+ */
+ public String getToolTipTextB() {
+ return toolTipTextB;
+ }
+
+ /**
+ * Sets the toolTipTextA.
+ * @param toolTipTextA The toolTipTextA to set
+ */
+ public void setToolTipTextA(String toolTipTextA) {
+ this.toolTipTextA = toolTipTextA;
+ if (isVariantA)
+ super.setToolTipText(toolTipTextA);
+ }
+
+ /**
+ * Sets the toolTipTextB.
+ * @param toolTipTextB The toolTipTextB to set
+ */
+ public void setToolTipTextB(String toolTipTextB) {
+ this.toolTipTextB = toolTipTextB;
+ if (!isVariantA)
+ super.setToolTipText(toolTipTextB);
+ }
+ /**
+ * @return true if Variant A is active
+ */
+ public boolean isVariantA() {
+ return isVariantA;
+ }
+
+ /* could enable auto-toggling, but problems when explict setVariantA/B() used
+ */
+ class MBToggleButtonModel2 extends DefaultButtonModel {
+
+ protected void fireActionPerformed(ActionEvent e) {
+ boolean oldVariant = isVariantA();
+ super.fireActionPerformed(e);
+ // if no ActionListener changed the variant setting,
+ // we do the toggling
+ /* if (oldVariant==isVariantA())
+ {toggle();}*/
+
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/memtext/widgets/MultiPanelViewer.java b/src/de/memtext/widgets/MultiPanelViewer.java
new file mode 100644
index 0000000..cec0224
--- /dev/null
+++ b/src/de/memtext/widgets/MultiPanelViewer.java
@@ -0,0 +1,123 @@
+package de.memtext.widgets;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+
+/**
+ * A Panel which shows a ComboBox, in which the concrete panel to be displayed
+ * can be selected.
+ * use addPanel(JPanel p) to add another panel.
+ *
+ */
+public class MultiPanelViewer extends JPanel implements ItemListener {
+ private JComboBox cbPanelSelection;
+ private JLabel lblSelection1 = new JLabel();
+ private boolean isHideSingleSelectionOption = true;
+ private TitlePanel titlePanel = new TitlePanel();
+ private CardLayoutPanel centerp = new CardLayoutPanel();
+ JPanel pSelection = new JPanel();
+
+ public MultiPanelViewer() {
+ this("");
+ }
+ public MultiPanelViewer(String title) {
+ super(new BorderLayout());
+ installNorth();
+ this.add(new JScrollPane(centerp), BorderLayout.CENTER);
+ setTitleText(title);
+ }
+ public Component getSelectedComponent() {
+ return centerp.getSelectedComponent();
+ }
+
+ /**
+ * adds another panel
+ * @param p
+ * @param name - appears in the ComboBox
+ */
+ public void addPanel(JPanel p, String name) {
+ if (name == null)
+ throw new IllegalArgumentException("Panel name must not be null");
+ p.setName(name);
+ addPanel(p);
+
+ }
+ /**
+ * if you want to use this method to add another panel
+ * the panel's name must have been set, to what you would like
+ * to appear in the ComboBox
+ * @param p
+ */
+ public void addPanel(JPanel p) {
+ if (p.getName() == null)
+ throw new IllegalArgumentException("Panel name must not be null");
+ centerp.add(p, p.getName());
+ cbPanelSelection.addItem(p.getName());
+ if (isHideSingleSelectionOption)
+ cbPanelSelection.setVisible(cbPanelSelection.getItemCount() > 1);
+ }
+ public void removePanel(JPanel p) {
+ centerp.remove(p);
+ cbPanelSelection.removeItem(p.getName());
+ if (isHideSingleSelectionOption)
+ cbPanelSelection.setVisible(cbPanelSelection.getItemCount() > 1);
+
+ }
+ public void setTitleText(String txt) {
+ titlePanel.setTitleText(txt);
+
+ }
+ /**
+ * Sets the info text left of the selection comboBox.
+ * @param txt
+ */
+ public void setSelectionText(String txt) {
+ lblSelection1.setText(txt);
+ }
+ /**
+ * adds a component to the Panel in which the combobox is
+ * also found
+ * @param comp
+ */
+ public void addToSelectionP(JComponent comp) {
+ pSelection.add(comp);
+ }
+ /**
+ * * adds a component to the Panel in which the combobox is
+ * also found
+ * @param comp
+ * @param pos - the position at which the addition is to be made
+ */
+ public void addToSelectionP(JComponent comp, int pos) {
+ pSelection.add(comp, pos);
+ }
+
+ private void installNorth() {
+ VerticalBox north = new VerticalBox();
+ north.add(titlePanel);
+ north.add(pSelection);
+ cbPanelSelection = new JComboBox();
+ cbPanelSelection.addItemListener(this);
+ pSelection.add(lblSelection1);
+ pSelection.add(cbPanelSelection);
+
+ this.add(north, BorderLayout.NORTH);
+ }
+
+ public void itemStateChanged(ItemEvent ie) {
+ if (ie.getStateChange() != ItemEvent.SELECTED)
+ return;
+ if (ie.getSource() == cbPanelSelection) {
+
+ centerp.show(ie.getItem().toString());
+ }
+ }
+
+}
diff --git a/src/de/memtext/widgets/MultilineEditPanel.java b/src/de/memtext/widgets/MultilineEditPanel.java
new file mode 100644
index 0000000..2e520c3
--- /dev/null
+++ b/src/de/memtext/widgets/MultilineEditPanel.java
@@ -0,0 +1,57 @@
+package de.memtext.widgets;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+
+/**
+ A Panel which can hold a number of LabeledTextFields one under the other.
+ It makes sure that the Label width is appropriate.
+ See for example LoginDlg
+ */
+public class MultilineEditPanel extends VerticalBox {
+ private LinkedList labeledTextFields = new LinkedList();
+
+ public MultilineEditPanel() {
+ super();
+ }
+ public void add(LabeledTextField lf) {
+ labeledTextFields.add(lf);
+ super.add(lf);
+ updateLabelWidth();
+ }
+ public void remove(LabeledTextField lf) {
+ labeledTextFields.remove(lf);
+ super.remove(lf);
+ updateLabelWidth();
+ }
+ private void updateLabelWidth() {
+ int maxLabelLength = 0;
+ for (Iterator it = labeledTextFields.iterator(); it.hasNext();) {
+ LabeledTextField lf = (LabeledTextField) it.next();
+ if (lf.getPreferredLabelWidth() > maxLabelLength)
+ maxLabelLength = lf.getPreferredLabelWidth();
+ }
+ for (Iterator it = labeledTextFields.iterator(); it.hasNext();) {
+ LabeledTextField lf = (LabeledTextField) it.next();
+ lf.setPreferredLabelWidth(maxLabelLength);
+ }
+
+ }
+ public static void main(String[] args) {
+ JFrame f = new JFrame();
+ MultilineEditPanel mp = new MultilineEditPanel();
+ LabeledTextField longf = new LabeledTextField("Test222Test");
+ mp.add(new LabeledTextField("Test"));
+ mp.add(longf);
+ mp.add(new JLabel("label text hier rein"));
+ mp.add(new LabeledTextField("TestTest"));
+ mp.remove(longf);
+ f.getContentPane().add(mp);
+ f.pack();
+ f.show();
+ }
+
+}
diff --git a/src/de/memtext/widgets/NodeSelectionPanel.java b/src/de/memtext/widgets/NodeSelectionPanel.java
new file mode 100644
index 0000000..5158703
--- /dev/null
+++ b/src/de/memtext/widgets/NodeSelectionPanel.java
@@ -0,0 +1,88 @@
+package de.memtext.widgets;
+
+import java.awt.Dimension;
+import java.awt.Frame;
+import java.awt.event.ActionEvent;
+
+import javax.swing.JTree;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreeCellRenderer;
+import javax.swing.tree.TreeNode;
+
+import de.memtext.dlg.NodeSelectionDlg;
+
+public class NodeSelectionPanel extends LabeledSelectionPanel {
+ private NodeSelectionDlg dlg;
+ private Frame owner;
+ private String infoText;
+ private JTree tree;
+
+ public NodeSelectionPanel(NodeSelectionDlg dlg)
+ {
+ super(dlg.getTitle());
+ this.dlg=dlg;
+ this.setName("nodeSelectionP-"+dlg.getInfoText());
+ setEditable(false);
+ makeTextBoxUnselectable();
+ }
+ public NodeSelectionPanel(Frame owner, String infoText, JTree tree) {
+ super(infoText);
+ this.owner=owner;
+ this.infoText=infoText;
+ this.tree=tree;
+ dlg = new NodeSelectionDlg(owner, infoText, tree);
+ setEditable(false);
+ makeTextBoxUnselectable();
+ this.setName("nodeSelectionP-"+infoText);
+ }
+ public NodeSelectionPanel(
+ Frame owner,
+ String infoText,
+ DefaultTreeModel treeModel) {
+ this(owner, infoText, new JTree(treeModel));
+ }
+ public NodeSelectionPanel(Frame owner, String infoText, TreeNode node) {
+ this(owner, infoText, new JTree(node));
+ }
+ public void setSelectionDlg(NodeSelectionDlg dlg)
+ {
+ this.dlg=dlg;
+ }
+ public void actionPerformed(ActionEvent ae) {
+ dlg.show();
+ if (dlg.wasOkSelected()) //if "clear" was selected also counts as OK
+ {
+ setSelectedObject(dlg.getSelectedNode());
+ setInfoText(getSelectedObject());
+ }
+ }
+ public void setNode(TreeNode node) {
+ dlg.setNode(node);
+ setInfoText("bitte wählen");
+ this.setSelectedObject(null);
+ }
+
+
+ public static void main(String a[]) {
+ MBFrame f = new MBFrame("df");
+ NodeSelectionPanel p =
+ new NodeSelectionPanel(null, "Ab auswählen", new JTree());
+ f.setCenter(p);
+ f.pack();
+ f.show();
+
+ }
+ public void setCellRenderer(TreeCellRenderer renderer)
+ {
+ dlg.setCellRenderer(renderer);
+ }
+ public void setDlgSize(Dimension dim) {
+ dlg.setSize(dim);
+
+ }
+ public void setDlgSize(int x, int y) {
+ dlg.setSize(x,y);
+ }
+}
+
+//Created on 17.11.2003
\ No newline at end of file
diff --git a/src/de/memtext/widgets/NumberOnlyTextArea.java b/src/de/memtext/widgets/NumberOnlyTextArea.java
new file mode 100644
index 0000000..56e1fa0
--- /dev/null
+++ b/src/de/memtext/widgets/NumberOnlyTextArea.java
@@ -0,0 +1,76 @@
+package de.memtext.widgets;
+
+import javax.swing.JTextArea;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.PlainDocument;
+/**
+ * A JTextArea which only accepts numbers
+ */
+public class NumberOnlyTextArea extends JTextArea {
+
+ public NumberOnlyTextArea() {
+ super();
+ }
+
+ public NumberOnlyTextArea(String text) {
+ super(text);
+ }
+
+ public NumberOnlyTextArea(int rows, int columns) {
+ super(rows, columns);
+ }
+
+ public NumberOnlyTextArea(String text, int rows, int columns) {
+ super(text, rows, columns);
+ }
+
+ public NumberOnlyTextArea(Document doc) {
+ super(doc);
+ }
+
+ public NumberOnlyTextArea(
+ Document doc,
+ String text,
+ int rows,
+ int columns) {
+ super(doc, text, rows, columns);
+ }
+ protected Document createDefaultModel() {
+ return new NumberOnlyDocument();
+ }
+ class NumberOnlyDocument extends PlainDocument {
+
+ public void insertString(int offs, String str, AttributeSet a)
+ throws BadLocationException {
+ if (str == null)
+ return;
+ StringBuffer accept = new StringBuffer();
+ for (int i = 0; i < str.length(); i++) {
+ if (str.charAt(i) == '0'
+ || str.charAt(i) == '1'
+ || str.charAt(i) == '2'
+ || str.charAt(i) == '3'
+ || str.charAt(i) == '4'
+ || str.charAt(i) == '5'
+ || str.charAt(i) == '6'
+ || str.charAt(i) == '7'
+ || str.charAt(i) == '8'
+ || str.charAt(i) == '9')
+ accept.append(str.charAt(i));
+ }
+ super.insertString(offs, accept.toString(), a);
+ }
+ }
+ public static void main(String a[]) {
+ MBFrame f = new MBFrame();
+ NumberOnlyTextArea x = new NumberOnlyTextArea();
+ x.setText("12aa356");
+ f.setCenter(x);
+ f.pack();
+ f.show();
+ }
+}
+
+//Created on 19.03.2004 at 09:14:53
\ No newline at end of file
diff --git a/src/de/memtext/widgets/NumberSelectionComboBox.java b/src/de/memtext/widgets/NumberSelectionComboBox.java
new file mode 100644
index 0000000..b064b5f
--- /dev/null
+++ b/src/de/memtext/widgets/NumberSelectionComboBox.java
@@ -0,0 +1,25 @@
+package de.memtext.widgets;
+
+import javax.swing.JComboBox;
+
+public class NumberSelectionComboBox extends JComboBox {
+
+ public NumberSelectionComboBox(
+ double startNumber,
+ double increaseBy,
+ double endNumber) {
+ super();
+ for (double val = startNumber; val <= endNumber; val += increaseBy)
+ this.addItem(new Double(val));
+ }
+ public NumberSelectionComboBox(
+ int startNumber,
+ int increaseBy,
+ int endNumber) {
+ super();
+ for (int val = startNumber; val <= endNumber; val += increaseBy)
+ this.addItem(new Integer(val));
+ }
+}
+
+//Created on 03.01.2004 at 13:34:03
\ No newline at end of file
diff --git a/src/de/memtext/widgets/ObjectCheckBox.java b/src/de/memtext/widgets/ObjectCheckBox.java
new file mode 100644
index 0000000..bb704ae
--- /dev/null
+++ b/src/de/memtext/widgets/ObjectCheckBox.java
@@ -0,0 +1,26 @@
+package de.memtext.widgets;
+
+import javax.swing.JCheckBox;
+/**
+ * A Checkbox that is constructed with an object,
+ * object's toString method used for text
+ * Method getObject can return object
+ */
+public class ObjectCheckBox extends JCheckBox {
+ private Object object;
+ public ObjectCheckBox(Object object, boolean selected) {
+ super(object.toString());
+ this.object = object;
+ this.setSelected(selected);
+ }
+
+ public ObjectCheckBox(Object object) {
+ this(object, false);
+ }
+
+ public Object getObject() {
+ return object;
+ }
+}
+
+//Created on 26.11.2003 at 12:44:15
\ No newline at end of file
diff --git a/src/de/memtext/widgets/OkFrame.java b/src/de/memtext/widgets/OkFrame.java
new file mode 100644
index 0000000..f8233cf
--- /dev/null
+++ b/src/de/memtext/widgets/OkFrame.java
@@ -0,0 +1,57 @@
+package de.memtext.widgets;
+
+import java.awt.Color;
+import java.awt.HeadlessException;
+import java.awt.Window;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+
+import de.memtext.util.HideThread;
+import de.memtext.util.WindowUtils;
+
+/**
+ * A frame which has an OK-Button to close it. Good to have a real frame not
+ * just a dialog if something is to be reported when there is no parent frame
+ * available, e.g. during startup time
+ */
+public class OkFrame extends MBFrame {
+private UneditableTextArea txtArea=new UneditableTextArea(8,40);
+ public OkFrame(String title,boolean isTextAreaWanted) throws HeadlessException {
+ super(title);
+ setSystemExitOnClose(false);
+ JButton ok = new JButton("OK");
+ ok.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ exit();
+ }
+ });
+ JPanel p = new JPanel();
+ p.add(ok);
+ this.setSouth(p);
+ if (isTextAreaWanted)
+ setCenter(new JScrollPane(txtArea));
+ getRootPane().setDefaultButton(ok);
+ this.pack();
+ WindowUtils.center(this);
+
+ }
+ public void setTextBackground(Color c)
+ {
+ txtArea.setBackground(c);
+ }
+public void disappearAfter(int secs)
+{
+ new HideThread(this,secs).start();
+}
+ public void setText(String text)
+{
+ txtArea.setText(text);
+}
+
+}
+
+//Created on 07.09.2004 at 10:16:04
diff --git a/src/de/memtext/widgets/PrintableEditorPane.java b/src/de/memtext/widgets/PrintableEditorPane.java
new file mode 100644
index 0000000..ffb7d45
--- /dev/null
+++ b/src/de/memtext/widgets/PrintableEditorPane.java
@@ -0,0 +1,52 @@
+package de.memtext.widgets;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.print.*;
+import java.io.Serializable;
+
+import javax.swing.JEditorPane;
+import javax.swing.RepaintManager;
+
+public class PrintableEditorPane extends JEditorPane implements Printable,
+ Serializable {
+ public PrintableEditorPane() {
+ super();
+ }
+ public PrintableEditorPane(String type, String text) {
+ super(type,text);
+ }
+
+ public int print(Graphics g, PageFormat pf, int pageIndex)
+ throws PrinterException {
+ Graphics2D g2 = (Graphics2D) g;
+ g2.setColor(Color.black);
+
+ RepaintManager.currentManager(this).setDoubleBufferingEnabled(false);
+ Dimension d = this.getSize();
+ double panelWidth = d.width;
+ double panelHeight = d.height;
+ double pageWidth = pf.getImageableWidth();
+ double pageHeight = pf.getImageableHeight();
+ double scale = 1;
+ if (panelWidth>pageWidth)
+ scale=pageWidth / panelWidth;
+ int totalNumPages = (int) Math.ceil(scale * panelHeight / pageHeight);
+
+ // Check for empty pages
+ if (pageIndex >= totalNumPages)
+ return Printable.NO_SUCH_PAGE;
+
+ g2.translate(pf.getImageableX(), pf.getImageableY());
+ g2.translate(0f, -pageIndex * pageHeight);
+
+ g2.scale(scale, scale);
+ this.paint(g2);
+
+ return Printable.PAGE_EXISTS;
+ }
+}
+
+//Created on 13.04.2005 at 11:28:36
diff --git a/src/de/memtext/widgets/RadioButtonGroup.java b/src/de/memtext/widgets/RadioButtonGroup.java
new file mode 100644
index 0000000..05731e1
--- /dev/null
+++ b/src/de/memtext/widgets/RadioButtonGroup.java
@@ -0,0 +1,54 @@
+package de.memtext.widgets;
+
+import java.awt.event.ActionListener;
+import java.util.Enumeration;
+import java.util.Iterator;
+
+import javax.swing.ButtonGroup;
+import javax.swing.ButtonModel;
+import javax.swing.JPanel;
+import javax.swing.JRadioButton;
+
+public class RadioButtonGroup extends JPanel {
+ private ActionListener al;
+ private ButtonGroup group = new ButtonGroup();
+ public RadioButtonGroup(ActionListener al) {
+ this.al=al;
+
+ }
+
+ public RadioButtonGroup() {
+ }
+
+ public void add(String buttonName) {
+ add(buttonName, false);
+ }
+ public void add(String buttonName, boolean selected) {
+ JRadioButton but = new JRadioButton(buttonName, selected);
+ but.addActionListener(al);
+ group.add(but);
+ this.add(but);
+ }
+ public String getSelectedName()
+ {
+ String result=null;
+ for (Enumeration en=group.getElements();en.hasMoreElements();)
+ {
+ JRadioButton rb=(JRadioButton)en.nextElement();
+ if (rb.isSelected())
+ result=rb.getActionCommand();
+ }
+ return result;
+ }
+ public void setSelection(String name)
+ {
+ for (Enumeration en=group.getElements();en.hasMoreElements();)
+ {
+ JRadioButton rb=(JRadioButton)en.nextElement();
+ if (rb.getActionCommand().equals(name))
+ rb.setSelected(true);
+ }
+ }
+}
+
+//Created on 23.03.2004 at 13:24:24
\ No newline at end of file
diff --git a/src/de/memtext/widgets/ScrollableTextArea.java b/src/de/memtext/widgets/ScrollableTextArea.java
new file mode 100644
index 0000000..99c8603
--- /dev/null
+++ b/src/de/memtext/widgets/ScrollableTextArea.java
@@ -0,0 +1,57 @@
+package de.memtext.widgets;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+
+/**
+A scrollable TextArea
+ */
+public class ScrollableTextArea extends JPanel {
+ private JTextArea txtArea = new JTextArea();
+ private boolean goToTextBeginning = true;
+ public ScrollableTextArea(int maxHeight) {
+ super(new BorderLayout());
+ this.add(new JScrollPane(txtArea), BorderLayout.CENTER);
+ this.setPreferredSize(new Dimension(0, maxHeight));
+
+ }
+ public ScrollableTextArea() {
+ this(70);
+
+ }
+
+ public void setColumns(int cols)
+ {
+ txtArea.setColumns(cols);
+ }
+ public void setText(String txt) {
+ txtArea.setText(txt);
+ if (goToTextBeginning)
+ txtArea.setCaretPosition(0);
+ }
+ public void append(String txt) {
+ txtArea.append(txt);
+ }
+ public void setBackground(Color c) {
+ super.setBackground(c);
+ if (txtArea != null)
+ txtArea.setBackground(c);
+ }
+ public void setEditable(boolean b) {
+ txtArea.setEditable(b);
+ }
+ public void setLineWrap(boolean b) {
+ txtArea.setLineWrap(b);
+ }
+ public void setWrapStyleWord(boolean b) {
+ txtArea.setWrapStyleWord(b);
+ }
+ public String getText() {
+ return txtArea.getText();
+ }
+}
diff --git a/src/de/memtext/widgets/SplashScreen.java b/src/de/memtext/widgets/SplashScreen.java
new file mode 100644
index 0000000..7e1a7b5
--- /dev/null
+++ b/src/de/memtext/widgets/SplashScreen.java
@@ -0,0 +1,230 @@
+package de.memtext.widgets;
+
+import java.awt.Font;
+
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JProgressBar;
+import javax.swing.JWindow;
+
+import de.memtext.util.FontUtils;
+import de.memtext.util.PlafUtils;
+import de.memtext.util.WindowUtils;
+/**
+ * This type was generated by a SmartGuide.
+ * Thanks to IBM Visual Age for Java
+ */
+public class SplashScreen extends JWindow {
+ private String graphicFile;
+ private JProgressBar progressBar;
+ private JLabel lbl1;
+
+ class IvjEventHandler implements java.awt.event.WindowListener {
+ public void windowActivated(java.awt.event.WindowEvent e) {
+ };
+ public void windowClosed(java.awt.event.WindowEvent e) {
+ };
+ public void windowClosing(java.awt.event.WindowEvent e) {
+ if (e.getSource() == SplashScreen.this)
+ connEtoC1(e);
+ };
+ public void windowDeactivated(java.awt.event.WindowEvent e) {
+ };
+ public void windowDeiconified(java.awt.event.WindowEvent e) {
+ };
+ public void windowIconified(java.awt.event.WindowEvent e) {
+ };
+ public void windowOpened(java.awt.event.WindowEvent e) {
+ };
+ };
+ IvjEventHandler ivjEventHandler = new IvjEventHandler();
+ private JLabel ivjJLabel1 = null;
+ private JPanel ivjJWindowContentPane = null;
+ /**
+ * SplashScreen constructor comment.
+ */
+ public SplashScreen(String graphicFile) {
+ super();
+ this.graphicFile = graphicFile;
+ WindowUtils.setWaitCursor(this, true);
+ PlafUtils.setWindowsLook(this);
+ initialize();
+ }
+ /**
+ * SplashScreen constructor comment.
+ * @param owner java.awt.Frame
+ */
+ /* SplashScreen(Frame owner) {
+ super(owner);
+ }*/
+ /**
+ * SplashScreen constructor comment.
+ * @param owner java.awt.Window
+ */
+ /* SplashScreen(Window owner) {
+ super(owner);
+ }*/
+ /**
+ * connEtoC1: (SplashScreen.window.windowClosing(java.awt.event.WindowEvent) --> SplashScreen.dispose()V)
+ * @param arg1 java.awt.event.WindowEvent
+ */
+ /* WARNING: THIS METHOD WILL BE REGENERATED. */
+ private void connEtoC1(java.awt.event.WindowEvent arg1) {
+ try {
+ // user code begin {1}
+ // user code end
+ this.dispose();
+ // user code begin {2}
+ // user code end
+ } catch (java.lang.Throwable ivjExc) {
+ // user code begin {3}
+ // user code end
+ handleException(ivjExc);
+ }
+ }
+ /**
+ * Return the JLabel1 property value.
+ * @return javax.swing.JLabel
+ */
+ /* WARNING: THIS METHOD WILL BE REGENERATED. */
+ private javax.swing.JLabel getJLabel1() {
+ if (ivjJLabel1 == null) {
+ try {
+ ivjJLabel1 = new javax.swing.JLabel();
+ ivjJLabel1.setName("JLabel1");
+ ivjJLabel1.setIcon(
+ new javax.swing.ImageIcon(
+ getClass().getClassLoader().getResource(graphicFile)));
+ ivjJLabel1.setText("");
+ // user code begin {1}
+ // user code end
+ } catch (java.lang.Throwable ivjExc) {
+ // user code begin {2}
+ // user code end
+ handleException(ivjExc);
+ }
+ }
+ return ivjJLabel1;
+ }
+ /**
+ * Return the JWindowContentPane property value.
+ * @return javax.swing.JPanel
+ */
+ /* WARNING: THIS METHOD WILL BE REGENERATED. */
+ private javax.swing.JPanel getJWindowContentPane() {
+ if (ivjJWindowContentPane == null) {
+ try {
+ ivjJWindowContentPane = new javax.swing.JPanel();
+ ivjJWindowContentPane.setName("JWindowContentPane");
+ ivjJWindowContentPane.setBorder(
+ new javax.swing.border.EtchedBorder());
+ ivjJWindowContentPane.setLayout(new java.awt.BorderLayout());
+ getJWindowContentPane().add(getJLabel1(), "Center");
+ // user code begin {1}
+ VerticalBox vbox = new VerticalBox();
+ lbl1 = new JLabel();
+ lbl1.setVisible(false);
+
+ vbox.addWithCenterAlignment(lbl1);
+ progressBar = new JProgressBar();
+ progressBar.setIndeterminate(true);
+ progressBar.setVisible(false);
+ vbox.add(progressBar);
+ getJWindowContentPane().add(vbox, "South");
+ // user code end
+ } catch (java.lang.Throwable ivjExc) {
+ // user code begin {2}
+ // user code end
+ handleException(ivjExc);
+ }
+ }
+ return ivjJWindowContentPane;
+ }
+ /**
+ * Called whenever the part throws an exception.
+ * @param exception java.lang.Throwable
+ */
+ private void handleException(java.lang.Throwable exception) {
+
+ /* Uncomment the following lines to print uncaught exceptions to stdout */
+ // System.out.println("--------- UNCAUGHT EXCEPTION ---------");
+ // exception.printStackTrace(System.out);
+ }
+ /**
+ * Initializes connections
+ * @exception java.lang.Exception The exception description.
+ */
+ /* WARNING: THIS METHOD WILL BE REGENERATED. */
+ private void initConnections() throws java.lang.Exception {
+ // user code begin {1}
+ // user code end
+ this.addWindowListener(ivjEventHandler);
+ }
+ /**
+ * Initialize the class.
+ */
+ /* WARNING: THIS METHOD WILL BE REGENERATED. */
+ private void initialize() {
+ try {
+ // user code begin {1}
+
+ // user code end
+ setName("SplashScreen");
+ setContentPane(getJWindowContentPane());
+ initConnections();
+ } catch (java.lang.Throwable ivjExc) {
+ handleException(ivjExc);
+ }
+ // user code begin {2}
+ this.pack();
+ WindowUtils.center(this);
+ // user code end
+ }
+ /**
+ * main entrypoint - starts the part when it is run as an application
+ * @param args java.lang.String[]
+ */
+ public static void main(java.lang.String[] args) {
+ try {
+ SplashScreen aSplashScreen;
+ aSplashScreen = new SplashScreen("");
+ aSplashScreen
+ .addWindowListener(new java.awt.event.WindowAdapter() {
+ public void windowClosing(java.awt.event.WindowEvent e) {
+ System.exit(0);
+ };
+ });
+ aSplashScreen.show();
+ java.awt.Insets insets = aSplashScreen.getInsets();
+ aSplashScreen.setSize(
+ aSplashScreen.getWidth() + insets.left + insets.right,
+ aSplashScreen.getHeight() + insets.top + insets.bottom);
+ aSplashScreen.setVisible(true);
+ } catch (Throwable exception) {
+ System.err.println(
+ "Exception occurred in main() of javax.swing.JWindow");
+ exception.printStackTrace(System.out);
+ }
+ }
+
+ public void setLblText(String txt) {
+ lbl1.setVisible(true);
+ lbl1.setFont(new Font("SansSerif",Font.BOLD,13));
+ lbl1.setText(txt);
+ }
+ public void setProgressBarVisible(boolean visible)
+ {
+ progressBar.setVisible(visible);
+ }
+ public void setProgressBarIndeterminate(boolean indeterminate)
+ {
+ progressBar.setIndeterminate(indeterminate);
+ }
+ public void setProgressBarText(String txt) {
+ progressBar.setStringPainted(true);
+ progressBar.setString(txt);
+
+ }
+}
+
+//Created on 27.02.2004 at 21:30:27
\ No newline at end of file
diff --git a/src/de/memtext/widgets/StandBox.java b/src/de/memtext/widgets/StandBox.java
new file mode 100644
index 0000000..e207408
--- /dev/null
+++ b/src/de/memtext/widgets/StandBox.java
@@ -0,0 +1,68 @@
+package de.memtext.widgets;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Date;
+
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+
+import de.memtext.util.DateUtils;
+/**
+ * Ein StandLabel Panel, das auch Standänderungen übernehmen kann.
+ * Es muss performStandChange implementiert werden
+ */
+public abstract class StandBox extends VerticalBox {
+ protected JLabel lblStand = new JLabel();
+ protected JButton btnStand;
+ private boolean isStandChanged;
+ protected StandBox() {
+
+ this.addWithCenterAlignment(lblStand);
+ btnStand = new JButton("Stand ändern");
+ btnStand.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ String neuerStand = JOptionPane.showInputDialog(lblStand,
+ "Neues Datum eingeben:", "Stand ändern",
+ JOptionPane.QUESTION_MESSAGE);
+ if (neuerStand == null)
+ return;
+ if (!DateUtils.isValidDateStrict(neuerStand)) {
+ WarningMessage.show(lblStand, neuerStand
+ + " ist kein gültiges Datum\nBitte im Format tt.mm.jjjj eingeben", "Standänderung");
+
+ } else
+ try {
+ performStandChange(neuerStand);
+ lblStand.setText(neuerStand);
+ } catch (Exception e) {
+ WarningMessage.show(lblStand,
+ "Standänderung fehlgeschlagen.\n"
+ + e.toString(), "Standänderung");
+ }
+ }
+ });
+ this.addWithCenterAlignment(btnStand);
+
+ }
+
+ public void setStandLblText(Date stand) {
+ lblStand.setText("Stand: "+DateUtils.format(stand));
+ }
+
+ protected abstract void performStandChange(String neuerStand)
+ throws Exception;
+
+
+ public boolean isStandChanged() {
+ return isStandChanged;
+ }
+
+ public void setStandChanged(boolean isStandChanged) {
+ this.isStandChanged = isStandChanged;
+ }
+}
+
+//Created on 31.05.2005 at 18:29:44
diff --git a/src/de/memtext/widgets/StatusContainer.java b/src/de/memtext/widgets/StatusContainer.java
new file mode 100644
index 0000000..87cf0bd
--- /dev/null
+++ b/src/de/memtext/widgets/StatusContainer.java
@@ -0,0 +1,40 @@
+package de.memtext.widgets;
+
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Font;
+
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+/**
+ in progress
+ */
+public class StatusContainer extends Container {
+private Font statusFont=new Font("SansSerif",Font.PLAIN,12);
+private JLabel lblStatus;
+
+ public StatusContainer(Container cont,String status) {
+ super();
+ setLayout(new BorderLayout());
+ JPanel statusp=new JPanel();
+ JLabel lblStatus=new JLabel(status);
+ lblStatus.setFont(statusFont);
+ statusp.add(lblStatus);
+ this.add(statusp,BorderLayout.NORTH);
+ this.add(cont,BorderLayout.CENTER);
+ }
+public StatusContainer(Container cont)
+{
+ this(cont,"");
+}
+public void setStatusText(String status)
+{
+ lblStatus.setText(status);
+}
+public void setStatusFont(Font f)
+{
+ lblStatus.setFont(f);
+}
+
+}
diff --git a/src/de/memtext/widgets/TextUnselectableDec.java b/src/de/memtext/widgets/TextUnselectableDec.java
new file mode 100644
index 0000000..4312af9
--- /dev/null
+++ b/src/de/memtext/widgets/TextUnselectableDec.java
@@ -0,0 +1,57 @@
+package de.memtext.widgets;
+
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.text.JTextComponent;
+
+/**
+ * A decorator that makes text unselectable
+ * klappt noch nicht!
+ */
+public class TextUnselectableDec {
+ private IgnoringMouseAdapter mouseList;
+ private NoMoveKeyAdapter keyList = new NoMoveKeyAdapter();
+ public TextUnselectableDec(){
+ }
+
+ public void makeUnselectable(JTextComponent textComp) {
+ textComp.addKeyListener(keyList);
+ mouseList = new IgnoringMouseAdapter(textComp);
+ textComp.addMouseListener(mouseList);
+ }
+
+ private class NoMoveKeyAdapter extends KeyAdapter {
+ NoMoveKeyAdapter() {
+ }
+
+ public void keyPressed(KeyEvent evt) {
+ int key = evt.getKeyCode();
+ switch (key) {
+ case KeyEvent.VK_LEFT :
+ case KeyEvent.VK_RIGHT :
+ case KeyEvent.VK_UP :
+ case KeyEvent.VK_DOWN :
+ if (evt.isShiftDown())
+ evt.consume();
+ break;
+ }
+ }
+ }
+
+ private class IgnoringMouseAdapter extends MouseAdapter {
+ JTextComponent textComp;
+ IgnoringMouseAdapter(JTextComponent textComp) {
+ this.textComp=textComp;
+ }
+
+ public void mousePressed(MouseEvent evt) {
+ evt.consume();
+ textComp.setCaretPosition(0);
+ }
+ }
+}
+
+//Created on 17.11.2003
\ No newline at end of file
diff --git a/src/de/memtext/widgets/TitlePanel.java b/src/de/memtext/widgets/TitlePanel.java
new file mode 100644
index 0000000..63c6e6e
--- /dev/null
+++ b/src/de/memtext/widgets/TitlePanel.java
@@ -0,0 +1,47 @@
+package de.memtext.widgets;
+
+import java.awt.BorderLayout;
+import java.awt.Font;
+
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+/**
+A Title Panel.
+More components can be added to appear under the Title, by using
+the add method
+ */
+public class TitlePanel extends VerticalBox {
+ private Font titleFont = new Font("SansSerif", Font.BOLD, 16);
+ private JLabel lblTitle;
+
+ public TitlePanel() {
+ this("");
+ }
+
+ public TitlePanel(String title) {
+ super();
+ JPanel ptitle = new JPanel();
+ lblTitle = new JLabel(title);
+ lblTitle.setFont(titleFont);
+ ptitle.add(lblTitle);
+ add(ptitle);
+
+ }
+ public void setTitleText(String title) {
+ lblTitle.setText(title);
+ }
+ public void setTitleFont(Font f) {
+ lblTitle.setFont(f);
+ }
+ public void add(JComponent comp) {
+ if (comp instanceof JPanel)
+ super.add(comp);
+ else {
+ JPanel p = new JPanel(new BorderLayout());
+ p.add(comp, BorderLayout.CENTER);
+ super.add(p);
+ }
+ }
+}
diff --git a/src/de/memtext/widgets/TitledContainerDec.java b/src/de/memtext/widgets/TitledContainerDec.java
new file mode 100644
index 0000000..1d9daa2
--- /dev/null
+++ b/src/de/memtext/widgets/TitledContainerDec.java
@@ -0,0 +1,51 @@
+package de.memtext.widgets;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Font;
+
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+/**
+ A title decorator. Any container (including JPanel) can get
+ this decorator so that a title appears over the container.
+ For an example see TitledTextScrollArea
+ */
+public class TitledContainerDec extends Container {
+ private Font titleFont = new Font("SansSerif", Font.BOLD, 16);
+ private JLabel lblTitle = new JLabel();
+ JPanel titlep = new JPanel();
+ /**
+ *
+ * @param cont - a Container which is to get a title
+ * @param title - title text
+ */
+ public TitledContainerDec(Container cont, String title) {
+ super();
+ setLayout(new BorderLayout());
+ lblTitle.setText(title);
+ lblTitle.setFont(titleFont);
+ titlep.add(lblTitle);
+ this.add(titlep, BorderLayout.NORTH);
+ this.add(cont, BorderLayout.CENTER);
+ }
+ public TitledContainerDec(Container cont) {
+ this(cont, "");
+ }
+ public void setTitleText(String title) {
+ lblTitle.setText(title);
+ }
+ public void setBackground(Color c) {
+ super.setBackground(c);
+ }
+ public void setTitleBackground(Color c) {
+ if (titlep != null)
+ titlep.setBackground(c);
+ }
+ public void setTitleFont(Font f) {
+ lblTitle.setFont(f);
+ }
+
+}
diff --git a/src/de/memtext/widgets/TitledTextScrollArea.java b/src/de/memtext/widgets/TitledTextScrollArea.java
new file mode 100644
index 0000000..8feafda
--- /dev/null
+++ b/src/de/memtext/widgets/TitledTextScrollArea.java
@@ -0,0 +1,72 @@
+package de.memtext.widgets;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Font;
+
+import javax.swing.JPanel;
+
+/**
+ A Scrollable Textarea which has a title at the top.
+
+ */
+public class TitledTextScrollArea extends JPanel {
+
+ private TitledContainerDec titleCont;
+ private ScrollableTextArea scrollableTextArea;
+
+ public TitledTextScrollArea(String title) {
+ this(title, 70);
+ }
+ public TitledTextScrollArea(String title, int maxHeight) {
+ super(new BorderLayout());
+ scrollableTextArea = new ScrollableTextArea(maxHeight);
+ titleCont = new TitledContainerDec(scrollableTextArea, title);
+ this.add(titleCont, BorderLayout.CENTER);
+ scrollableTextArea.setEditable(true);
+ scrollableTextArea.setLineWrap(true);
+ scrollableTextArea.setWrapStyleWord(true);
+ }
+
+ /**
+ * @param f
+ */
+ public void setTitleFont(Font f) {
+ titleCont.setTitleFont(f);
+ }
+
+ /**
+ * @param title
+ */
+ public void setTitleText(String title) {
+ titleCont.setTitleText(title);
+ }
+
+ /**
+ * @param txt
+ */
+ public void setText(String txt) {
+ scrollableTextArea.setText(txt);
+ }
+ public String getText() {
+ return scrollableTextArea.getText();
+ }
+ public void setTitleBackground(Color c) {
+ if (titleCont != null)
+ titleCont.setTitleBackground(c);
+ }
+ public void setBackground(Color c) {
+ super.setBackground(c);
+ if (scrollableTextArea != null)
+ scrollableTextArea.setBackground(c);
+ if (titleCont != null)
+ titleCont.setBackground(c);
+ }
+ public void setEditable(boolean b) {
+ scrollableTextArea.setEditable(b);
+
+ }
+ public void setColumns(int cols) {
+ scrollableTextArea.setColumns(cols);
+ }
+}
diff --git a/src/de/memtext/widgets/UnchangeableTextViewer.java b/src/de/memtext/widgets/UnchangeableTextViewer.java
new file mode 100644
index 0000000..f523b13
--- /dev/null
+++ b/src/de/memtext/widgets/UnchangeableTextViewer.java
@@ -0,0 +1,37 @@
+package de.memtext.widgets;
+
+import java.awt.Frame;
+
+import javax.swing.JScrollPane;
+
+import de.memtext.dlg.OkDlg;
+
+/**
+ * Shows a text in an uneditable textarea in Dialog that can only be closed by
+ * clicking OK
+ */
+public class UnchangeableTextViewer extends OkDlg {
+
+ private UneditableTextArea ta;
+
+ /**
+ * Constructor for LicenceViewer.
+ */
+ public UnchangeableTextViewer(Frame owner, String title, String txt) {
+ super(owner, title);
+ ta = new UneditableTextArea(20, 50);
+ ta.setText(txt);
+ ta.setCaretPosition(0);
+ setCenter(new JScrollPane(ta));
+ this.pack();
+ de.memtext.util.WindowUtils.center(this);
+ }
+
+ protected void performOK() {
+ this.hide();
+ }
+
+ public void setText(String txt) {
+ ta.setText(txt);
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/widgets/UneditableTextArea.java b/src/de/memtext/widgets/UneditableTextArea.java
new file mode 100644
index 0000000..7af3d05
--- /dev/null
+++ b/src/de/memtext/widgets/UneditableTextArea.java
@@ -0,0 +1,50 @@
+package de.memtext.widgets;
+
+import javax.swing.JTextArea;
+import javax.swing.text.Document;
+
+/**
+ A JTextArea in which the text is uneditable and word wrapping
+ is active
+ */
+public class UneditableTextArea extends JTextArea {
+
+
+ public UneditableTextArea() {
+ super();
+ initUneditableTextArea();
+ }
+
+ public UneditableTextArea(String arg0) {
+ super(arg0);
+ initUneditableTextArea();
+ }
+
+ public UneditableTextArea(int arg0, int arg1) {
+ super(arg0, arg1);
+ initUneditableTextArea();
+ }
+
+
+ public UneditableTextArea(String arg0, int arg1, int arg2) {
+ super(arg0, arg1, arg2);
+ initUneditableTextArea();
+ }
+
+
+ public UneditableTextArea(Document arg0) {
+ super(arg0);
+ initUneditableTextArea();
+ }
+
+ public UneditableTextArea(Document arg0, String arg1, int arg2, int arg3) {
+ super(arg0, arg1, arg2, arg3);
+ initUneditableTextArea();
+ }
+ private void initUneditableTextArea() {
+ setEditable(false);
+ setLineWrap(true);
+ setWrapStyleWord(true);
+
+ }
+}
diff --git a/src/de/memtext/widgets/UnicodeReplacerDocument.java b/src/de/memtext/widgets/UnicodeReplacerDocument.java
new file mode 100644
index 0000000..f9e392f
--- /dev/null
+++ b/src/de/memtext/widgets/UnicodeReplacerDocument.java
@@ -0,0 +1,86 @@
+package de.memtext.widgets;
+
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.PlainDocument;
+/**
+ * A javax.swing.text.Document which replaces char combinations like
+ cx,sx etc with single character unicode chars
+ *
+ */
+public class UnicodeReplacerDocument extends PlainDocument {
+ private boolean yDisabled=true;
+ public static final char C_ROOF = '\u0109',
+ C_CAP_ROOF = '\u0108',
+ G_ROOF = '\u011d',
+ G_CAP_ROOF = '\u011c';
+ public static final char H_ROOF = '\u0125',
+ H_CAP_ROOF = '\u0124',
+ J_ROOF = '\u0135',
+ J_CAP_ROOF = '\u0134';
+ public static final char S_ROOF = '\u015d',
+ S_CAP_ROOF = '\u015c',
+ U_ARC = '\u016d',
+ U_CAP_ARC = '\u016c';
+ public void insertString(int offs, String string, AttributeSet a)
+ throws BadLocationException {
+ //System.out.println("correction");
+ if (string == null) {
+ return;
+ }
+ char newChar = 0;
+ if (string.equals("y")||string.equals("Y"))
+ {
+ WarningMessage.show(null,"En Esperanto ni ne havas y","");
+ return;
+ }
+ boolean isRemoveNecessary = false;
+ if (offs > 0 && string.equals("x")) {
+ if (getText(offs - 1, 1).equals("c")) {
+ newChar = C_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("C")) {
+ newChar = C_CAP_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("g")) {
+ newChar = G_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("G")) {
+ newChar = G_CAP_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("j")) {
+ newChar = J_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("J")) {
+ newChar = J_CAP_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("s")) {
+ newChar = S_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("S")) {
+ newChar = S_CAP_ROOF;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("u")) {
+ newChar = U_ARC;
+ isRemoveNecessary = true;
+ }
+ if (getText(offs - 1, 1).equals("U")) {
+ newChar = U_CAP_ARC;
+ isRemoveNecessary = true;
+ }
+ }
+ if (isRemoveNecessary) {
+ remove(--offs, 1);
+ string = newChar + "";
+ }
+ super.insertString(offs, string, a);
+ }
+}
\ No newline at end of file
diff --git a/src/de/memtext/widgets/UnicodeReplacerTextField.java b/src/de/memtext/widgets/UnicodeReplacerTextField.java
new file mode 100644
index 0000000..08740b9
--- /dev/null
+++ b/src/de/memtext/widgets/UnicodeReplacerTextField.java
@@ -0,0 +1,60 @@
+package de.memtext.widgets;
+
+import javax.swing.JTextField;
+import javax.swing.text.Document;
+
+/**
+ A JTextField in which char combinations like c^ and s^ are replaced
+ by unicode chars
+ */
+public class UnicodeReplacerTextField extends JTextField {
+
+ /**
+ * Constructor for UnicodeReplacerTextField.
+ */
+ public UnicodeReplacerTextField() {
+ super();
+ }
+
+ /**
+ * Constructor for UnicodeReplacerTextField.
+ * @param arg0
+ */
+ public UnicodeReplacerTextField(String arg0) {
+ super(arg0);
+ }
+
+ /**
+ * Constructor for UnicodeReplacerTextField.
+ * @param arg0
+ */
+ public UnicodeReplacerTextField(int arg0) {
+ super(arg0);
+ }
+
+ /**
+ * Constructor for UnicodeReplacerTextField.
+ * @param arg0
+ * @param arg1
+ */
+ public UnicodeReplacerTextField(String arg0, int arg1) {
+ super(arg0, arg1);
+ }
+
+ /**
+ * Constructor for UnicodeReplacerTextField.
+ * @param arg0
+ * @param arg1
+ * @param arg2
+ */
+ public UnicodeReplacerTextField(Document arg0, String arg1, int arg2) {
+ super(arg0, arg1, arg2);
+ }
+
+ protected Document createDefaultModel() {
+ return new UnicodeReplacerDocument();
+ }
+
+
+
+}
diff --git a/src/de/memtext/widgets/VerticalBox.java b/src/de/memtext/widgets/VerticalBox.java
new file mode 100644
index 0000000..c3aebe8
--- /dev/null
+++ b/src/de/memtext/widgets/VerticalBox.java
@@ -0,0 +1,84 @@
+package de.memtext.widgets;
+
+import java.awt.Component;
+import java.awt.FlowLayout;
+
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+/**
+ * A Vertical Box - just add one Component after the other,
+ * one displayed under the former.
+ * Much better than GridLayout(0,x) because GridLayout forces
+ * all Componets to have the same size whereas the box respects
+ * preferred size
+ * a vertical box inside another vertical box is OK
+ * see javax.swing.Box
+ */
+public class VerticalBox extends Box {
+ public VerticalBox() {
+ super(BoxLayout.Y_AXIS);
+ this.setBackground(null);
+ }
+ public void addGlue() {
+ JComponent filler=(JComponent) Box.createVerticalGlue();
+
+ this.add(filler);
+ filler.setBackground(java.awt.Color.red);
+ }
+ public void addStrut(int height) {
+ this.add(Box.createVerticalStrut(height));
+
+ }
+
+ public void addWithLeftAlignment(JComponent comp) {
+ JPanel p = new JPanel(new FlowLayout(FlowLayout.LEFT));
+ p.setBackground(comp.getBackground());
+ p.add(comp);
+ this.add(p);
+ }
+ public void addWithCenterAlignment(JComponent comp) {
+ JPanel p = new JPanel(new FlowLayout(FlowLayout.CENTER));
+ p.setBackground(comp.getBackground());
+ p.add(comp);
+ this.add(p);
+ }
+ public void addWithCenterAlignment(JComponent comp, int pos) {
+ JPanel p = new JPanel(new FlowLayout(FlowLayout.CENTER));
+ p.setBackground(comp.getBackground());
+ p.add(comp);
+ this.add(p,pos);
+ }
+ public void addWithRightAlignment(Component comp) {
+ JPanel p = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+ p.add(comp);
+ p.setBackground(comp.getBackground());
+ this.add(p);
+ }
+ public static void main(String a[]) {
+ MBFrame f = new MBFrame();
+ VerticalBox vb1 = new VerticalBox();
+ vb1.add(new JLabel("1"));
+ VerticalBox vb2 = new VerticalBox();
+ vb2.add(new JLabel("2a"));
+ vb2.add(new JLabel("2b"));
+ vb1.add(vb2);
+ f.setCenter(vb1);
+ f.pack();
+ f.show();
+
+ }
+ public void setEnabled(boolean b) {
+ Component comp;
+ for (int i = 0; i < this.getComponents().length; i++) {
+ comp = this.getComponent(i);
+ comp.setEnabled(b);
+ }
+ }
+
+
+
+}
diff --git a/src/de/memtext/widgets/WarningMessage.java b/src/de/memtext/widgets/WarningMessage.java
new file mode 100644
index 0000000..bf42168
--- /dev/null
+++ b/src/de/memtext/widgets/WarningMessage.java
@@ -0,0 +1,73 @@
+package de.memtext.widgets;
+
+import java.awt.Component;
+
+import javax.swing.JOptionPane;
+
+/**
+ A warning message that can be displayed by calling show()
+ convenience for the JoptionPane method
+ either create an object for reuse or use static method
+ show(msg,title)
+ */
+public class WarningMessage {
+ private String msg, title;
+private Component parent;
+ public WarningMessage(Component parent, String msg, String title) {
+ this.msg = msg;
+ this.title = title;
+ }
+ public WarningMessage(Component parent,String msg) {
+ this(parent, msg, "");
+ }
+ public static void show(Component parent,String msg, String title)
+ {
+ JOptionPane.showMessageDialog(
+ parent,
+ msg,
+ title,
+ JOptionPane.WARNING_MESSAGE);
+ }
+ public void show() {
+ JOptionPane.showMessageDialog(
+ parent,
+ msg,
+ title,
+ JOptionPane.WARNING_MESSAGE);
+ }
+ /**
+ * Returns the msg.
+ * @return String
+ */
+ public String getMsg() {
+ return msg;
+ }
+
+ /**
+ * Returns the title.
+ * @return String
+ */
+ public String getTitle() {
+ return title;
+ }
+
+ /**
+ * Sets the msg.
+ * @param msg The msg to set
+ */
+ public void setMsg(String msg) {
+ this.msg = msg;
+ }
+
+ /**
+ * Sets the title.
+ * @param title The title to set
+ */
+ public void setTitle(String title) {
+ this.title = title;
+ }
+ public static void show(Component parent,StringBuffer msg, String title) {
+ show(parent,msg.toString(),title);
+ }
+
+}
diff --git a/src/de/statspez/plausi/generated/Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN.java b/src/de/statspez/plausi/generated/Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN.java
new file mode 100644
index 0000000..2c2b344
--- /dev/null
+++ b/src/de/statspez/plausi/generated/Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN.java
@@ -0,0 +1,33212 @@
+package de.statspez.plausi.generated;
+
+import de.statspez.pleditor.generator.runtime.BasePlausi;
+import de.statspez.pleditor.generator.runtime.BooleanValue;
+import de.statspez.pleditor.generator.runtime.Classification;
+import de.statspez.pleditor.generator.runtime.FeatureVariable;
+import de.statspez.pleditor.generator.runtime.FeldDeskriptor;
+import de.statspez.pleditor.generator.runtime.FeldDeskriptorExt;
+import de.statspez.pleditor.generator.runtime.FunctionLib;
+import de.statspez.pleditor.generator.runtime.IntervalRange;
+import de.statspez.pleditor.generator.runtime.InvalidValue;
+import de.statspez.pleditor.generator.runtime.LocalVariable;
+import de.statspez.pleditor.generator.runtime.Material;
+import de.statspez.pleditor.generator.runtime.MaterialThemenbereich;
+import de.statspez.pleditor.generator.runtime.MaterialVariable;
+import de.statspez.pleditor.generator.runtime.MerkmalCheckFeatureVariable;
+import de.statspez.pleditor.generator.runtime.NumberValue;
+import de.statspez.pleditor.generator.runtime.OperatorLib;
+import de.statspez.pleditor.generator.runtime.PlausiDescriptor;
+import de.statspez.pleditor.generator.runtime.PlausiRuntimeContext;
+import de.statspez.pleditor.generator.runtime.Range;
+import de.statspez.pleditor.generator.runtime.RangeSeries;
+import de.statspez.pleditor.generator.runtime.ReturnStatementException;
+import de.statspez.pleditor.generator.runtime.RuntimeSettings;
+import de.statspez.pleditor.generator.runtime.SequenceRange;
+import de.statspez.pleditor.generator.runtime.SingleValueRange;
+import de.statspez.pleditor.generator.runtime.StringValue;
+import de.statspez.pleditor.generator.runtime.SupportLib;
+import de.statspez.pleditor.generator.runtime.TopicField;
+import de.statspez.pleditor.generator.runtime.Value;
+import de.statspez.pleditor.generator.runtime.ValueFactory;
+import de.statspez.pleditor.generator.runtime.Variable;
+import de.statspez.pleditor.generator.runtime.plausi.FeldDeskriptorInterface;
+import de.statspez.pleditor.generator.runtime.plausi.PlausiFehler;
+import de.statspez.pleditor.generator.runtime.plausi.SatzFilter;
+
+public class Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN extends BasePlausi
+{
+ public double getPlausiSystemVersion() { return 3.2; }
+ public String getPlausiVersionString() { return "20130212_105652"; }
+
+ public Value prg_Merkmal_M_01stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_01stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_1).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_01stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_01stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_01stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_01stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_01stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_01stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_01stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_01stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_01stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_01stelligesFeldAlphanummerisch" : "#M_01stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_Merkmal_M_02stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_02stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_2).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_02stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_02stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_02stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_02stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_02stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_02stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_02stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_02stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_02stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_02stelligesFeldAlphanummerisch" : "#M_02stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_Merkmal_M_03stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_03stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_3).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_03stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_03stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_03stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_03stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_03stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_03stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_03stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_03stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_03stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_03stelligesFeldAlphanummerisch" : "#M_03stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_Merkmal_M_04stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_04stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_4).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_04stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_04stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_04stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_04stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_04stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_04stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_04stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_04stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_04stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_04stelligesFeldAlphanummerisch" : "#M_04stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_Merkmal_M_05stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_05stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_5).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_05stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_05stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_05stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_05stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_05stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_05stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_05stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_05stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_05stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_05stelligesFeldAlphanummerisch" : "#M_05stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_Merkmal_M_06stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_06stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_6).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_06stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_06stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_06stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_06stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_06stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_06stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_06stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_06stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_06stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_06stelligesFeldAlphanummerisch" : "#M_06stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_Merkmal_M_07stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_07stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_7).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_07stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_07stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_07stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_07stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_07stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_07stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_07stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_07stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_07stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_07stelligesFeldAlphanummerisch" : "#M_07stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+
+
+ public Value prg_Merkmal_M_12stelligesFeldAlphanummerisch(PlausiRuntimeContext context, Variable aFeld)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewPruefSection("Merkmal M_12stelligesFeldAlphanummerisch");
+ try
+ {
+ context.getLogger().trace("Pruefe Feld " + ((FeatureVariable)aFeld).hierarchyAsString());
+ context.setCurrentField((FeatureVariable)aFeld);
+ Variable feld = new MerkmalCheckFeatureVariable((FeatureVariable)aFeld);
+ if(OperatorLib.ne(context, feld.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.gt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(feld.get(context))), __NUM_LIT_8).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_12stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_12stelligesFeldAlphanummerisch(context, 3, null);
+ return vf.valueFor(true);
+ }
+ }
+ if(OperatorLib.not(context, vf.valueFor(SupportLib.checkType(feld.get(context), 3, context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: Merkmal_M_12stelligesFeldAlphanummerisch");
+ fehler_Merkmal_M_12stelligesFeldAlphanummerisch(context, 2, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: Merkmal_M_12stelligesFeldAlphanummerisch", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): Merkmal_M_12stelligesFeldAlphanummerisch");
+ this.fehler_Merkmal_M_12stelligesFeldAlphanummerisch(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.setCurrentField(null);
+ context.leaveCurrentSection();
+ }
+ }
+
+ protected void fehler_Merkmal_M_12stelligesFeldAlphanummerisch(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("M_12stelligesFeldAlphanummerisch");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#M_12stelligesFeldAlphanummerisch" : "#M_12stelligesFeldAlphanummerisch");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public class TB_Abschluss3steller extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sig2steller;
+ public transient FeatureVariable sortKey;
+ public TB_Abschluss3steller(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Abschlussprüfungen 3-Steller"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Abschlussprüfung 3-Steller"), null);
+ this.sig2steller = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sig2steller", null, 3, null, "Signierschlüssel Abschlussprüfung 2-Steller"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "Sortierschlüssel Abschluss 3-Steller"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Abschluss3steller(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Abschluss3steller extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sig2steller;
+ public MaterialVariable sortKey;
+ public MaterialTB_Abschluss3steller(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sig2steller = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sig2steller", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Abschluss3steller(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Abschluss3steller_Land extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable keyBund;
+ public transient FeatureVariable land;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sig2steller;
+ public transient FeatureVariable sortKey;
+ public TB_Abschluss3steller_Land(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel landesintern Abschlussprüfungen 3-Steller"), null);
+ this.keyBund = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "keyBund", null, 3, null, "Signierschlüssel Bund Abschlussprüfungen 3-Steller"), null);
+ this.land = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "land", null, 3, null, "Signierschlüssel Berichtsland"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Abschlussprüfung 3-Steller"), null);
+ this.sig2steller = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sig2steller", null, 3, null, "Signierschlüssel Abschlussprüfung 2-Steller"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "landesinterner Sortierschlüssel Abschluss 3-Steller"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Abschluss3steller_Land(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Abschluss3steller_Land extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable keyBund;
+ public MaterialVariable land;
+ public MaterialVariable name;
+ public MaterialVariable sig2steller;
+ public MaterialVariable sortKey;
+ public MaterialTB_Abschluss3steller_Land(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.keyBund = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "keyBund", null, 3), null);
+ this.land = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "land", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sig2steller = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sig2steller", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Abschluss3steller_Land(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Bundesland extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_Bundesland(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültig ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültig ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültig bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültig bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Bundesland"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Bundesland"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "Sortierschlüssel Bundesland"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Bundesland(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Bundesland extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_Bundesland(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Bundesland(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_EinschreibungArt extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_EinschreibungArt(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Art der Einschreibung"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Art der Einschreibung"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "LEER"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_EinschreibungArt(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_EinschreibungArt extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_EinschreibungArt(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_EinschreibungArt(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_HZBArt extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable hochschulreifeArt;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_HZBArt(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.hochschulreifeArt = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "hochschulreifeArt", null, 3, null, "Art der Hochschulreife"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Art der HZB"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Art der HZB"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "LEER"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_HZBArt(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_HZBArt extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable hochschulreifeArt;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_HZBArt(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.hochschulreifeArt = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "hochschulreifeArt", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_HZBArt(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Hochschulfachbereich extends TopicField
+ {
+ public transient FeatureVariable foerderung;
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable habilitationsRecht;
+ public transient FeatureVariable hochschulStandort;
+ public transient FeatureVariable hochschulTraeger;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_Hochschulfachbereich(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.foerderung = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "foerderung", null, 3, null, "Förderung nach dem Hochschulbauförderungsgesetz (HBFG-gefördert)"), null);
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.habilitationsRecht = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "habilitationsRecht", null, 3, null, "Schlüssel Habilitationsrecht der Hochschule"), null);
+ this.hochschulStandort = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "hochschulStandort", null, 3, null, "Signierschlüssel Hochschulstandort"), null);
+ this.hochschulTraeger = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "hochschulTraeger", null, 3, null, "Signierschlüssel Trägerschaft der Hochschule"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Hochschulfachbereich"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Hochschulfachbereich"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "Sortierschlüssel Hochschulfachbereich"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Hochschulfachbereich(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Hochschulfachbereich extends MaterialThemenbereich
+ {
+ public MaterialVariable foerderung;
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable habilitationsRecht;
+ public MaterialVariable hochschulStandort;
+ public MaterialVariable hochschulTraeger;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_Hochschulfachbereich(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.foerderung = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "foerderung", null, 3), null);
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.habilitationsRecht = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "habilitationsRecht", null, 3), null);
+ this.hochschulStandort = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "hochschulStandort", null, 3), null);
+ this.hochschulTraeger = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "hochschulTraeger", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Hochschulfachbereich(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Hochschulstandort extends TopicField
+ {
+ public transient FeatureVariable bundesland;
+ public transient FeatureVariable gemeindeSchluessel;
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable hochschule;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_Hochschulstandort(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.bundesland = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "bundesland", null, 3, null, "Signierschlüssel Bundesland"), null);
+ this.gemeindeSchluessel = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gemeindeSchluessel", null, 3, null, "Gemeindeschlüssel"), null);
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.hochschule = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "hochschule", null, 3, null, "Signierschlüssel Hochschule"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Hochschulstandort"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Hochschulabteilung"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "Sortierschlüssel Hochschulstandort"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Hochschulstandort(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Hochschulstandort extends MaterialThemenbereich
+ {
+ public MaterialVariable bundesland;
+ public MaterialVariable gemeindeSchluessel;
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable hochschule;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_Hochschulstandort(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.bundesland = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "bundesland", null, 3), null);
+ this.gemeindeSchluessel = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gemeindeSchluessel", null, 3), null);
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.hochschule = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "hochschule", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Hochschulstandort(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Kreise extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_Kreise(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Kreise"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Kreise"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "LEER"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Kreise(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Kreise extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_Kreise(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Kreise(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Staat extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable kontinent;
+ public transient FeatureVariable mitgliedschaftEU;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_Staat(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüsel Staatsangehörigkeit"), null);
+ this.kontinent = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "kontinent", null, 3, null, "Signierschlüssel Kontinent"), null);
+ this.mitgliedschaftEU = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "mitgliedschaftEU", null, 3, null, "EU-Mitgliedschaft"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Staatsangehörigkeit"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "Sortierschlüssel Staatsangehörigkeit"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Staat(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Staat extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable kontinent;
+ public MaterialVariable mitgliedschaftEU;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_Staat(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.kontinent = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "kontinent", null, 3), null);
+ this.mitgliedschaftEU = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "mitgliedschaftEU", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Staat(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Studienfach extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable isced;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public transient FeatureVariable stb;
+ public TB_Studienfach(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.isced = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "isced", null, 3, null, "ISCED-Schlüssel"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Studienfach"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Studienfach"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "Sortierschlüssel Studienfach"), null);
+ this.stb = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "stb", null, 3, null, "Signierschlüssel Studienbereiche"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Studienfach(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Studienfach extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable isced;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialVariable stb;
+ public MaterialTB_Studienfach(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.isced = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "isced", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ this.stb = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "stb", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Studienfach(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_StudienfachMerkmalsKombination extends TopicField
+ {
+ public transient FeatureVariable abschluss3steller;
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable land;
+ public transient FeatureVariable regelstudienzeit;
+ public transient FeatureVariable sortKey;
+ public transient FeatureVariable studienfach;
+ public transient FeatureVariable vollteildual;
+ public TB_StudienfachMerkmalsKombination(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.abschluss3steller = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "abschluss3steller", null, 3, null, "Signierschlüssel Abschlussprüfung 3-steller"), null);
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Hochschule"), null);
+ this.land = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "land", null, 3, null, "Signierschlüssel Berichtsland"), null);
+ this.regelstudienzeit = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "regelstudienzeit", null, 3, null, "Angabe der Regelstudienzeit"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "LEER"), null);
+ this.studienfach = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "studienfach", null, 3, null, "Signierschlüssel Studienfach"), null);
+ this.vollteildual = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "vollteildual", null, 3, null, "Schlüssel Vollzeit / Teilzeit / Duales Studium"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_StudienfachMerkmalsKombination(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_StudienfachMerkmalsKombination extends MaterialThemenbereich
+ {
+ public MaterialVariable abschluss3steller;
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable land;
+ public MaterialVariable regelstudienzeit;
+ public MaterialVariable sortKey;
+ public MaterialVariable studienfach;
+ public MaterialVariable vollteildual;
+ public MaterialTB_StudienfachMerkmalsKombination(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.abschluss3steller = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "abschluss3steller", null, 3), null);
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.land = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "land", null, 3), null);
+ this.regelstudienzeit = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "regelstudienzeit", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ this.studienfach = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "studienfach", null, 3), null);
+ this.vollteildual = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "vollteildual", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_StudienfachMerkmalsKombination(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_Studienfach_Land extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable isced;
+ public transient FeatureVariable key;
+ public transient FeatureVariable keyBund;
+ public transient FeatureVariable land;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public transient FeatureVariable stb;
+ public TB_Studienfach_Land(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.isced = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "isced", null, 3, null, "ISCED-Schlüssel"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel landesintern Studienfach"), null);
+ this.keyBund = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "keyBund", null, 3, null, "Signierschlüssel Bund Studienfach"), null);
+ this.land = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "land", null, 3, null, "Signierschlüssel Berichtsland"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Studienfach"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "landesinterner Sortierschlüssel Studienfach"), null);
+ this.stb = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "stb", null, 3, null, "Signierschlüssel Studienbereiche"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_Studienfach_Land(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_Studienfach_Land extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable isced;
+ public MaterialVariable key;
+ public MaterialVariable keyBund;
+ public MaterialVariable land;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialVariable stb;
+ public MaterialTB_Studienfach_Land(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.isced = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "isced", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.keyBund = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "keyBund", null, 3), null);
+ this.land = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "land", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ this.stb = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "stb", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_Studienfach_Land(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_StudiumArt extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_StudiumArt(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Art des Studiums"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Art des Studiums"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "LEER"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_StudiumArt(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_StudiumArt extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_StudiumArt(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_StudiumArt(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_T_Studenten_Pruefungen extends TopicField
+ {
+ public transient FeatureVariable EF1;
+ public transient FeatureVariable EF100;
+ public transient FeatureVariable EF101;
+ public transient FeatureVariable EF102;
+ public transient FeatureVariable EF103;
+ public transient FeatureVariable EF104;
+ public transient FeatureVariable EF105;
+ public transient FeatureVariable EF106;
+ public transient FeatureVariable EF107;
+ public transient FeatureVariable EF108;
+ public transient FeatureVariable EF109;
+ public transient FeatureVariable EF10U1;
+ public transient FeatureVariable EF10U2;
+ public transient FeatureVariable EF110;
+ public transient FeatureVariable EF111U1;
+ public transient FeatureVariable EF111U2;
+ public transient FeatureVariable EF112;
+ public transient FeatureVariable EF113;
+ public transient FeatureVariable EF114;
+ public transient FeatureVariable EF115;
+ public transient FeatureVariable EF116;
+ public transient FeatureVariable EF117;
+ public transient FeatureVariable EF118;
+ public transient FeatureVariable EF119;
+ public transient FeatureVariable EF11U1;
+ public transient FeatureVariable EF11U2;
+ public transient FeatureVariable EF12;
+ public transient FeatureVariable EF120;
+ public transient FeatureVariable EF121;
+ public transient FeatureVariable EF122;
+ public transient FeatureVariable EF123;
+ public transient FeatureVariable EF124;
+ public transient FeatureVariable EF125;
+ public transient FeatureVariable EF126;
+ public transient FeatureVariable EF127;
+ public transient FeatureVariable EF128;
+ public transient FeatureVariable EF129;
+ public transient FeatureVariable EF13;
+ public transient FeatureVariable EF130;
+ public transient FeatureVariable EF131;
+ public transient FeatureVariable EF132;
+ public transient FeatureVariable EF133;
+ public transient FeatureVariable EF134;
+ public transient FeatureVariable EF135;
+ public transient FeatureVariable EF136;
+ public transient FeatureVariable EF137;
+ public transient FeatureVariable EF138;
+ public transient FeatureVariable EF139;
+ public transient FeatureVariable EF14;
+ public transient FeatureVariable EF140;
+ public transient FeatureVariable EF141;
+ public transient FeatureVariable EF142;
+ public transient FeatureVariable EF143;
+ public transient FeatureVariable EF144;
+ public transient FeatureVariable EF145;
+ public transient FeatureVariable EF146;
+ public transient FeatureVariable EF147;
+ public transient FeatureVariable EF148;
+ public transient FeatureVariable EF149;
+ public transient FeatureVariable EF15;
+ public transient FeatureVariable EF150;
+ public transient FeatureVariable EF151;
+ public transient FeatureVariable EF152;
+ public transient FeatureVariable EF16;
+ public transient FeatureVariable EF17;
+ public transient FeatureVariable EF18;
+ public transient FeatureVariable EF19;
+ public transient FeatureVariable EF2;
+ public transient FeatureVariable EF20;
+ public transient FeatureVariable EF21;
+ public transient FeatureVariable EF22;
+ public transient FeatureVariable EF23;
+ public transient FeatureVariable EF24;
+ public transient FeatureVariable EF25;
+ public transient FeatureVariable EF26;
+ public transient FeatureVariable EF27;
+ public transient FeatureVariable EF28;
+ public transient FeatureVariable EF29;
+ public transient FeatureVariable EF3;
+ public transient FeatureVariable EF30;
+ public transient FeatureVariable EF31;
+ public transient FeatureVariable EF32;
+ public transient FeatureVariable EF33;
+ public transient FeatureVariable EF34;
+ public transient FeatureVariable EF35;
+ public transient FeatureVariable EF36;
+ public transient FeatureVariable EF37;
+ public transient FeatureVariable EF38;
+ public transient FeatureVariable EF39;
+ public transient FeatureVariable EF4;
+ public transient FeatureVariable EF40;
+ public transient FeatureVariable EF41;
+ public transient FeatureVariable EF42;
+ public transient FeatureVariable EF43;
+ public transient FeatureVariable EF44;
+ public transient FeatureVariable EF45;
+ public transient FeatureVariable EF46;
+ public transient FeatureVariable EF47;
+ public transient FeatureVariable EF48;
+ public transient FeatureVariable EF49;
+ public transient FeatureVariable EF5;
+ public transient FeatureVariable EF50;
+ public transient FeatureVariable EF51;
+ public transient FeatureVariable EF52;
+ public transient FeatureVariable EF53;
+ public transient FeatureVariable EF54;
+ public transient FeatureVariable EF55;
+ public transient FeatureVariable EF56;
+ public transient FeatureVariable EF57;
+ public transient FeatureVariable EF58;
+ public transient FeatureVariable EF59;
+ public transient FeatureVariable EF6;
+ public transient FeatureVariable EF60;
+ public transient FeatureVariable EF61;
+ public transient FeatureVariable EF62;
+ public transient FeatureVariable EF63;
+ public transient FeatureVariable EF64;
+ public transient FeatureVariable EF65U1;
+ public transient FeatureVariable EF65U2;
+ public transient FeatureVariable EF66;
+ public transient FeatureVariable EF67;
+ public transient FeatureVariable EF68;
+ public transient FeatureVariable EF69;
+ public transient FeatureVariable EF7;
+ public transient FeatureVariable EF70;
+ public transient FeatureVariable EF71;
+ public transient FeatureVariable EF72;
+ public transient FeatureVariable EF73;
+ public transient FeatureVariable EF74;
+ public transient FeatureVariable EF75;
+ public transient FeatureVariable EF76;
+ public transient FeatureVariable EF77;
+ public transient FeatureVariable EF78;
+ public transient FeatureVariable EF79;
+ public transient FeatureVariable EF80;
+ public transient FeatureVariable EF81;
+ public transient FeatureVariable EF82;
+ public transient FeatureVariable EF83;
+ public transient FeatureVariable EF84;
+ public transient FeatureVariable EF85;
+ public transient FeatureVariable EF86;
+ public transient FeatureVariable EF87;
+ public transient FeatureVariable EF88;
+ public transient FeatureVariable EF89;
+ public transient FeatureVariable EF8U1;
+ public transient FeatureVariable EF8U2;
+ public transient FeatureVariable EF9;
+ public transient FeatureVariable EF90;
+ public transient FeatureVariable EF91;
+ public transient FeatureVariable EF92;
+ public transient FeatureVariable EF93;
+ public transient FeatureVariable EF94;
+ public transient FeatureVariable EF95;
+ public transient FeatureVariable EF96;
+ public transient FeatureVariable EF97;
+ public transient FeatureVariable EF98;
+ public transient FeatureVariable EF99;
+ public transient MaterialTB_Hochschulfachbereich __material_ref_HOCHSCHULFACHBEREICH;
+ public transient MaterialTB_Hochschulstandort __material_ref_HOCHSCHULSTANDORT;
+ public transient MaterialTB_Staat __material_ref_STAAT;
+ public transient MaterialTB_Bundesland __material_ref_BUNDESLAND;
+ public transient MaterialTB_EinschreibungArt __material_ref_EINSCHREIBUNGART;
+ public transient MaterialTB_Abschluss3steller __material_ref_ABSCHLUSS3STELLER;
+ public transient MaterialTB_Abschluss3steller_Land __material_ref_ABSCHLUSS3STELLER_LAND;
+ public transient MaterialTB_Studienfach_Land __material_ref_STUDIENFACH_LAND;
+ public transient MaterialTB_Studienfach __material_ref_STUDIENFACH;
+ public transient MaterialTB_StudiumArt __material_ref_STUDIUMART;
+ public transient MaterialTB_VollTeilzeit __material_ref_VOLLTEILZEIT;
+ public transient MaterialTB_HZBArt __material_ref_HZBART;
+ public transient MaterialTB_Kreise __material_ref_KREISE;
+ public transient MaterialTB_StudienfachMerkmalsKombination __material_ref_STUDIENFACHMERKMALSKOMBINATION;
+ public TB_T_Studenten_Pruefungen(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.EF1 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF1", null, 3, null, "Berichtsland"), null);
+ this.EF100 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF100", null, 3, null, "Art der Prüfung"), null);
+ this.EF101 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF101", null, 3, null, "1. Studienfach"), null);
+ this.EF102 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF102", null, 3, null, "2. Studienfach"), null);
+ this.EF103 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF103", null, 3, null, "3. Studienfach"), null);
+ this.EF104 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF104", null, 3, null, "frei für StLÄ"), null);
+ this.EF105 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF105", null, 3, null, "Monat des Prüfungsabschlusses"), null);
+ this.EF106 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF106", null, 3, null, "Jahr des Prüfungsabschlusses"), null);
+ this.EF107 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF107", null, 3, null, "Prüfungsergebnis"), null);
+ this.EF108 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF108", null, 3, null, "Gesamtnote"), null);
+ this.EF109 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF109", null, 3, null, "Jahr des ersten Erwerbs der HZB"), null);
+ this.EF10U1 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF10U1", null, 3, null, "Semesterwohnsitz - Bundesland/Ausland"), null);
+ this.EF10U2 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF10U2", null, 3, null, "Semesterwohnsitz Kreis/Staat"), null);
+ this.EF110 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF110", null, 3, null, "Art der HZB"), null);
+ this.EF111U1 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF111U1", null, 3, null, "Bundesland/Ausland"), null);
+ this.EF111U2 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF111U2", null, 3, null, "Kreis/Staat"), null);
+ this.EF112 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF112", null, 3, null, "Art der Tätigkeit (Aubildung)"), null);
+ this.EF113 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF113", null, 3, null, "Art der Tätigkeit (Praktikum)"), null);
+ this.EF114 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF114", null, 3, null, "LEER"), null);
+ this.EF115 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF115", null, 3, null, "LEER"), null);
+ this.EF116 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF116", null, 3, null, "LEER"), null);
+ this.EF117 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF117", null, 3, null, "LEER"), null);
+ this.EF118 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF118", null, 3, null, "LEER"), null);
+ this.EF119 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF119", null, 3, null, "LEER"), null);
+ this.EF11U1 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF11U1", null, 3, null, "Heimatwohnsitz - Bundesland/Ausland"), null);
+ this.EF11U2 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF11U2", null, 3, null, "Heimatwohnsitz Kreis/Staat"), null);
+ this.EF12 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF12", null, 3, null, "Hörerstatus"), null);
+ this.EF120 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF120", null, 3, null, "Prüfungsamt"), null);
+ this.EF121 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF121", null, 3, null, "Anzahl der Fachsemester für diese Prüfung"), null);
+ this.EF122 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF122", null, 3, null, "dar.: Anzahl der angerechneten Fachsemester insgesamt"), null);
+ this.EF123 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF123", null, 3, null, "Aus einem anderem Studiengang an einer deutschen Hochschule (einschl. Praxissemester)"), null);
+ this.EF124 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF124", null, 3, null, "Berufspraktische Tätigkeit vor der Einschreibung im Studiengang der Prüfung, soweit als Praxissemester bewertet"), null);
+ this.EF125 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF125", null, 3, null, "aus einem Auslandsstudium"), null);
+ this.EF126 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF126", null, 3, null, "Art der Prüfung"), null);
+ this.EF127 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF127", null, 3, null, "1. Studienfach"), null);
+ this.EF128 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF128", null, 3, null, "2. Studienfach"), null);
+ this.EF129 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF129", null, 3, null, "3. Studienfach"), null);
+ this.EF13 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF13", null, 3, null, "Frei für StLÄ"), null);
+ this.EF130 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF130", null, 3, null, "frei für StLÄ"), null);
+ this.EF131 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF131", null, 3, null, "frei für StLÄ"), null);
+ this.EF132 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF132", null, 3, null, "Monat des Prüfungsabschlusses"), null);
+ this.EF133 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF133", null, 3, null, "Jahr des Prüfungsabschlusses"), null);
+ this.EF134 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF134", null, 3, null, "Prüfungsergebnis"), null);
+ this.EF135 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF135", null, 3, null, "Gesamtnote"), null);
+ this.EF136 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF136", null, 3, null, "Prüfungsamt"), null);
+ this.EF137 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF137", null, 3, null, "Anzahl der Fachsemester für diese Prüfung"), null);
+ this.EF138 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF138", null, 3, null, "dar.: Anzahl der angerechneten Fachsemester insgesamt"), null);
+ this.EF139 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF139", null, 3, null, "Aus einem anderem Studiengang an einer deutschen Hochschule (einschl. Praxissemester)"), null);
+ this.EF14 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF14", null, 3, null, "Frei für StLÄ"), null);
+ this.EF140 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF140", null, 3, null, "Berufspraktische Tätigkeit vor der Einschreibung im Studiengang der Prüfung, soweit als Praxissemester bewertet"), null);
+ this.EF141 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF141", null, 3, null, "aus einem Auslandsstudium"), null);
+ this.EF142 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF142", null, 3, null, "Art der Prüfung"), null);
+ this.EF143 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF143", null, 3, null, "1. Studienfach"), null);
+ this.EF144 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF144", null, 3, null, "2. Studienfach"), null);
+ this.EF145 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF145", null, 3, null, "3. Studienfach"), null);
+ this.EF146 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF146", null, 3, null, "frei für StLÄ"), null);
+ this.EF147 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF147", null, 3, null, "frei für StLÄ"), null);
+ this.EF148 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF148", null, 3, null, "Monat des Prüfungsabschlusses"), null);
+ this.EF149 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF149", null, 3, null, "Jahr des Prüfungsabschlusses"), null);
+ this.EF15 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF15", null, 3, null, "Frei für StLÄ"), null);
+ this.EF150 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF150", null, 3, null, "Prüfungsergebnis"), null);
+ this.EF151 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF151", null, 3, null, "Gesamtnote"), null);
+ this.EF152 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF152", null, 3, null, "Gesamtnote in Punkten"), null);
+ this.EF16 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF16", null, 3, null, "Hochschule der Ersteinschreibung"), null);
+ this.EF17 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF17", null, 3, null, "Semester der Ersteinschreibung"), null);
+ this.EF18 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF18", null, 3, null, "Jahr der Ersteinschreibung"), null);
+ this.EF19 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF19", null, 3, null, "Anzahl der Hochschulsemester insgesamt"), null);
+ this.EF2 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF2", null, 3, null, "Berichtssemester"), null);
+ this.EF20 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF20", null, 3, null, "Urlaubssemester"), null);
+ this.EF21 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF21", null, 3, null, "Praxissemester"), null);
+ this.EF22 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF22", null, 3, null, "Semester in der DDR bzw. Berlin (Ost)"), null);
+ this.EF23 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF23", null, 3, null, "Art des Studiums (nur Studium in der DDR/Berlin (Ost))"), null);
+ this.EF24 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF24", null, 3, null, "Semester am Studienkolleg"), null);
+ this.EF25 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF25", null, 3, null, "Anzahl der Unterbrechungssemester insgesamt"), null);
+ this.EF26 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF26", null, 3, null, "Art der Einschreibung im Berichtssemester (1. Studiengang)"), null);
+ this.EF27 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF27", null, 3, null, "Grund der Exmatrikulation im Berichtssemester (1. Studiengang)"), null);
+ this.EF28 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF28", null, 3, null, "Art des Studiums im Berichtssemester (1. Studiengang)"), null);
+ this.EF29 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF29", null, 3, null, "Voll-/Teilzeit/ Duales Studium im Berichtssemester (1. Studiengang)"), null);
+ this.EF3 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF3", null, 3, null, "Berichtsjahr"), null);
+ this.EF30 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF30", null, 3, null, "Anzahl der Fachsemester im Berichtssemester (1. Studiengang)"), null);
+ this.EF31 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF31", null, 3, null, "Angestrebte Abschlussprüfung im Berichtssemester (1. Studiengang)"), null);
+ this.EF32 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF32", null, 3, null, "1. Studienfach im Berichtssemester (1. Studiengang)"), null);
+ this.EF33 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF33", null, 3, null, "Frei für StLÄ"), null);
+ this.EF34 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF34", null, 3, null, "2. Studienfach im Berichtssemester (1. Studiengang)"), null);
+ this.EF35 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF35", null, 3, null, "Frei für StLÄ"), null);
+ this.EF36 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF36", null, 3, null, "3. Studienfach im Berichtssemester (1. Studiengang)"), null);
+ this.EF37 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF37", null, 3, null, "Frei für StLÄ"), null);
+ this.EF38 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF38", null, 3, null, "Frei für StLÄ"), null);
+ this.EF39 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF39", null, 3, null, "Frei für StLÄ"), null);
+ this.EF4 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF4", null, 3, null, "Hochschule"), null);
+ this.EF40 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF40", null, 3, null, "Frei für StLÄ"), null);
+ this.EF41 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF41", null, 3, null, "Art der Einschreibung im Berichtssemester (2. Studiengang)"), null);
+ this.EF42 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF42", null, 3, null, "Grund der Exmatrikulation im Berichtssemester (2. Studiengang)"), null);
+ this.EF43 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF43", null, 3, null, "Art des Studiums im Berichtssemester (2. Studiengang)"), null);
+ this.EF44 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF44", null, 3, null, "Voll-/Teilzeit/ Duales Studium im Berichtssemester (2. Studiengang)"), null);
+ this.EF45 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF45", null, 3, null, "Anzahl der Fachsemester im Berichtssemester (2. Studiengang)"), null);
+ this.EF46 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF46", null, 3, null, "Angestrebte Abschlussprüfung im Berichtssemester (2. Studiengang)"), null);
+ this.EF47 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF47", null, 3, null, "1. Studienfach im Berichtssemester (2. Studiengang)"), null);
+ this.EF48 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF48", null, 3, null, "Frei für StLÄ"), null);
+ this.EF49 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF49", null, 3, null, "2. Studienfach im Berichtssemester (2. Studiengang)"), null);
+ this.EF5 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF5", null, 3, null, "Paginiernummer"), null);
+ this.EF50 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF50", null, 3, null, "Frei für StLÄ"), null);
+ this.EF51 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF51", null, 3, null, "3. Studienfach im Berichtssemester (2. Studiengang)"), null);
+ this.EF52 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF52", null, 3, null, "Frei für StLÄ"), null);
+ this.EF53 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF53", null, 3, null, "Frei für StLÄ"), null);
+ this.EF54 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF54", null, 3, null, "Frei für StLÄ"), null);
+ this.EF55 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF55", null, 3, null, "Frei für StLÄ"), null);
+ this.EF56 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF56", null, 3, null, "Hochschule (bei Einschreibung an einer anderen HS im Berichtssemester)"), null);
+ this.EF57 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF57", null, 3, null, "frei für StLÄ"), null);
+ this.EF58 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF58", null, 3, null, "frei für StLÄ"), null);
+ this.EF59 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF59", null, 3, null, "Angestrebte Abschlussprüfung"), null);
+ this.EF6 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF6", null, 3, null, "Matrikelnummer"), null);
+ this.EF60 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF60", null, 3, null, "1. Studienfach"), null);
+ this.EF61 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF61", null, 3, null, "2. Studienfach"), null);
+ this.EF62 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF62", null, 3, null, "3. Studienfach"), null);
+ this.EF63 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF63", null, 3, null, "frei für StLÄ"), null);
+ this.EF64 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF64", null, 3, null, "Hochschule im vorhergehenden Semester"), null);
+ this.EF65U1 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF65U1", null, 3, null, "Studiengang gleich dem Berichtssemster?"), null);
+ this.EF65U2 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF65U2", null, 3, null, "frei für StLÄ"), null);
+ this.EF66 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF66", null, 3, null, "Hochschule"), null);
+ this.EF67 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF67", null, 3, null, "frei für StLÄ"), null);
+ this.EF68 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF68", null, 3, null, "frei für StLÄ"), null);
+ this.EF69 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF69", null, 3, null, "Angestrebte Abschlussprüfung"), null);
+ this.EF7 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF7", null, 3, null, "Geschlecht"), null);
+ this.EF70 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF70", null, 3, null, "1. Studienfach"), null);
+ this.EF71 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF71", null, 3, null, "2. Studienfach"), null);
+ this.EF72 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF72", null, 3, null, "3. Studienfach"), null);
+ this.EF73 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF73", null, 3, null, "frei für StLÄ"), null);
+ this.EF74 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF74", null, 3, null, "Hochschule"), null);
+ this.EF75 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF75", null, 3, null, "frei für StLÄ"), null);
+ this.EF76 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF76", null, 3, null, "frei für StLÄ"), null);
+ this.EF77 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF77", null, 3, null, "Angestrebte Abschlussprüfung"), null);
+ this.EF78 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF78", null, 3, null, "1. Studienfach"), null);
+ this.EF79 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF79", null, 3, null, "2. Studienfach"), null);
+ this.EF80 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF80", null, 3, null, "3. Studienfach"), null);
+ this.EF81 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF81", null, 3, null, "frei für StLÄ"), null);
+ this.EF82 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF82", null, 3, null, "1. Land (Staat)"), null);
+ this.EF83 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF83", null, 3, null, "Anzahl der Monate"), null);
+ this.EF84 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF84", null, 3, null, "LEER"), null);
+ this.EF85 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF85", null, 3, null, "2. Land (Staat)"), null);
+ this.EF86 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF86", null, 3, null, "Anzahl der Monate"), null);
+ this.EF87 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF87", null, 3, null, "LEER"), null);
+ this.EF88 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF88", null, 3, null, "LEER"), null);
+ this.EF89 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF89", null, 3, null, "LEER"), null);
+ this.EF8U1 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF8U1", null, 3, null, "Geburtsdatum - Monat"), null);
+ this.EF8U2 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF8U2", null, 3, null, "Geburtsdatum - Jahr"), null);
+ this.EF9 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF9", null, 3, null, "Staatsangehörigkeit"), null);
+ this.EF90 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF90", null, 3, null, "LEER"), null);
+ this.EF91 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF91", null, 3, null, "Art der Prüfung"), null);
+ this.EF92 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF92", null, 3, null, "1. Studienfach"), null);
+ this.EF93 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF93", null, 3, null, "2. Studienfach"), null);
+ this.EF94 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF94", null, 3, null, "3. Studienfach"), null);
+ this.EF95 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF95", null, 3, null, "frei für StLÄ"), null);
+ this.EF96 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF96", null, 3, null, "Monat des Prüfungsabschlusses"), null);
+ this.EF97 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF97", null, 3, null, "Jahr des Prüfungsabschlusses"), null);
+ this.EF98 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF98", null, 3, null, "Prüfungsergebnis"), null);
+ this.EF99 = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "EF99", null, 3, null, "Gesamtnote"), null);
+ this.__material_ref_HOCHSCHULFACHBEREICH = __material_Hochschulfachbereich_Materialbeschreibung;
+ this.__material_ref_HOCHSCHULSTANDORT = __material_Hochschulstandort_Materialbeschreibung;
+ this.__material_ref_STAAT = __material_Staat_Materialbeschreibung;
+ this.__material_ref_BUNDESLAND = __material_Bundesland_Materialbeschreibung;
+ this.__material_ref_EINSCHREIBUNGART = __material_EinschreibungArt_Materialbeschreibung;
+ this.__material_ref_ABSCHLUSS3STELLER = __material_Abschluss3steller_Materialbeschreibung;
+ this.__material_ref_ABSCHLUSS3STELLER_LAND = __material_Abschluss3steller_Land_Materialbeschreibung;
+ this.__material_ref_STUDIENFACH_LAND = __material_Studienfach_Land_Materialbeschreibung;
+ this.__material_ref_STUDIENFACH = __material_Studienfach_Materialbeschreibung;
+ this.__material_ref_STUDIUMART = __material_StudiumArt_Materialbeschreibung;
+ this.__material_ref_VOLLTEILZEIT = __material_VollTeilzeit_Materialbeschreibung;
+ this.__material_ref_HZBART = __material_HZBArt_Materialbeschreibung;
+ this.__material_ref_KREISE = __material_Kreise_Materialbeschreibung;
+ this.__material_ref_STUDIENFACHMERKMALSKOMBINATION = __material_StudienfachMerkmalsKombination_Materialbeschreibung;
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_T_Studenten_Pruefungen(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+
+ public Value prg_LAND_000(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_000");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_1).asBoolean() && OperatorLib.eq(context, EF12.get(context), __STR_LIT_2).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.eq(context, EF4.get(context), __STR_LIT_4).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF32.get(context)).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF47.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF60.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF70.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF78.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF92.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF101.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF127.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_5), new SingleValueRange(__STR_LIT_6), new SingleValueRange(__STR_LIT_7), new SingleValueRange(__STR_LIT_8)}), EF143.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: LAND_000");
+ fehler_LAND_000(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_000", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_000");
+ this.fehler_LAND_000(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_000");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_000(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_000");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_000" : "#LAND_000");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_000K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_000K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_9), new SingleValueRange(__STR_LIT_10), new SingleValueRange(__STR_LIT_11)}), EF110.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12)}), EF112.get(context))).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12)}), EF113.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: LAND_000K");
+ fehler_LAND_000K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_000K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_000K");
+ this.fehler_LAND_000K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_000K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_000K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_000K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_000K" : "#LAND_000K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_001(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_001");
+ try
+ {
+ if(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF38.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF38.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF38.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF38.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF53.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF53.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF53.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF53.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF63.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF63.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF63.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF63.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF73.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF73.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF73.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF73.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF81.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF81.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF81.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF81.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF95.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF95.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF95.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF95.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF104.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF104.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF104.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF104.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF130.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF130.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF130.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF130.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF146.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF146.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF146.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF146.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF33.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF33.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF33.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF33.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF35.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF35.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF35.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF35.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF37.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF37.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF37.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF37.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF39.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF39.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF39.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF39.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF48.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF48.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF48.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF48.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF50.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF50.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF50.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF50.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF52.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF52.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF52.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF52.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF54.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF54.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF54.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF54.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_001");
+ fehler_LAND_001(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_001", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_001");
+ this.fehler_LAND_001(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_001");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_001(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_001");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_001" : "#LAND_001");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_002(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_002");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF28.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF29.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF28.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF28.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF38.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_002");
+ fehler_LAND_002(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_002", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_002");
+ this.fehler_LAND_002(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_002");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_002(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_002");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_002" : "#LAND_002");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_003(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_003");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF43.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF44.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF43.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF43.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF46.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF53.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_003");
+ fehler_LAND_003(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_003", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_003");
+ this.fehler_LAND_003(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_003");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_003(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_003");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_003" : "#LAND_003");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_004(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_004");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(EF38.get(context)));
+ }
+ if(OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF38.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_004");
+ fehler_LAND_004(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_004", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_004");
+ this.fehler_LAND_004(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_004");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_004(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_004");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_004" : "#LAND_004");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_005(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_005");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(EF53.get(context)));
+ }
+ if(OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF53.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_005");
+ fehler_LAND_005(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_005", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_005");
+ this.fehler_LAND_005(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_005");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_005(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_005");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_005" : "#LAND_005");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_006(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_006");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF34.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(EF38.get(context)));
+ }
+ if(OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF38.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_006");
+ fehler_LAND_006(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_006", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_006");
+ this.fehler_LAND_006(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_006");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_006(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_006");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_006" : "#LAND_006");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_007(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_007");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF49.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(EF53.get(context)));
+ }
+ if(OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF53.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_007");
+ fehler_LAND_007(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_007", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_007");
+ this.fehler_LAND_007(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_007");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_007(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_007");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_007" : "#LAND_007");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_008(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_008");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF36.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(EF38.get(context)));
+ }
+ if(OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF38.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_008");
+ fehler_LAND_008(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_008", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_008");
+ this.fehler_LAND_008(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_008");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_008(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_008");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_008" : "#LAND_008");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_009(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_009");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF51.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(EF53.get(context)));
+ }
+ if(OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF53.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_009");
+ fehler_LAND_009(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_009", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_009");
+ this.fehler_LAND_009(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_009");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_009(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_009");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_009" : "#LAND_009");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_010(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_010");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF38.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF53.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF63.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF63.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF73.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF73.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF81.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF81.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF95.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF95.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF104.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF104.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF130.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF146.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF38.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF31.get(context))}, context), EF38.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF53.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF46.get(context))}, context), EF53.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_22), new SingleValueRange(__STR_LIT_23)}), EF56.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context))}, context), EF56.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF63.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF56.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF59.get(context))}, context), EF63.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF126.get(context))}, context), EF128.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF126.get(context))}, context), EF129.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF126.get(context))}, context), EF130.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF142.get(context))}, context), EF144.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF142.get(context))}, context), EF145.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF142.get(context))}, context), EF146.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: LAND_010");
+ fehler_LAND_010(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_010", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_010");
+ this.fehler_LAND_010(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_010");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_010(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_010");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_010" : "#LAND_010");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_012(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_012");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF129.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(EF130.get(context)));
+ }
+ if(OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF130.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_012");
+ fehler_LAND_012(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_012", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_012");
+ this.fehler_LAND_012(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_012");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_012(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_012");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_012" : "#LAND_012");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_013(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_013");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF128.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(EF129.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF130.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(EF130.get(context)));
+ }
+ if(OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF130.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_013");
+ fehler_LAND_013(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_013", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_013");
+ this.fehler_LAND_013(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_013");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_013(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_013");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_013" : "#LAND_013");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_014(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_014");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF127.set(context, ValueFactory.instance().valueFor(EF128.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(EF129.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF130.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(EF130.get(context)));
+ }
+ if(OperatorLib.ne(context, EF130.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF130.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_014");
+ fehler_LAND_014(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_014", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_014");
+ this.fehler_LAND_014(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_014");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_014(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_014");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_014" : "#LAND_014");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_015(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_015");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF145.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(EF146.get(context)));
+ }
+ if(OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF146.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_015");
+ fehler_LAND_015(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_015", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_015");
+ this.fehler_LAND_015(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_015");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_015(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_015");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_015" : "#LAND_015");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_016(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_016");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF144.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(EF145.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF146.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(EF146.get(context)));
+ }
+ if(OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF146.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_016");
+ fehler_LAND_016(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_016", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_016");
+ this.fehler_LAND_016(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_016");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_016(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_016");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_016" : "#LAND_016");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_LAND_017(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung LAND_017");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF143.set(context, ValueFactory.instance().valueFor(EF144.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(EF145.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF146.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(EF146.get(context)));
+ }
+ if(OperatorLib.ne(context, EF146.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF146.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: LAND_017");
+ fehler_LAND_017(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: LAND_017", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): LAND_017");
+ this.fehler_LAND_017(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: LAND_017");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_LAND_017(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("LAND_017");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#LAND_017" : "#LAND_017");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_003(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_003");
+ try
+ {
+ if(OperatorLib.ne(context, EF4.get(context), InvalidValue.instance()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF2.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF2.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF3.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF3.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF4.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF4.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF5.get(context), __STR_LIT_26).asBoolean())
+ {
+ EF5.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF6.get(context), __STR_LIT_27).asBoolean())
+ {
+ EF6.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF7.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF7.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF8U1.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF8U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF8U2.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF8U2.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF9.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF9.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF10U1.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF10U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF10U2.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF10U2.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF11U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF11U2.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF11U2.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF12.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF12.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF17.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF17.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF18.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF19.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF19.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF20.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF20.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF21.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF21.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF22.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF22.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF23.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF23.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF24.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF24.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF25.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF25.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF26.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF26.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF27.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF27.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF28.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF28.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF29.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF29.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF30.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF31.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF32.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF34.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF36.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF41.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF41.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF42.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF42.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF43.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF43.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF44.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF44.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF45.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF45.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF46.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF46.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF47.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF49.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF51.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF56.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF56.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF59.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF59.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF60.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF60.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF61.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF61.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF62.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF62.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF64.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF64.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF65U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF69.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF70.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF71.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF72.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF77.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF78.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF79.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF80.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF82.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF82.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF83.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF83.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF85.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF85.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF86.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF86.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF91.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF91.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF92.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF92.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF93.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF94.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF94.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF96.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF96.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF97.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF97.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF98.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF98.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF99.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF100.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF100.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF101.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF101.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF102.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF103.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF103.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF105.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF105.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF106.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF106.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF107.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF107.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF108.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF109.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF109.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF110.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF110.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF111U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF111U2.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF111U2.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF112.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF112.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF113.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF113.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF120.get(context), __STR_LIT_28).asBoolean())
+ {
+ EF120.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF121.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF121.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF122.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF122.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF123.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF123.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF124.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF124.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF125.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF125.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF126.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF126.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF127.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF127.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF128.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF129.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF132.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF132.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF133.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF133.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF134.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF134.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF135.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF136.get(context), __STR_LIT_28).asBoolean())
+ {
+ EF136.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF137.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF137.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF138.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF138.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF139.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF139.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF140.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF140.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF141.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF141.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF142.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF142.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF143.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF143.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF144.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF145.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF148.get(context), __STR_LIT_16).asBoolean())
+ {
+ EF148.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF149.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF149.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF150.get(context), __STR_LIT_24).asBoolean())
+ {
+ EF150.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF151.get(context), __STR_LIT_14).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF152.get(context), __STR_LIT_25).asBoolean())
+ {
+ EF152.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_003");
+ fehler_MA_003(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_003", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_003");
+ this.fehler_MA_003(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_003");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_003(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_003");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_003" : "#MA_003");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_006(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_006");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF10U1.get(context), __STR_LIT_17).asBoolean() || OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF12.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF16.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF17.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF18.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF23.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF24.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF26.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF28.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF29.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF31.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF32.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF34.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF41.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF43.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF44.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF46.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF47.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF49.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF56.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF59.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF60.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF61.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF62.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF64.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF66.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF69.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF70.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF71.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF72.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF74.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF77.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF78.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF79.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF80.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF82.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF85.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF91.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF92.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF93.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF96.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF97.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF98.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF100.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF101.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF102.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF103.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF105.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF106.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF109.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF110.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF112.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF113.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF120.get(context), __STR_LIT_31).asBoolean()).asBoolean() || OperatorLib.eq(context, EF126.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF127.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF128.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF129.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF132.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF133.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF134.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.eq(context, EF136.get(context), __STR_LIT_31).asBoolean()).asBoolean() || OperatorLib.eq(context, EF142.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF143.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF144.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF145.get(context), __STR_LIT_15).asBoolean()).asBoolean() || OperatorLib.eq(context, EF148.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.eq(context, EF149.get(context), __STR_LIT_30).asBoolean()).asBoolean() || OperatorLib.eq(context, EF150.get(context), __STR_LIT_29).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF10U1.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF10U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF11U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF12.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF12.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF17.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF17.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF18.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF23.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF23.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF24.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF24.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF26.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF26.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF28.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF28.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF29.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF29.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF31.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF32.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF34.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF36.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF41.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF41.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF43.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF43.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF44.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF44.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF46.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF46.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF47.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF49.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF51.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF56.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF56.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF59.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF59.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF60.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF60.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF61.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF61.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF62.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF62.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF64.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF64.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF65U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF69.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF70.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF71.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF72.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF77.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF78.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF79.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF80.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF82.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF82.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF85.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF85.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF91.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF91.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF92.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF92.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF93.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF94.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF94.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF96.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF96.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF97.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF97.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF98.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF98.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF100.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF100.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF101.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF101.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF102.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF103.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF103.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF105.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF105.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF106.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF106.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF107.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF107.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF109.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF109.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF110.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF110.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF111U1.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF112.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF112.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF113.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF113.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF120.get(context), __STR_LIT_31).asBoolean())
+ {
+ EF120.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF126.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF126.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF127.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF127.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF128.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF129.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF132.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF132.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF133.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF133.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF134.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF134.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF136.get(context), __STR_LIT_31).asBoolean())
+ {
+ EF136.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF142.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF142.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF143.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF143.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF144.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF145.get(context), __STR_LIT_15).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF148.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF148.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF149.get(context), __STR_LIT_30).asBoolean())
+ {
+ EF149.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, EF150.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF150.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_006");
+ fehler_MA_006(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_006", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_006");
+ this.fehler_MA_006(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_006");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_006(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_006");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_006" : "#MA_006");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_009(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_009");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && OperatorLib.ne(context, EF11U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF11U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF11U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36)}), EF110.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36)}), EF110.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.ne(context, EF11U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF11U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF11U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36), new SingleValueRange(__STR_LIT_38), new SingleValueRange(__STR_LIT_39), new SingleValueRange(__STR_LIT_40)}), EF110.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36), new SingleValueRange(__STR_LIT_38), new SingleValueRange(__STR_LIT_39), new SingleValueRange(__STR_LIT_40)}), EF110.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF11U1.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF111U1.set(context, ValueFactory.instance().valueFor(EF11U1.get(context)));
+ }
+ if(OperatorLib.ne(context, EF11U2.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF111U2.set(context, ValueFactory.instance().valueFor(EF11U2.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_009");
+ fehler_MA_009(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_009", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_009");
+ this.fehler_MA_009(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_009");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_009(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_009");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_009" : "#MA_009");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_012(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_012");
+ try
+ {
+ if(vf.valueFor(prg_EIG_B(context).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF97.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF106.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF109.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_012");
+ fehler_MA_012(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_012", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_012");
+ this.fehler_MA_012(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_012");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_012(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_012");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_012" : "#MA_012");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_015(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_015");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36)}), EF110.get(context)).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF9.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_9), new SingleValueRange(__NUM_LIT_10)}), EF9.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF11U1.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF11U2.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF11U2.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF111U1.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF111U2.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF111U2.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36), new SingleValueRange(__STR_LIT_38), new SingleValueRange(__STR_LIT_39), new SingleValueRange(__STR_LIT_40)}), EF110.get(context)).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF9.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_9), new SingleValueRange(__NUM_LIT_10)}), EF9.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF11U1.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF11U2.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF11U2.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF111U1.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF111U2.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF111U2.get(context), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_9), new SingleValueRange(__NUM_LIT_10)}), EF9.get(context)).asBoolean())
+ {
+ EF111U1.set(context, ValueFactory.instance().valueFor(__STR_LIT_33));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_9), new SingleValueRange(__NUM_LIT_10)}), EF9.get(context)).asBoolean())
+ {
+ EF111U2.set(context, ValueFactory.instance().valueFor(EF9.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_015");
+ fehler_MA_015(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_015", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_015");
+ this.fehler_MA_015(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_015");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_015(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_015");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_015" : "#MA_015");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_018(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_018");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF4.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF16.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ context.getLogger().trace("Fehler angeschrieben: MA_018");
+ fehler_MA_018(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_018", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_018");
+ this.fehler_MA_018(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_018");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_018(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_018");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF16;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_018");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_021(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_021");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF17.set(context, ValueFactory.instance().valueFor(EF2.get(context)));
+ context.getLogger().trace("Fehler angeschrieben: MA_021");
+ fehler_MA_021(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_021", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_021");
+ this.fehler_MA_021(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_021");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_021(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_021");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF17;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_021");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_024(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_024");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF3.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(EF3.get(context)));
+ context.getLogger().trace("Fehler angeschrieben: MA_024");
+ fehler_MA_024(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_024", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_024");
+ this.fehler_MA_024(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_024");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_024(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_024");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF18;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_024");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_027(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_027");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47)}), EF1.get(context))).asBoolean() && OperatorLib.lt(context, EF20.get(context), __STR_LIT_44).asBoolean()).asBoolean() && OperatorLib.eq(context, EF19.get(context), EF20.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF28.get(context))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF43.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF21.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF21.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.ne(context, EF22.get(context), __STR_LIT_29).asBoolean())
+ {
+ EF22.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.ne(context, EF30.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.ne(context, EF45.get(context), __STR_LIT_17).asBoolean())
+ {
+ EF45.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_027");
+ fehler_MA_027(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_027", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_027");
+ this.fehler_MA_027(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_027");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_027(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_027");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_027" : "#MA_027");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_030(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_030");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_48), new SingleValueRange(__STR_LIT_49), new SingleValueRange(__STR_LIT_50), new SingleValueRange(__STR_LIT_51), new SingleValueRange(__STR_LIT_52), new SingleValueRange(__STR_LIT_53), new SingleValueRange(__STR_LIT_54), new SingleValueRange(__STR_LIT_55), new SingleValueRange(__STR_LIT_56), new SingleValueRange(__STR_LIT_57), new SingleValueRange(__STR_LIT_58), new SingleValueRange(__STR_LIT_59), new SingleValueRange(__STR_LIT_60), new SingleValueRange(__STR_LIT_61), new SingleValueRange(__STR_LIT_62), new SingleValueRange(__STR_LIT_63), new SingleValueRange(__STR_LIT_64), new SingleValueRange(__STR_LIT_65), new SingleValueRange(__STR_LIT_66), new SingleValueRange(__STR_LIT_67), new SingleValueRange(__STR_LIT_68), new SingleValueRange(__STR_LIT_69), new SingleValueRange(__STR_LIT_70), new SingleValueRange(__STR_LIT_71), new SingleValueRange(__STR_LIT_72), new SingleValueRange(__STR_LIT_73), new SingleValueRange(__STR_LIT_74), new SingleValueRange(__STR_LIT_75), new SingleValueRange(__STR_LIT_76), new SingleValueRange(__STR_LIT_77), new SingleValueRange(__STR_LIT_78), new SingleValueRange(__STR_LIT_79), new SingleValueRange(__STR_LIT_80), new SingleValueRange(__STR_LIT_81)}), EF16.get(context)).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_82), new SingleValueRange(__STR_LIT_83)}), EF16.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_85), new SingleValueRange(__STR_LIT_86)}), EF16.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_22));
+ context.getLogger().trace("Fehler angeschrieben: MA_030");
+ fehler_MA_030(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_030", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_030");
+ this.fehler_MA_030(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_030");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_030(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_030");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF16;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_030");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_033(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_033");
+ try
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_87), new SingleValueRange(__STR_LIT_88), new SingleValueRange(__STR_LIT_89), new SingleValueRange(__STR_LIT_90), new SingleValueRange(__STR_LIT_91), new SingleValueRange(__STR_LIT_92), new SingleValueRange(__STR_LIT_93), new SingleValueRange(__STR_LIT_94), new SingleValueRange(__STR_LIT_95), new SingleValueRange(__STR_LIT_96), new SingleValueRange(__STR_LIT_97), new SingleValueRange(__STR_LIT_98), new SingleValueRange(__STR_LIT_99), new SingleValueRange(__STR_LIT_100), new SingleValueRange(__STR_LIT_101), new SingleValueRange(__STR_LIT_102), new SingleValueRange(__STR_LIT_103), new SingleValueRange(__STR_LIT_104), new SingleValueRange(__STR_LIT_105), new SingleValueRange(__STR_LIT_106), new SingleValueRange(__STR_LIT_107), new SingleValueRange(__STR_LIT_108), new SingleValueRange(__STR_LIT_109), new SingleValueRange(__STR_LIT_110), new SingleValueRange(__STR_LIT_111), new SingleValueRange(__STR_LIT_112), new SingleValueRange(__STR_LIT_113), new SingleValueRange(__STR_LIT_114), new SingleValueRange(__STR_LIT_115), new SingleValueRange(__STR_LIT_116), new SingleValueRange(__STR_LIT_117), new SingleValueRange(__STR_LIT_118), new SingleValueRange(__STR_LIT_119), new SingleValueRange(__STR_LIT_120), new SingleValueRange(__STR_LIT_121), new SingleValueRange(__STR_LIT_122), new SingleValueRange(__STR_LIT_123), new SingleValueRange(__STR_LIT_124), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_127), new SingleValueRange(__STR_LIT_128), new SingleValueRange(__STR_LIT_129), new SingleValueRange(__STR_LIT_130), new SingleValueRange(__STR_LIT_131), new SingleValueRange(__STR_LIT_132), new SingleValueRange(__STR_LIT_133), new SingleValueRange(__STR_LIT_134), new SingleValueRange(__STR_LIT_135), new SingleValueRange(__STR_LIT_136), new SingleValueRange(__STR_LIT_137), new SingleValueRange(__STR_LIT_138), new SingleValueRange(__STR_LIT_139), new SingleValueRange(__STR_LIT_140), new SingleValueRange(__STR_LIT_141), new SingleValueRange(__STR_LIT_142), new SingleValueRange(__STR_LIT_143), new SingleValueRange(__STR_LIT_144), new SingleValueRange(__STR_LIT_145), new SingleValueRange(__STR_LIT_146), new SingleValueRange(__STR_LIT_146), new SingleValueRange(__STR_LIT_147), new SingleValueRange(__STR_LIT_148), new SingleValueRange(__STR_LIT_149), new SingleValueRange(__STR_LIT_150), new SingleValueRange(__STR_LIT_151), new SingleValueRange(__STR_LIT_152), new SingleValueRange(__STR_LIT_153), new SingleValueRange(__STR_LIT_154), new SingleValueRange(__STR_LIT_155), new SingleValueRange(__STR_LIT_156), new SingleValueRange(__STR_LIT_157), new SingleValueRange(__STR_LIT_158), new SingleValueRange(__STR_LIT_159), new SingleValueRange(__STR_LIT_160), new SingleValueRange(__STR_LIT_161), new SingleValueRange(__STR_LIT_162), new SingleValueRange(__STR_LIT_163), new SingleValueRange(__STR_LIT_164), new SingleValueRange(__STR_LIT_165), new SingleValueRange(__STR_LIT_166), new SingleValueRange(__STR_LIT_167), new SingleValueRange(__STR_LIT_168), new SingleValueRange(__STR_LIT_169), new SingleValueRange(__STR_LIT_170), new SingleValueRange(__STR_LIT_171), new SingleValueRange(__STR_LIT_172), new SingleValueRange(__STR_LIT_173), new SingleValueRange(__STR_LIT_174), new SingleValueRange(__STR_LIT_175), new SingleValueRange(__STR_LIT_176), new SingleValueRange(__STR_LIT_177), new SingleValueRange(__STR_LIT_178), new SingleValueRange(__STR_LIT_179), new SingleValueRange(__STR_LIT_180), new SingleValueRange(__STR_LIT_181), new SingleValueRange(__STR_LIT_182), new SingleValueRange(__STR_LIT_183), new SingleValueRange(__STR_LIT_184), new SingleValueRange(__STR_LIT_185), new SingleValueRange(__STR_LIT_186), new SingleValueRange(__STR_LIT_187), new SingleValueRange(__STR_LIT_188), new SingleValueRange(__STR_LIT_189), new SingleValueRange(__STR_LIT_190), new SingleValueRange(__STR_LIT_191), new SingleValueRange(__STR_LIT_192), new SingleValueRange(__STR_LIT_192), new SingleValueRange(__STR_LIT_193), new SingleValueRange(__STR_LIT_194), new SingleValueRange(__STR_LIT_195), new SingleValueRange(__STR_LIT_196), new SingleValueRange(__STR_LIT_197), new SingleValueRange(__STR_LIT_198), new SingleValueRange(__STR_LIT_199), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_202), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_208), new SingleValueRange(__STR_LIT_209), new SingleValueRange(__STR_LIT_210), new SingleValueRange(__STR_LIT_211), new SingleValueRange(__STR_LIT_212), new SingleValueRange(__STR_LIT_213), new SingleValueRange(__STR_LIT_214), new SingleValueRange(__STR_LIT_215), new SingleValueRange(__STR_LIT_216), new SingleValueRange(__STR_LIT_217), new SingleValueRange(__STR_LIT_218), new SingleValueRange(__STR_LIT_219), new SingleValueRange(__STR_LIT_220), new SingleValueRange(__STR_LIT_221), new SingleValueRange(__STR_LIT_222), new SingleValueRange(__STR_LIT_223), new SingleValueRange(__STR_LIT_224), new SingleValueRange(__STR_LIT_225), new SingleValueRange(__STR_LIT_226), new SingleValueRange(__STR_LIT_227), new SingleValueRange(__STR_LIT_228), new SingleValueRange(__STR_LIT_229), new SingleValueRange(__STR_LIT_230), new SingleValueRange(__STR_LIT_231), new SingleValueRange(__STR_LIT_232), new SingleValueRange(__STR_LIT_233), new SingleValueRange(__STR_LIT_234), new SingleValueRange(__STR_LIT_235), new SingleValueRange(__STR_LIT_236), new SingleValueRange(__STR_LIT_237), new SingleValueRange(__STR_LIT_238), new SingleValueRange(__STR_LIT_239), new SingleValueRange(__STR_LIT_240), new SingleValueRange(__STR_LIT_241), new SingleValueRange(__STR_LIT_242), new SingleValueRange(__STR_LIT_243), new SingleValueRange(__STR_LIT_244), new SingleValueRange(__STR_LIT_245), new SingleValueRange(__STR_LIT_246), new SingleValueRange(__STR_LIT_247), new SingleValueRange(__STR_LIT_248), new SingleValueRange(__STR_LIT_249), new SingleValueRange(__STR_LIT_250), new SingleValueRange(__STR_LIT_251), new SingleValueRange(__STR_LIT_252), new SingleValueRange(__STR_LIT_253), new SingleValueRange(__STR_LIT_254), new SingleValueRange(__STR_LIT_255), new SingleValueRange(__STR_LIT_256), new SingleValueRange(__STR_LIT_257), new SingleValueRange(__STR_LIT_258), new SingleValueRange(__STR_LIT_259), new SingleValueRange(__STR_LIT_260), new SingleValueRange(__STR_LIT_261), new SingleValueRange(__STR_LIT_262), new SingleValueRange(__STR_LIT_263), new SingleValueRange(__STR_LIT_264), new SingleValueRange(__STR_LIT_265), new SingleValueRange(__STR_LIT_266), new SingleValueRange(__STR_LIT_267), new SingleValueRange(__STR_LIT_268), new SingleValueRange(__STR_LIT_269), new SingleValueRange(__STR_LIT_270), new SingleValueRange(__STR_LIT_271), new SingleValueRange(__STR_LIT_272), new SingleValueRange(__STR_LIT_273), new SingleValueRange(__STR_LIT_274), new SingleValueRange(__STR_LIT_275), new SingleValueRange(__STR_LIT_276), new SingleValueRange(__STR_LIT_277), new SingleValueRange(__STR_LIT_278), new SingleValueRange(__STR_LIT_279), new SingleValueRange(__STR_LIT_280), new SingleValueRange(__STR_LIT_281), new SingleValueRange(__STR_LIT_282), new SingleValueRange(__STR_LIT_283), new SingleValueRange(__STR_LIT_284), new SingleValueRange(__STR_LIT_285), new SingleValueRange(__STR_LIT_286), new SingleValueRange(__STR_LIT_287), new SingleValueRange(__STR_LIT_288), new SingleValueRange(__STR_LIT_68), new SingleValueRange(__STR_LIT_289), new SingleValueRange(__STR_LIT_290), new SingleValueRange(__STR_LIT_291), new SingleValueRange(__STR_LIT_292), new SingleValueRange(__STR_LIT_293), new SingleValueRange(__STR_LIT_294), new SingleValueRange(__STR_LIT_295), new SingleValueRange(__STR_LIT_296), new SingleValueRange(__STR_LIT_297), new SingleValueRange(__STR_LIT_298), new SingleValueRange(__STR_LIT_299), new SingleValueRange(__STR_LIT_300), new SingleValueRange(__STR_LIT_301), new SingleValueRange(__STR_LIT_302), new SingleValueRange(__STR_LIT_303), new SingleValueRange(__STR_LIT_304), new SingleValueRange(__STR_LIT_305), new SingleValueRange(__STR_LIT_306), new SingleValueRange(__STR_LIT_307), new SingleValueRange(__STR_LIT_308), new SingleValueRange(__STR_LIT_309), new SingleValueRange(__STR_LIT_310), new SingleValueRange(__STR_LIT_311), new SingleValueRange(__STR_LIT_312), new SingleValueRange(__STR_LIT_313), new SingleValueRange(__STR_LIT_314), new SingleValueRange(__STR_LIT_315), new SingleValueRange(__STR_LIT_316), new SingleValueRange(__STR_LIT_317), new SingleValueRange(__STR_LIT_318), new SingleValueRange(__STR_LIT_319), new SingleValueRange(__STR_LIT_320), new SingleValueRange(__STR_LIT_321), new SingleValueRange(__STR_LIT_322), new SingleValueRange(__STR_LIT_323), new SingleValueRange(__STR_LIT_324), new SingleValueRange(__STR_LIT_325), new SingleValueRange(__STR_LIT_326), new SingleValueRange(__STR_LIT_327), new SingleValueRange(__STR_LIT_328), new SingleValueRange(__STR_LIT_329), new SingleValueRange(__STR_LIT_330), new SingleValueRange(__STR_LIT_331), new SingleValueRange(__STR_LIT_332), new SingleValueRange(__STR_LIT_333), new SingleValueRange(__STR_LIT_334), new SingleValueRange(__STR_LIT_335), new SingleValueRange(__STR_LIT_336), new SingleValueRange(__STR_LIT_337), new SingleValueRange(__STR_LIT_338), new SingleValueRange(__STR_LIT_339), new SingleValueRange(__STR_LIT_340), new SingleValueRange(__STR_LIT_341), new SingleValueRange(__STR_LIT_342), new SingleValueRange(__STR_LIT_343), new SingleValueRange(__STR_LIT_344), new SingleValueRange(__STR_LIT_345), new SingleValueRange(__STR_LIT_346), new SingleValueRange(__STR_LIT_347), new SingleValueRange(__STR_LIT_348), new SingleValueRange(__STR_LIT_349), new SingleValueRange(__STR_LIT_350), new SingleValueRange(__STR_LIT_351), new SingleValueRange(__STR_LIT_219), new SingleValueRange(__STR_LIT_214), new SingleValueRange(__STR_LIT_215), new SingleValueRange(__STR_LIT_234), new SingleValueRange(__STR_LIT_241), new SingleValueRange(__STR_LIT_242), new SingleValueRange(__STR_LIT_352), new SingleValueRange(__STR_LIT_353), new SingleValueRange(__STR_LIT_354), new SingleValueRange(__STR_LIT_355), new SingleValueRange(__STR_LIT_356), new SingleValueRange(__STR_LIT_357), new SingleValueRange(__STR_LIT_353), new SingleValueRange(__STR_LIT_358), new SingleValueRange(__STR_LIT_359), new SingleValueRange(__STR_LIT_360), new SingleValueRange(__STR_LIT_361), new SingleValueRange(__STR_LIT_362), new SingleValueRange(__STR_LIT_363), new SingleValueRange(__STR_LIT_364), new SingleValueRange(__STR_LIT_365)}), EF16.get(context)).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_87).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_88).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_89).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_90).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_91).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_367));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_92).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_368));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_93).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_369));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_94).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_95).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_371));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_96).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_372));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_97).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_373));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_98).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_99).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_375));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_100).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_376));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_101).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_102).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_103).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_104).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_379));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_105).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_380));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_106).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_107).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_381));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_108).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_109).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_110).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_111).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_112).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_113).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_114).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_115).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_116).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_117).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_387));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_118).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_119).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_120).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_388));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_121).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_389));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_123).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_390));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_124).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_390));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_125).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_391));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_126).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_391));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_127).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_392));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_128).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_393));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_129).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_394));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_130).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_131).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_132).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_396));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_133).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_397));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_134).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_398));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_135).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_136).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_137).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_138).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_139).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_399));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_140).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_400));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_141).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_401));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_142).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_401));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_143).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_402));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_144).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_403));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_145).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_403));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_146).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_146).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_147).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_404));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_148).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_405));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_149).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_406));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_150).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_407));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_151).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_408));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_152).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_409));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_153).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_410));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_154).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_155).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_411));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_156).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_157).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_158).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_412));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_159).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_413));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_160).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_414));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_161).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_415));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_162).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_416));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_163).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_414));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_164).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_165).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_166).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_167).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_168).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_169).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_418));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_170).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_400));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_171).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_172).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_173).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_373));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_174).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_421));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_175).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_176).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_177).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_376));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_178).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_422));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_179).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_423));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_180).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_424));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_181).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_182).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_183).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_184).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_185).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_186).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_187).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_393));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_188).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_425));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_189).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_426));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_190).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_425));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_191).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_394));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_192).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_192).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_193).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_427));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_194).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_195).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_4));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_196).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_122));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_197).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_428));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_198).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_429));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_199).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_430));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_200).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_201).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_202).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_432));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_203).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_204).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_205).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_206).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_207).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_208).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_209).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_210).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_211).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_434));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_212).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_435));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_213).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_214).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_215).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_216).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_217).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_85));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_218).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_219).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_220).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_436));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_221).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_436));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_222).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_437));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_223).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_224).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_225).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_361));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_226).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_364));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_227).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_361));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_228).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_439));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_229).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_230).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_359));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_231).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_363));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_232).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_360));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_233).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_363));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_234).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_235).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_236).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_362));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_237).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_238).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_440));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_239).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_240).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_241).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_441));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_242).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_442));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_243).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_442));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_244).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_443));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_245).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_246).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_247).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_248).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_249).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_445));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_250).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_446));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_251).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_252).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_447));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_253).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_448));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_254).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_449));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_255).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_450));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_256).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_451));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_257).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_258).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_259).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_260).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_261).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_262).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_263).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_416));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_264).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_452));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_265).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_452));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_266).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_453));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_267).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_454));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_268).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_455));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_269).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_270).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_271).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_272).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_273).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_457));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_274).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_275).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_458));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_276).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_277).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_278).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_459));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_279).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_460));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_280).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_461));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_281).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_282).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_283).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_284).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_463));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_285).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_464));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_286).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_465));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_287).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_466));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_288).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_467));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_289).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_290).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_468));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_291).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_469));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_292).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_470));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_293).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_471));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_294).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_472));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_295).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_473));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_296).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_474));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_297).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_473));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_298).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_475));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_299).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_476));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_300).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_477));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_301).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_478));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_302).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_478));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_303).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_479));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_304).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_305).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_481));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_306).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_482));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_307).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_483));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_308).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_479));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_309).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_484));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_310).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_485));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_311).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_357));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_312).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_486));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_313).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_487));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_314).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_315).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_316).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_317).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_318).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_488));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_319).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_489));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_320).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_489));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_321).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_490));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_322).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_491));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_323).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_492));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_324).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_493));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_325).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_326).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_494));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_327).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_495));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_328).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_356));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_329).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_356));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_330).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_496));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_331).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_497));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_332).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_498));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_333).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_499));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_334).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_500));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_335).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_501));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_336).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_502));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_337).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_503));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_338).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_504));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_339).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_340).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_341).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_342).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_506));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_343).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_344).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_507));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_345).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_346).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_347).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_348).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_509));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_349).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_510));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_350).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_511));
+ }
+ if(OperatorLib.eq(context, EF16.get(context), __STR_LIT_351).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_512));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_352).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_476));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_355).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_513));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_356).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_514));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_357).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_515));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_516).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_353).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_517));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_354).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_518));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_358).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_118));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_359).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_519));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_360).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_520));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_361).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_521));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_362).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_522));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_363).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_523));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_364).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_524));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_365).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_525));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_526).asBoolean() && OperatorLib.eq(context, EF16.get(context), __STR_LIT_122).asBoolean()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(__STR_LIT_527));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_033");
+ fehler_MA_033(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_033", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_033");
+ this.fehler_MA_033(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_033");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_033(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_033");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF16;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_033");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_036(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_036");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF29.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF44.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF44.set(context, ValueFactory.instance().valueFor(EF29.get(context)));
+ context.getLogger().trace("Fehler angeschrieben: MA_036");
+ fehler_MA_036(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_036", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_036");
+ this.fehler_MA_036(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_036");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_036(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_036");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF44;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_036");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_039(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_039");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF26.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF41.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF41.set(context, ValueFactory.instance().valueFor(EF26.get(context)));
+ context.getLogger().trace("Fehler angeschrieben: MA_039");
+ fehler_MA_039(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_039", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_039");
+ this.fehler_MA_039(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_039");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_039(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_039");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF41;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_039");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_042(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_042");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean()).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF41.get(context), __STR_LIT_21).asBoolean())
+ {
+ EF41.set(context, ValueFactory.instance().valueFor(EF26.get(context)));
+ }
+ if(OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF42.set(context, ValueFactory.instance().valueFor(EF27.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_042");
+ fehler_MA_042(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_042", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_042");
+ this.fehler_MA_042(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_042");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_042(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_042");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_042" : "#MA_042");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_045(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_045");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF28.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF43.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF43.set(context, ValueFactory.instance().valueFor(EF28.get(context)));
+ context.getLogger().trace("Fehler angeschrieben: MA_045");
+ fehler_MA_045(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_045", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_045");
+ this.fehler_MA_045(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_045");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_045(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_045");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF43;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_045");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_048(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_048");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_048");
+ fehler_MA_048(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_048", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_048");
+ this.fehler_MA_048(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_048");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_048(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_048");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_048" : "#MA_048");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_051(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_051");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF34.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF34.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_051");
+ fehler_MA_051(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_051", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_051");
+ this.fehler_MA_051(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_051");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_051(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_051");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_051" : "#MA_051");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_054(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_054");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_054");
+ fehler_MA_054(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_054", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_054");
+ this.fehler_MA_054(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_054");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_054(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_054");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_054" : "#MA_054");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_057(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_057");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ if(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_057");
+ fehler_MA_057(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_057", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_057");
+ this.fehler_MA_057(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_057");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_057(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_057");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_057" : "#MA_057");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_060(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_060");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF49.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF49.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ if(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_060");
+ fehler_MA_060(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_060", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_060");
+ this.fehler_MA_060(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_060");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_060(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_060");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_060" : "#MA_060");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_063(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_063");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_063");
+ fehler_MA_063(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_063", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_063");
+ this.fehler_MA_063(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_063");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_063(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_063");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_063" : "#MA_063");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_066(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_066");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF26.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF28.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF29.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF30.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF26.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF26.set(context, ValueFactory.instance().valueFor(EF41.get(context)));
+ }
+ if(OperatorLib.eq(context, EF28.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF28.set(context, ValueFactory.instance().valueFor(EF43.get(context)));
+ }
+ if(OperatorLib.eq(context, EF29.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF29.set(context, ValueFactory.instance().valueFor(EF44.get(context)));
+ }
+ if(OperatorLib.eq(context, EF30.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(EF45.get(context)));
+ }
+ if(OperatorLib.eq(context, EF31.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(EF46.get(context)));
+ }
+ if(OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(EF47.get(context)));
+ }
+ if(OperatorLib.eq(context, EF34.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.eq(context, EF36.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ if(OperatorLib.ne(context, EF41.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF41.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF43.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF43.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF44.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF44.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF45.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF45.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF46.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_066");
+ fehler_MA_066(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_066", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_066");
+ this.fehler_MA_066(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_066");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_066(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_066");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_066" : "#MA_066");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_069(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_069");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF30.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF30.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF20.get(context))))));
+ }
+ if(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF30.get(context))), __NUM_LIT_2).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(FunctionLib.KONKATENIEREN(context, vf.valueFor(__STR_LIT_29), vf.valueFor(EF30.get(context)))));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_069");
+ fehler_MA_069(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_069", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_069");
+ this.fehler_MA_069(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_069");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_069(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_069");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF30;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_069");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_072(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_072");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF45.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF45.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ EF45.set(context, ValueFactory.instance().valueFor(EF19.get(context)));
+ context.getLogger().trace("Fehler angeschrieben: MA_072");
+ fehler_MA_072(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_072", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_072");
+ this.fehler_MA_072(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_072");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_072(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_072");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF45;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_072");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_075(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_075");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF60.set(context, ValueFactory.instance().valueFor(EF61.get(context)));
+ }
+ if(OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF61.set(context, ValueFactory.instance().valueFor(EF62.get(context)));
+ }
+ if(OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF62.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_075");
+ fehler_MA_075(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_075", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_075");
+ this.fehler_MA_075(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_075");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_075(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_075");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_075" : "#MA_075");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_078(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_078");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF61.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF61.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF61.set(context, ValueFactory.instance().valueFor(EF62.get(context)));
+ }
+ if(OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF62.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_078");
+ fehler_MA_078(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_078", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_078");
+ this.fehler_MA_078(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_078");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_078(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_078");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_078" : "#MA_078");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_081(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_081");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF60.set(context, ValueFactory.instance().valueFor(EF61.get(context)));
+ }
+ if(OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF61.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_081");
+ fehler_MA_081(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_081", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_081");
+ this.fehler_MA_081(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_081");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_081(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_081");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_081" : "#MA_081");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_084(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_084");
+ try
+ {
+ if(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF56.get(context), __STR_LIT_23).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF56.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF56.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF59.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF59.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF60.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF61.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF62.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_084");
+ fehler_MA_084(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_084", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_084");
+ this.fehler_MA_084(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_084");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_084(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_084");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_084" : "#MA_084");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_087(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_087");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF66.get(context), EF4.get(context)).asBoolean() && OperatorLib.ne(context, EF64.get(context), __STR_LIT_12).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF74.get(context), EF4.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ EF64.set(context, ValueFactory.instance().valueFor(__STR_LIT_12));
+ context.getLogger().trace("Fehler angeschrieben: MA_087");
+ fehler_MA_087(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_087", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_087");
+ this.fehler_MA_087(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_087");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_087(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_087");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_087" : "#MA_087");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_090(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_090");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF64.get(context), __STR_LIT_20).asBoolean() && OperatorLib.ne(context, EF66.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF66.get(context), __STR_LIT_23).asBoolean()).asBoolean() && OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF74.get(context), __STR_LIT_23).asBoolean()).asBoolean() && OperatorLib.ne(context, EF74.get(context), EF4.get(context)).asBoolean()).asBoolean())
+ {
+ EF64.set(context, ValueFactory.instance().valueFor(__STR_LIT_20));
+ context.getLogger().trace("Fehler angeschrieben: MA_090");
+ fehler_MA_090(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_090", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_090");
+ this.fehler_MA_090(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_090");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_090(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_090");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF64;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_090");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_093(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_093");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF71.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF72.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_093");
+ fehler_MA_093(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_093", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_093");
+ this.fehler_MA_093(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_093");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_093(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_093");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_093" : "#MA_093");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_096(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_096");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF71.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF71.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF72.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_096");
+ fehler_MA_096(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_096", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_096");
+ this.fehler_MA_096(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_096");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_096(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_096");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_096" : "#MA_096");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_099(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_099");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF71.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_099");
+ fehler_MA_099(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_099", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_099");
+ this.fehler_MA_099(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_099");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_099(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_099");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_099" : "#MA_099");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_102(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_102");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF79.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF80.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_102");
+ fehler_MA_102(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_102", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_102");
+ this.fehler_MA_102(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_102");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_102(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_102");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_102" : "#MA_102");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_105(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_105");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF79.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF79.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF80.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_105");
+ fehler_MA_105(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_105", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_105");
+ this.fehler_MA_105(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_105");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_105(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_105");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_105" : "#MA_105");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_108(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_108");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF79.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_108");
+ fehler_MA_108(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_108", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_108");
+ this.fehler_MA_108(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_108");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_108(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_108");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_108" : "#MA_108");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_111(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_111");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF66.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF66.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF74.get(context)));
+ }
+ if(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF77.get(context)));
+ }
+ if(OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF78.get(context)));
+ }
+ if(OperatorLib.eq(context, EF71.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF79.get(context)));
+ }
+ if(OperatorLib.eq(context, EF72.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF80.get(context)));
+ }
+ if(OperatorLib.ne(context, EF74.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_111");
+ fehler_MA_111(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_111", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_111");
+ this.fehler_MA_111(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_111");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_111(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_111");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_111" : "#MA_111");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_114(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_114");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_12).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_114");
+ fehler_MA_114(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_114", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_114");
+ this.fehler_MA_114(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_114");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_114(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_114");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_114" : "#MA_114");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_115(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_115");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_12).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_115");
+ fehler_MA_115(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_115", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_115");
+ this.fehler_MA_115(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_115");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_115(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_115");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_115" : "#MA_115");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_116(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_116");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_20).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF74.get(context), EF4.get(context)).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), EF46.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF46.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF47.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF47.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF49.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF51.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_116");
+ fehler_MA_116(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_116", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_116");
+ this.fehler_MA_116(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_116");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_116(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_116");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_116" : "#MA_116");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_117(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_117");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_20).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF77.get(context), EF46.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF46.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF47.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF47.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF49.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF51.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_117");
+ fehler_MA_117(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_117", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_117");
+ this.fehler_MA_117(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_117");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_117(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_117");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_117" : "#MA_117");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_118(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_118");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_2).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF74.get(context), EF4.get(context)).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), EF46.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF46.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF47.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF47.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF49.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF51.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_118");
+ fehler_MA_118(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_118", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_118");
+ this.fehler_MA_118(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_118");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_118(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_118");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_118" : "#MA_118");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_119(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_119");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_2).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), EF46.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF46.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF47.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF47.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF49.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF51.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_119");
+ fehler_MA_119(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_119", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_119");
+ this.fehler_MA_119(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_119");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_119(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_119");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_119" : "#MA_119");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_120(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_120");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_21).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.ne(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF59.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF74.get(context), EF56.get(context)).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(EF56.get(context)));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), EF59.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF59.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF60.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF60.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF61.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF61.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF62.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF62.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_120");
+ fehler_MA_120(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_120", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_120");
+ this.fehler_MA_120(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_120");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_120(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_120");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_120" : "#MA_120");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_121(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_121");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_21).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF59.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF74.get(context), __STR_LIT_22).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_22));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), EF59.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF59.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF60.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF60.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF61.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF61.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF62.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF62.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_121");
+ fehler_MA_121(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_121", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_121");
+ this.fehler_MA_121(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_121");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_121(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_121");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_121" : "#MA_121");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_122(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_122");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_21).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF59.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF74.get(context), __STR_LIT_22).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_22));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), EF46.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF46.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF47.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF47.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF49.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF51.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_122");
+ fehler_MA_122(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_122", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_122");
+ this.fehler_MA_122(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_122");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_122(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_122");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_122" : "#MA_122");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_123(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_123");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_21).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.ne(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF59.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.ne(context, EF69.get(context), EF31.get(context)).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(OperatorLib.ne(context, EF70.get(context), EF32.get(context)).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(OperatorLib.ne(context, EF71.get(context), EF34.get(context)).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(OperatorLib.ne(context, EF72.get(context), EF36.get(context)).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ if(OperatorLib.ne(context, EF74.get(context), EF56.get(context)).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(EF56.get(context)));
+ }
+ if(OperatorLib.ne(context, EF77.get(context), EF46.get(context)).asBoolean())
+ {
+ EF77.set(context, ValueFactory.instance().valueFor(EF46.get(context)));
+ }
+ if(OperatorLib.ne(context, EF78.get(context), EF47.get(context)).asBoolean())
+ {
+ EF78.set(context, ValueFactory.instance().valueFor(EF47.get(context)));
+ }
+ if(OperatorLib.ne(context, EF79.get(context), EF49.get(context)).asBoolean())
+ {
+ EF79.set(context, ValueFactory.instance().valueFor(EF49.get(context)));
+ }
+ if(OperatorLib.ne(context, EF80.get(context), EF51.get(context)).asBoolean())
+ {
+ EF80.set(context, ValueFactory.instance().valueFor(EF51.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_123");
+ fehler_MA_123(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_123", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_123");
+ this.fehler_MA_123(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_123");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_123(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_123");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_123" : "#MA_123");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_124(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_124");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_48), new SingleValueRange(__STR_LIT_49), new SingleValueRange(__STR_LIT_50), new SingleValueRange(__STR_LIT_51), new SingleValueRange(__STR_LIT_52), new SingleValueRange(__STR_LIT_53), new SingleValueRange(__STR_LIT_54), new SingleValueRange(__STR_LIT_55), new SingleValueRange(__STR_LIT_56), new SingleValueRange(__STR_LIT_57), new SingleValueRange(__STR_LIT_58), new SingleValueRange(__STR_LIT_59), new SingleValueRange(__STR_LIT_60), new SingleValueRange(__STR_LIT_61), new SingleValueRange(__STR_LIT_62), new SingleValueRange(__STR_LIT_63), new SingleValueRange(__STR_LIT_64), new SingleValueRange(__STR_LIT_65), new SingleValueRange(__STR_LIT_66), new SingleValueRange(__STR_LIT_67), new SingleValueRange(__STR_LIT_68), new SingleValueRange(__STR_LIT_69), new SingleValueRange(__STR_LIT_70), new SingleValueRange(__STR_LIT_71), new SingleValueRange(__STR_LIT_72), new SingleValueRange(__STR_LIT_73), new SingleValueRange(__STR_LIT_74), new SingleValueRange(__STR_LIT_75), new SingleValueRange(__STR_LIT_76), new SingleValueRange(__STR_LIT_77), new SingleValueRange(__STR_LIT_78), new SingleValueRange(__STR_LIT_79), new SingleValueRange(__STR_LIT_80), new SingleValueRange(__STR_LIT_81)}), EF66.get(context)).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_82), new SingleValueRange(__STR_LIT_83)}), EF66.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_85), new SingleValueRange(__STR_LIT_86)}), EF66.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_22));
+ context.getLogger().trace("Fehler angeschrieben: MA_124");
+ fehler_MA_124(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_124", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_124");
+ this.fehler_MA_124(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_124");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_124(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_124");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF66;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_124");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_127(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_127");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_48), new SingleValueRange(__STR_LIT_49), new SingleValueRange(__STR_LIT_50), new SingleValueRange(__STR_LIT_51), new SingleValueRange(__STR_LIT_52), new SingleValueRange(__STR_LIT_53), new SingleValueRange(__STR_LIT_54), new SingleValueRange(__STR_LIT_55), new SingleValueRange(__STR_LIT_56), new SingleValueRange(__STR_LIT_57), new SingleValueRange(__STR_LIT_58), new SingleValueRange(__STR_LIT_59), new SingleValueRange(__STR_LIT_60), new SingleValueRange(__STR_LIT_61), new SingleValueRange(__STR_LIT_62), new SingleValueRange(__STR_LIT_63), new SingleValueRange(__STR_LIT_64), new SingleValueRange(__STR_LIT_65), new SingleValueRange(__STR_LIT_66), new SingleValueRange(__STR_LIT_67), new SingleValueRange(__STR_LIT_68), new SingleValueRange(__STR_LIT_69), new SingleValueRange(__STR_LIT_70), new SingleValueRange(__STR_LIT_71), new SingleValueRange(__STR_LIT_72), new SingleValueRange(__STR_LIT_73), new SingleValueRange(__STR_LIT_74), new SingleValueRange(__STR_LIT_75), new SingleValueRange(__STR_LIT_76), new SingleValueRange(__STR_LIT_77), new SingleValueRange(__STR_LIT_78), new SingleValueRange(__STR_LIT_79), new SingleValueRange(__STR_LIT_80), new SingleValueRange(__STR_LIT_81)}), EF74.get(context)).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_82), new SingleValueRange(__STR_LIT_83)}), EF74.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_85), new SingleValueRange(__STR_LIT_86)}), EF74.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_22));
+ context.getLogger().trace("Fehler angeschrieben: MA_127");
+ fehler_MA_127(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_127", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_127");
+ this.fehler_MA_127(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_127");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_127(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_127");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF74;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_127");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_129(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_129");
+ try
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_87), new SingleValueRange(__STR_LIT_88), new SingleValueRange(__STR_LIT_89), new SingleValueRange(__STR_LIT_90), new SingleValueRange(__STR_LIT_91), new SingleValueRange(__STR_LIT_92), new SingleValueRange(__STR_LIT_93), new SingleValueRange(__STR_LIT_94), new SingleValueRange(__STR_LIT_95), new SingleValueRange(__STR_LIT_96), new SingleValueRange(__STR_LIT_97), new SingleValueRange(__STR_LIT_98), new SingleValueRange(__STR_LIT_99), new SingleValueRange(__STR_LIT_100), new SingleValueRange(__STR_LIT_101), new SingleValueRange(__STR_LIT_102), new SingleValueRange(__STR_LIT_103), new SingleValueRange(__STR_LIT_104), new SingleValueRange(__STR_LIT_105), new SingleValueRange(__STR_LIT_106), new SingleValueRange(__STR_LIT_107), new SingleValueRange(__STR_LIT_108), new SingleValueRange(__STR_LIT_109), new SingleValueRange(__STR_LIT_110), new SingleValueRange(__STR_LIT_111), new SingleValueRange(__STR_LIT_112), new SingleValueRange(__STR_LIT_113), new SingleValueRange(__STR_LIT_114), new SingleValueRange(__STR_LIT_115), new SingleValueRange(__STR_LIT_116), new SingleValueRange(__STR_LIT_117), new SingleValueRange(__STR_LIT_118), new SingleValueRange(__STR_LIT_119), new SingleValueRange(__STR_LIT_120), new SingleValueRange(__STR_LIT_121), new SingleValueRange(__STR_LIT_122), new SingleValueRange(__STR_LIT_123), new SingleValueRange(__STR_LIT_124), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_127), new SingleValueRange(__STR_LIT_128), new SingleValueRange(__STR_LIT_129), new SingleValueRange(__STR_LIT_130), new SingleValueRange(__STR_LIT_131), new SingleValueRange(__STR_LIT_132), new SingleValueRange(__STR_LIT_133), new SingleValueRange(__STR_LIT_134), new SingleValueRange(__STR_LIT_135), new SingleValueRange(__STR_LIT_136), new SingleValueRange(__STR_LIT_137), new SingleValueRange(__STR_LIT_138), new SingleValueRange(__STR_LIT_139), new SingleValueRange(__STR_LIT_140), new SingleValueRange(__STR_LIT_141), new SingleValueRange(__STR_LIT_142), new SingleValueRange(__STR_LIT_143), new SingleValueRange(__STR_LIT_144), new SingleValueRange(__STR_LIT_145), new SingleValueRange(__STR_LIT_146), new SingleValueRange(__STR_LIT_146), new SingleValueRange(__STR_LIT_147), new SingleValueRange(__STR_LIT_148), new SingleValueRange(__STR_LIT_149), new SingleValueRange(__STR_LIT_150), new SingleValueRange(__STR_LIT_151), new SingleValueRange(__STR_LIT_152), new SingleValueRange(__STR_LIT_153), new SingleValueRange(__STR_LIT_154), new SingleValueRange(__STR_LIT_155), new SingleValueRange(__STR_LIT_156), new SingleValueRange(__STR_LIT_157), new SingleValueRange(__STR_LIT_158), new SingleValueRange(__STR_LIT_159), new SingleValueRange(__STR_LIT_160), new SingleValueRange(__STR_LIT_161), new SingleValueRange(__STR_LIT_162), new SingleValueRange(__STR_LIT_163), new SingleValueRange(__STR_LIT_164), new SingleValueRange(__STR_LIT_165), new SingleValueRange(__STR_LIT_166), new SingleValueRange(__STR_LIT_167), new SingleValueRange(__STR_LIT_168), new SingleValueRange(__STR_LIT_169), new SingleValueRange(__STR_LIT_170), new SingleValueRange(__STR_LIT_171), new SingleValueRange(__STR_LIT_172), new SingleValueRange(__STR_LIT_173), new SingleValueRange(__STR_LIT_174), new SingleValueRange(__STR_LIT_175), new SingleValueRange(__STR_LIT_176), new SingleValueRange(__STR_LIT_177), new SingleValueRange(__STR_LIT_178), new SingleValueRange(__STR_LIT_179), new SingleValueRange(__STR_LIT_180), new SingleValueRange(__STR_LIT_181), new SingleValueRange(__STR_LIT_182), new SingleValueRange(__STR_LIT_183), new SingleValueRange(__STR_LIT_184), new SingleValueRange(__STR_LIT_185), new SingleValueRange(__STR_LIT_186), new SingleValueRange(__STR_LIT_187), new SingleValueRange(__STR_LIT_188), new SingleValueRange(__STR_LIT_189), new SingleValueRange(__STR_LIT_190), new SingleValueRange(__STR_LIT_191), new SingleValueRange(__STR_LIT_192), new SingleValueRange(__STR_LIT_192), new SingleValueRange(__STR_LIT_193), new SingleValueRange(__STR_LIT_194), new SingleValueRange(__STR_LIT_195), new SingleValueRange(__STR_LIT_196), new SingleValueRange(__STR_LIT_197), new SingleValueRange(__STR_LIT_198), new SingleValueRange(__STR_LIT_199), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_202), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_208), new SingleValueRange(__STR_LIT_209), new SingleValueRange(__STR_LIT_210), new SingleValueRange(__STR_LIT_211), new SingleValueRange(__STR_LIT_212), new SingleValueRange(__STR_LIT_213), new SingleValueRange(__STR_LIT_214), new SingleValueRange(__STR_LIT_215), new SingleValueRange(__STR_LIT_216), new SingleValueRange(__STR_LIT_217), new SingleValueRange(__STR_LIT_218), new SingleValueRange(__STR_LIT_219), new SingleValueRange(__STR_LIT_220), new SingleValueRange(__STR_LIT_221), new SingleValueRange(__STR_LIT_222), new SingleValueRange(__STR_LIT_223), new SingleValueRange(__STR_LIT_224), new SingleValueRange(__STR_LIT_225), new SingleValueRange(__STR_LIT_226), new SingleValueRange(__STR_LIT_227), new SingleValueRange(__STR_LIT_228), new SingleValueRange(__STR_LIT_229), new SingleValueRange(__STR_LIT_230), new SingleValueRange(__STR_LIT_231), new SingleValueRange(__STR_LIT_232), new SingleValueRange(__STR_LIT_233), new SingleValueRange(__STR_LIT_234), new SingleValueRange(__STR_LIT_235), new SingleValueRange(__STR_LIT_236), new SingleValueRange(__STR_LIT_237), new SingleValueRange(__STR_LIT_238), new SingleValueRange(__STR_LIT_239), new SingleValueRange(__STR_LIT_240), new SingleValueRange(__STR_LIT_241), new SingleValueRange(__STR_LIT_242), new SingleValueRange(__STR_LIT_243), new SingleValueRange(__STR_LIT_244), new SingleValueRange(__STR_LIT_245), new SingleValueRange(__STR_LIT_246), new SingleValueRange(__STR_LIT_247), new SingleValueRange(__STR_LIT_248), new SingleValueRange(__STR_LIT_249), new SingleValueRange(__STR_LIT_250), new SingleValueRange(__STR_LIT_251), new SingleValueRange(__STR_LIT_252), new SingleValueRange(__STR_LIT_253), new SingleValueRange(__STR_LIT_254), new SingleValueRange(__STR_LIT_255), new SingleValueRange(__STR_LIT_256), new SingleValueRange(__STR_LIT_257), new SingleValueRange(__STR_LIT_258), new SingleValueRange(__STR_LIT_259), new SingleValueRange(__STR_LIT_260), new SingleValueRange(__STR_LIT_261), new SingleValueRange(__STR_LIT_262), new SingleValueRange(__STR_LIT_263), new SingleValueRange(__STR_LIT_264), new SingleValueRange(__STR_LIT_265), new SingleValueRange(__STR_LIT_266), new SingleValueRange(__STR_LIT_267), new SingleValueRange(__STR_LIT_268), new SingleValueRange(__STR_LIT_269), new SingleValueRange(__STR_LIT_270), new SingleValueRange(__STR_LIT_271), new SingleValueRange(__STR_LIT_272), new SingleValueRange(__STR_LIT_273), new SingleValueRange(__STR_LIT_274), new SingleValueRange(__STR_LIT_275), new SingleValueRange(__STR_LIT_276), new SingleValueRange(__STR_LIT_277), new SingleValueRange(__STR_LIT_278), new SingleValueRange(__STR_LIT_279), new SingleValueRange(__STR_LIT_280), new SingleValueRange(__STR_LIT_281), new SingleValueRange(__STR_LIT_282), new SingleValueRange(__STR_LIT_283), new SingleValueRange(__STR_LIT_284), new SingleValueRange(__STR_LIT_285), new SingleValueRange(__STR_LIT_286), new SingleValueRange(__STR_LIT_287), new SingleValueRange(__STR_LIT_288), new SingleValueRange(__STR_LIT_68), new SingleValueRange(__STR_LIT_289), new SingleValueRange(__STR_LIT_290), new SingleValueRange(__STR_LIT_291), new SingleValueRange(__STR_LIT_292), new SingleValueRange(__STR_LIT_293), new SingleValueRange(__STR_LIT_294), new SingleValueRange(__STR_LIT_295), new SingleValueRange(__STR_LIT_296), new SingleValueRange(__STR_LIT_297), new SingleValueRange(__STR_LIT_298), new SingleValueRange(__STR_LIT_299), new SingleValueRange(__STR_LIT_300), new SingleValueRange(__STR_LIT_301), new SingleValueRange(__STR_LIT_302), new SingleValueRange(__STR_LIT_303), new SingleValueRange(__STR_LIT_304), new SingleValueRange(__STR_LIT_305), new SingleValueRange(__STR_LIT_306), new SingleValueRange(__STR_LIT_307), new SingleValueRange(__STR_LIT_308), new SingleValueRange(__STR_LIT_309), new SingleValueRange(__STR_LIT_310), new SingleValueRange(__STR_LIT_311), new SingleValueRange(__STR_LIT_312), new SingleValueRange(__STR_LIT_313), new SingleValueRange(__STR_LIT_314), new SingleValueRange(__STR_LIT_315), new SingleValueRange(__STR_LIT_316), new SingleValueRange(__STR_LIT_317), new SingleValueRange(__STR_LIT_318), new SingleValueRange(__STR_LIT_319), new SingleValueRange(__STR_LIT_320), new SingleValueRange(__STR_LIT_321), new SingleValueRange(__STR_LIT_322), new SingleValueRange(__STR_LIT_323), new SingleValueRange(__STR_LIT_324), new SingleValueRange(__STR_LIT_325), new SingleValueRange(__STR_LIT_326), new SingleValueRange(__STR_LIT_327), new SingleValueRange(__STR_LIT_328), new SingleValueRange(__STR_LIT_329), new SingleValueRange(__STR_LIT_330), new SingleValueRange(__STR_LIT_331), new SingleValueRange(__STR_LIT_332), new SingleValueRange(__STR_LIT_333), new SingleValueRange(__STR_LIT_334), new SingleValueRange(__STR_LIT_335), new SingleValueRange(__STR_LIT_336), new SingleValueRange(__STR_LIT_337), new SingleValueRange(__STR_LIT_338), new SingleValueRange(__STR_LIT_339), new SingleValueRange(__STR_LIT_340), new SingleValueRange(__STR_LIT_341), new SingleValueRange(__STR_LIT_342), new SingleValueRange(__STR_LIT_343), new SingleValueRange(__STR_LIT_344), new SingleValueRange(__STR_LIT_345), new SingleValueRange(__STR_LIT_346), new SingleValueRange(__STR_LIT_347), new SingleValueRange(__STR_LIT_348), new SingleValueRange(__STR_LIT_349), new SingleValueRange(__STR_LIT_350), new SingleValueRange(__STR_LIT_351), new SingleValueRange(__STR_LIT_219), new SingleValueRange(__STR_LIT_214), new SingleValueRange(__STR_LIT_215), new SingleValueRange(__STR_LIT_234), new SingleValueRange(__STR_LIT_241), new SingleValueRange(__STR_LIT_242), new SingleValueRange(__STR_LIT_352), new SingleValueRange(__STR_LIT_353), new SingleValueRange(__STR_LIT_354), new SingleValueRange(__STR_LIT_355), new SingleValueRange(__STR_LIT_356), new SingleValueRange(__STR_LIT_357), new SingleValueRange(__STR_LIT_353), new SingleValueRange(__STR_LIT_358), new SingleValueRange(__STR_LIT_359), new SingleValueRange(__STR_LIT_360), new SingleValueRange(__STR_LIT_361), new SingleValueRange(__STR_LIT_362), new SingleValueRange(__STR_LIT_363), new SingleValueRange(__STR_LIT_364), new SingleValueRange(__STR_LIT_365)}), EF66.get(context)).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_87).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_88).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_89).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_90).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_91).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_367));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_92).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_368));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_93).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_369));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_94).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_95).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_371));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_96).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_372));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_97).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_373));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_98).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_99).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_375));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_100).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_376));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_101).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_102).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_103).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_104).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_379));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_105).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_380));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_106).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_107).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_381));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_108).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_109).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_110).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_111).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_112).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_113).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_114).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_115).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_116).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_117).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_387));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_118).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_119).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_120).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_388));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_121).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_389));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_123).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_390));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_124).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_390));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_125).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_391));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_126).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_391));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_127).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_392));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_128).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_393));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_129).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_394));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_130).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_131).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_132).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_396));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_133).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_397));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_134).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_398));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_135).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_136).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_137).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_138).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_139).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_399));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_140).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_400));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_141).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_401));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_142).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_401));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_143).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_402));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_144).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_403));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_145).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_403));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_146).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_146).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_147).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_404));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_148).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_405));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_149).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_406));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_150).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_407));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_151).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_408));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_152).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_409));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_153).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_410));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_154).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_155).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_411));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_156).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_157).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_158).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_412));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_159).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_413));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_160).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_414));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_161).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_415));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_162).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_416));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_163).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_414));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_164).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_165).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_166).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_167).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_168).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_169).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_418));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_170).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_400));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_171).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_172).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_173).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_373));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_174).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_421));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_175).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_176).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_177).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_376));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_178).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_422));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_179).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_423));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_180).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_424));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_181).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_182).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_183).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_184).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_185).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_186).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_187).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_393));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_188).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_425));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_189).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_426));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_190).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_425));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_191).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_394));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_192).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_192).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_193).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_427));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_194).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_195).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_4));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_196).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_122));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_197).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_428));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_198).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_429));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_199).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_430));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_200).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_201).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_202).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_432));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_203).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_204).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_205).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_206).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_207).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_208).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_209).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_210).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_211).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_434));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_212).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_435));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_213).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_214).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_215).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_216).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_217).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_85));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_218).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_219).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_220).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_436));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_221).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_436));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_222).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_437));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_223).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_224).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_225).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_361));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_226).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_364));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_227).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_361));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_228).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_439));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_229).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_230).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_359));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_231).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_363));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_232).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_360));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_233).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_363));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_234).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_235).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_236).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_362));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_237).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_238).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_440));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_239).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_240).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_241).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_441));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_242).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_442));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_243).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_442));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_244).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_443));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_245).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_246).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_247).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_248).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_249).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_445));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_250).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_446));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_251).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_252).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_447));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_253).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_448));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_254).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_449));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_255).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_450));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_256).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_451));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_257).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_258).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_259).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_260).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_261).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_262).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_263).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_416));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_264).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_452));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_265).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_452));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_266).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_453));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_267).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_454));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_268).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_455));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_269).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_270).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_271).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_272).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_273).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_457));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_274).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_275).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_458));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_276).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_277).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_278).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_459));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_279).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_460));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_280).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_461));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_281).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_282).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_283).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_284).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_463));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_285).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_464));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_286).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_465));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_287).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_466));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_288).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_467));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_289).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_290).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_468));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_291).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_469));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_292).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_470));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_293).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_471));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_294).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_472));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_295).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_473));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_296).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_474));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_297).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_473));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_298).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_475));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_299).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_476));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_300).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_477));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_301).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_478));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_302).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_478));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_303).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_479));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_304).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_305).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_481));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_306).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_482));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_307).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_483));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_308).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_479));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_309).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_484));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_310).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_485));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_311).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_357));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_312).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_486));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_313).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_487));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_314).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_315).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_316).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_317).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_318).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_488));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_319).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_489));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_320).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_489));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_321).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_490));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_322).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_491));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_323).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_492));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_324).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_493));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_325).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_326).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_494));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_327).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_495));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_328).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_356));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_329).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_356));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_330).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_496));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_331).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_497));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_332).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_498));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_333).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_499));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_334).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_500));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_335).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_501));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_336).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_502));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_337).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_503));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_338).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_504));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_339).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_340).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_341).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_342).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_506));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_343).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_344).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_507));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_345).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_346).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_347).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_348).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_509));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_349).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_510));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_350).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_511));
+ }
+ if(OperatorLib.eq(context, EF66.get(context), __STR_LIT_351).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_512));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_352).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_476));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_355).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_513));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_356).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_514));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_357).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_515));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_516).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_353).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_517));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_354).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_518));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_358).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_118));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_359).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_519));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_360).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_520));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_361).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_521));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_362).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_522));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_363).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_523));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_364).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_524));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_365).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_525));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_526).asBoolean() && OperatorLib.eq(context, EF66.get(context), __STR_LIT_122).asBoolean()).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(__STR_LIT_527));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_129");
+ fehler_MA_129(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_129", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_129");
+ this.fehler_MA_129(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_129");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_129(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_129");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF66;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_129");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_132(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_132");
+ try
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_87), new SingleValueRange(__STR_LIT_88), new SingleValueRange(__STR_LIT_89), new SingleValueRange(__STR_LIT_90), new SingleValueRange(__STR_LIT_91), new SingleValueRange(__STR_LIT_92), new SingleValueRange(__STR_LIT_93), new SingleValueRange(__STR_LIT_94), new SingleValueRange(__STR_LIT_95), new SingleValueRange(__STR_LIT_96), new SingleValueRange(__STR_LIT_97), new SingleValueRange(__STR_LIT_98), new SingleValueRange(__STR_LIT_99), new SingleValueRange(__STR_LIT_100), new SingleValueRange(__STR_LIT_101), new SingleValueRange(__STR_LIT_102), new SingleValueRange(__STR_LIT_103), new SingleValueRange(__STR_LIT_104), new SingleValueRange(__STR_LIT_105), new SingleValueRange(__STR_LIT_106), new SingleValueRange(__STR_LIT_107), new SingleValueRange(__STR_LIT_108), new SingleValueRange(__STR_LIT_109), new SingleValueRange(__STR_LIT_110), new SingleValueRange(__STR_LIT_111), new SingleValueRange(__STR_LIT_112), new SingleValueRange(__STR_LIT_113), new SingleValueRange(__STR_LIT_114), new SingleValueRange(__STR_LIT_115), new SingleValueRange(__STR_LIT_116), new SingleValueRange(__STR_LIT_117), new SingleValueRange(__STR_LIT_118), new SingleValueRange(__STR_LIT_119), new SingleValueRange(__STR_LIT_120), new SingleValueRange(__STR_LIT_121), new SingleValueRange(__STR_LIT_122), new SingleValueRange(__STR_LIT_123), new SingleValueRange(__STR_LIT_124), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_127), new SingleValueRange(__STR_LIT_128), new SingleValueRange(__STR_LIT_129), new SingleValueRange(__STR_LIT_130), new SingleValueRange(__STR_LIT_131), new SingleValueRange(__STR_LIT_132), new SingleValueRange(__STR_LIT_133), new SingleValueRange(__STR_LIT_134), new SingleValueRange(__STR_LIT_135), new SingleValueRange(__STR_LIT_136), new SingleValueRange(__STR_LIT_137), new SingleValueRange(__STR_LIT_138), new SingleValueRange(__STR_LIT_139), new SingleValueRange(__STR_LIT_140), new SingleValueRange(__STR_LIT_141), new SingleValueRange(__STR_LIT_142), new SingleValueRange(__STR_LIT_143), new SingleValueRange(__STR_LIT_144), new SingleValueRange(__STR_LIT_145), new SingleValueRange(__STR_LIT_146), new SingleValueRange(__STR_LIT_146), new SingleValueRange(__STR_LIT_147), new SingleValueRange(__STR_LIT_148), new SingleValueRange(__STR_LIT_149), new SingleValueRange(__STR_LIT_150), new SingleValueRange(__STR_LIT_151), new SingleValueRange(__STR_LIT_152), new SingleValueRange(__STR_LIT_153), new SingleValueRange(__STR_LIT_154), new SingleValueRange(__STR_LIT_155), new SingleValueRange(__STR_LIT_156), new SingleValueRange(__STR_LIT_157), new SingleValueRange(__STR_LIT_158), new SingleValueRange(__STR_LIT_159), new SingleValueRange(__STR_LIT_160), new SingleValueRange(__STR_LIT_161), new SingleValueRange(__STR_LIT_162), new SingleValueRange(__STR_LIT_163), new SingleValueRange(__STR_LIT_164), new SingleValueRange(__STR_LIT_165), new SingleValueRange(__STR_LIT_166), new SingleValueRange(__STR_LIT_167), new SingleValueRange(__STR_LIT_168), new SingleValueRange(__STR_LIT_169), new SingleValueRange(__STR_LIT_170), new SingleValueRange(__STR_LIT_171), new SingleValueRange(__STR_LIT_172), new SingleValueRange(__STR_LIT_173), new SingleValueRange(__STR_LIT_174), new SingleValueRange(__STR_LIT_175), new SingleValueRange(__STR_LIT_176), new SingleValueRange(__STR_LIT_177), new SingleValueRange(__STR_LIT_178), new SingleValueRange(__STR_LIT_179), new SingleValueRange(__STR_LIT_180), new SingleValueRange(__STR_LIT_181), new SingleValueRange(__STR_LIT_182), new SingleValueRange(__STR_LIT_183), new SingleValueRange(__STR_LIT_184), new SingleValueRange(__STR_LIT_185), new SingleValueRange(__STR_LIT_186), new SingleValueRange(__STR_LIT_187), new SingleValueRange(__STR_LIT_188), new SingleValueRange(__STR_LIT_189), new SingleValueRange(__STR_LIT_190), new SingleValueRange(__STR_LIT_191), new SingleValueRange(__STR_LIT_192), new SingleValueRange(__STR_LIT_192), new SingleValueRange(__STR_LIT_193), new SingleValueRange(__STR_LIT_194), new SingleValueRange(__STR_LIT_195), new SingleValueRange(__STR_LIT_196), new SingleValueRange(__STR_LIT_197), new SingleValueRange(__STR_LIT_198), new SingleValueRange(__STR_LIT_199), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_202), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_208), new SingleValueRange(__STR_LIT_209), new SingleValueRange(__STR_LIT_210), new SingleValueRange(__STR_LIT_211), new SingleValueRange(__STR_LIT_212), new SingleValueRange(__STR_LIT_213), new SingleValueRange(__STR_LIT_214), new SingleValueRange(__STR_LIT_215), new SingleValueRange(__STR_LIT_216), new SingleValueRange(__STR_LIT_217), new SingleValueRange(__STR_LIT_218), new SingleValueRange(__STR_LIT_219), new SingleValueRange(__STR_LIT_220), new SingleValueRange(__STR_LIT_221), new SingleValueRange(__STR_LIT_222), new SingleValueRange(__STR_LIT_223), new SingleValueRange(__STR_LIT_224), new SingleValueRange(__STR_LIT_225), new SingleValueRange(__STR_LIT_226), new SingleValueRange(__STR_LIT_227), new SingleValueRange(__STR_LIT_228), new SingleValueRange(__STR_LIT_229), new SingleValueRange(__STR_LIT_230), new SingleValueRange(__STR_LIT_231), new SingleValueRange(__STR_LIT_232), new SingleValueRange(__STR_LIT_233), new SingleValueRange(__STR_LIT_234), new SingleValueRange(__STR_LIT_235), new SingleValueRange(__STR_LIT_236), new SingleValueRange(__STR_LIT_237), new SingleValueRange(__STR_LIT_238), new SingleValueRange(__STR_LIT_239), new SingleValueRange(__STR_LIT_240), new SingleValueRange(__STR_LIT_241), new SingleValueRange(__STR_LIT_242), new SingleValueRange(__STR_LIT_243), new SingleValueRange(__STR_LIT_244), new SingleValueRange(__STR_LIT_245), new SingleValueRange(__STR_LIT_246), new SingleValueRange(__STR_LIT_247), new SingleValueRange(__STR_LIT_248), new SingleValueRange(__STR_LIT_249), new SingleValueRange(__STR_LIT_250), new SingleValueRange(__STR_LIT_251), new SingleValueRange(__STR_LIT_252), new SingleValueRange(__STR_LIT_253), new SingleValueRange(__STR_LIT_254), new SingleValueRange(__STR_LIT_255), new SingleValueRange(__STR_LIT_256), new SingleValueRange(__STR_LIT_257), new SingleValueRange(__STR_LIT_258), new SingleValueRange(__STR_LIT_259), new SingleValueRange(__STR_LIT_260), new SingleValueRange(__STR_LIT_261), new SingleValueRange(__STR_LIT_262), new SingleValueRange(__STR_LIT_263), new SingleValueRange(__STR_LIT_264), new SingleValueRange(__STR_LIT_265), new SingleValueRange(__STR_LIT_266), new SingleValueRange(__STR_LIT_267), new SingleValueRange(__STR_LIT_268), new SingleValueRange(__STR_LIT_269), new SingleValueRange(__STR_LIT_270), new SingleValueRange(__STR_LIT_271), new SingleValueRange(__STR_LIT_272), new SingleValueRange(__STR_LIT_273), new SingleValueRange(__STR_LIT_274), new SingleValueRange(__STR_LIT_275), new SingleValueRange(__STR_LIT_276), new SingleValueRange(__STR_LIT_277), new SingleValueRange(__STR_LIT_278), new SingleValueRange(__STR_LIT_279), new SingleValueRange(__STR_LIT_280), new SingleValueRange(__STR_LIT_281), new SingleValueRange(__STR_LIT_282), new SingleValueRange(__STR_LIT_283), new SingleValueRange(__STR_LIT_284), new SingleValueRange(__STR_LIT_285), new SingleValueRange(__STR_LIT_286), new SingleValueRange(__STR_LIT_287), new SingleValueRange(__STR_LIT_288), new SingleValueRange(__STR_LIT_68), new SingleValueRange(__STR_LIT_289), new SingleValueRange(__STR_LIT_290), new SingleValueRange(__STR_LIT_291), new SingleValueRange(__STR_LIT_292), new SingleValueRange(__STR_LIT_293), new SingleValueRange(__STR_LIT_294), new SingleValueRange(__STR_LIT_295), new SingleValueRange(__STR_LIT_296), new SingleValueRange(__STR_LIT_297), new SingleValueRange(__STR_LIT_298), new SingleValueRange(__STR_LIT_299), new SingleValueRange(__STR_LIT_300), new SingleValueRange(__STR_LIT_301), new SingleValueRange(__STR_LIT_302), new SingleValueRange(__STR_LIT_303), new SingleValueRange(__STR_LIT_304), new SingleValueRange(__STR_LIT_305), new SingleValueRange(__STR_LIT_306), new SingleValueRange(__STR_LIT_307), new SingleValueRange(__STR_LIT_308), new SingleValueRange(__STR_LIT_309), new SingleValueRange(__STR_LIT_310), new SingleValueRange(__STR_LIT_311), new SingleValueRange(__STR_LIT_312), new SingleValueRange(__STR_LIT_313), new SingleValueRange(__STR_LIT_314), new SingleValueRange(__STR_LIT_315), new SingleValueRange(__STR_LIT_316), new SingleValueRange(__STR_LIT_317), new SingleValueRange(__STR_LIT_318), new SingleValueRange(__STR_LIT_319), new SingleValueRange(__STR_LIT_320), new SingleValueRange(__STR_LIT_321), new SingleValueRange(__STR_LIT_322), new SingleValueRange(__STR_LIT_323), new SingleValueRange(__STR_LIT_324), new SingleValueRange(__STR_LIT_325), new SingleValueRange(__STR_LIT_326), new SingleValueRange(__STR_LIT_327), new SingleValueRange(__STR_LIT_328), new SingleValueRange(__STR_LIT_329), new SingleValueRange(__STR_LIT_330), new SingleValueRange(__STR_LIT_331), new SingleValueRange(__STR_LIT_332), new SingleValueRange(__STR_LIT_333), new SingleValueRange(__STR_LIT_334), new SingleValueRange(__STR_LIT_335), new SingleValueRange(__STR_LIT_336), new SingleValueRange(__STR_LIT_337), new SingleValueRange(__STR_LIT_338), new SingleValueRange(__STR_LIT_339), new SingleValueRange(__STR_LIT_340), new SingleValueRange(__STR_LIT_341), new SingleValueRange(__STR_LIT_342), new SingleValueRange(__STR_LIT_343), new SingleValueRange(__STR_LIT_344), new SingleValueRange(__STR_LIT_345), new SingleValueRange(__STR_LIT_346), new SingleValueRange(__STR_LIT_347), new SingleValueRange(__STR_LIT_348), new SingleValueRange(__STR_LIT_349), new SingleValueRange(__STR_LIT_350), new SingleValueRange(__STR_LIT_351), new SingleValueRange(__STR_LIT_219), new SingleValueRange(__STR_LIT_214), new SingleValueRange(__STR_LIT_215), new SingleValueRange(__STR_LIT_234), new SingleValueRange(__STR_LIT_241), new SingleValueRange(__STR_LIT_242), new SingleValueRange(__STR_LIT_352), new SingleValueRange(__STR_LIT_353), new SingleValueRange(__STR_LIT_354), new SingleValueRange(__STR_LIT_355), new SingleValueRange(__STR_LIT_356), new SingleValueRange(__STR_LIT_357), new SingleValueRange(__STR_LIT_353), new SingleValueRange(__STR_LIT_358), new SingleValueRange(__STR_LIT_359), new SingleValueRange(__STR_LIT_360), new SingleValueRange(__STR_LIT_361), new SingleValueRange(__STR_LIT_362), new SingleValueRange(__STR_LIT_363), new SingleValueRange(__STR_LIT_364), new SingleValueRange(__STR_LIT_365)}), EF74.get(context)).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_87).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_88).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_89).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_90).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_91).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_367));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_92).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_368));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_93).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_369));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_94).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_95).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_371));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_96).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_372));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_97).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_373));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_98).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_99).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_375));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_100).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_376));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_101).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_102).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_103).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_104).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_379));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_105).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_380));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_106).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_107).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_381));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_108).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_109).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_110).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_111).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_112).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_113).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_114).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_115).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_116).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_117).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_387));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_118).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_119).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_120).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_388));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_121).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_389));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_123).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_390));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_124).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_390));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_125).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_391));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_126).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_391));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_127).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_392));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_128).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_393));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_129).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_394));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_130).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_131).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_132).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_396));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_133).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_397));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_134).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_398));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_135).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_136).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_137).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_138).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_139).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_399));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_140).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_400));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_141).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_401));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_142).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_401));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_143).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_402));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_144).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_403));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_145).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_403));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_146).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_146).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_147).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_404));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_148).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_405));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_149).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_406));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_150).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_407));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_151).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_408));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_152).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_409));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_153).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_410));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_154).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_155).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_411));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_156).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_157).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_383));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_158).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_412));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_159).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_413));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_160).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_414));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_161).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_415));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_162).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_416));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_163).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_414));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_164).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_165).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_166).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_167).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_168).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_417));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_169).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_418));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_170).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_400));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_171).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_172).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_173).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_373));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_174).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_421));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_175).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_176).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_374));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_177).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_376));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_178).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_422));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_179).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_423));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_180).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_424));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_181).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_182).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_183).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_184).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_378));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_185).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_377));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_186).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_382));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_187).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_393));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_188).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_425));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_189).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_426));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_190).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_425));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_191).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_394));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_192).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_192).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_395));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_193).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_427));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_194).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_385));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_195).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_4));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_196).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_122));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_197).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_428));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_198).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_429));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_199).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_430));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_200).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_201).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_202).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_432));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_203).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_204).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_205).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_206).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_207).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_431));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_208).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_209).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_210).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_433));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_211).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_434));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_212).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_435));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_213).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_214).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_215).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_216).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_217).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_85));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_218).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_219).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_220).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_436));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_221).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_436));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_222).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_437));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_223).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_224).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_384));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_225).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_361));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_226).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_364));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_227).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_361));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_228).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_439));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_229).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_230).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_359));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_231).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_363));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_232).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_360));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_233).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_363));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_234).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_235).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_236).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_362));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_237).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_365));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_238).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_440));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_239).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_438));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_240).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_358));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_241).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_441));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_242).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_442));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_243).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_442));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_244).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_443));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_245).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_246).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_247).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_248).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_444));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_249).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_445));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_250).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_446));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_251).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_366));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_252).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_447));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_253).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_448));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_254).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_449));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_255).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_450));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_256).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_451));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_257).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_258).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_259).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_260).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_419));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_261).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_262).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_420));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_263).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_416));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_264).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_452));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_265).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_452));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_266).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_453));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_267).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_454));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_268).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_455));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_269).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_270).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_271).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_272).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_273).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_457));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_274).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_275).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_458));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_276).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_277).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_278).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_459));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_279).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_460));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_280).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_461));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_281).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_282).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_456));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_283).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_284).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_463));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_285).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_464));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_286).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_465));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_287).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_466));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_288).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_467));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_289).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_290).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_468));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_291).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_469));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_292).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_470));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_293).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_471));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_294).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_472));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_295).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_473));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_296).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_474));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_297).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_473));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_298).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_475));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_299).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_476));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_300).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_477));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_301).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_478));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_302).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_478));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_303).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_479));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_304).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_305).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_481));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_306).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_482));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_307).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_483));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_308).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_479));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_309).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_484));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_310).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_485));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_311).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_357));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_312).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_486));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_313).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_487));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_314).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_462));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_315).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_316).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_317).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_480));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_318).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_488));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_319).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_489));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_320).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_489));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_321).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_490));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_322).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_491));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_323).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_492));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_324).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_493));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_325).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_386));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_326).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_494));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_327).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_495));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_328).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_356));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_329).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_356));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_330).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_496));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_331).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_497));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_332).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_498));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_333).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_499));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_334).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_500));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_335).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_501));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_336).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_502));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_337).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_503));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_338).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_504));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_339).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_340).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_370));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_341).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_342).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_506));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_343).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_505));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_344).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_507));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_345).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_346).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_347).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_508));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_348).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_509));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_349).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_510));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_350).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_511));
+ }
+ if(OperatorLib.eq(context, EF74.get(context), __STR_LIT_351).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_512));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_352).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_476));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_355).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_513));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_356).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_514));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_357).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_515));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_516).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_353).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_517));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_354).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_518));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_358).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_118));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_359).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_519));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_360).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_520));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_361).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_521));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_362).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_522));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_363).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_523));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_364).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_524));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_365).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_525));
+ }
+ if(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_526).asBoolean() && OperatorLib.eq(context, EF74.get(context), __STR_LIT_122).asBoolean()).asBoolean())
+ {
+ EF74.set(context, ValueFactory.instance().valueFor(__STR_LIT_527));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_132");
+ fehler_MA_132(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_132", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_132");
+ this.fehler_MA_132(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_132");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_132(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_132");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF74;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_132");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_135(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_135");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF82.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF83.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF83.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF85.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.gt(context, EF86.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF82.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF82.set(context, ValueFactory.instance().valueFor(EF85.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF83.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF83.get(context), __STR_LIT_17).asBoolean()).asBoolean())
+ {
+ EF83.set(context, ValueFactory.instance().valueFor(EF86.get(context)));
+ }
+ if(OperatorLib.ne(context, EF85.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF85.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF86.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF86.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_135");
+ fehler_MA_135(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_135", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_135");
+ this.fehler_MA_135(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_135");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_135(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_135");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_135" : "#MA_135");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_138(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_138");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_138");
+ fehler_MA_138(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_138", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_138");
+ this.fehler_MA_138(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_138");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_138(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_138");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_138" : "#MA_138");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_141(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_141");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF92.set(context, ValueFactory.instance().valueFor(EF93.get(context)));
+ }
+ if(OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(EF94.get(context)));
+ }
+ if(OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF94.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_141");
+ fehler_MA_141(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_141", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_141");
+ this.fehler_MA_141(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_141");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_141(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_141");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_141" : "#MA_141");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_144(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_144");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF93.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF93.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(EF94.get(context)));
+ }
+ if(OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF94.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_144");
+ fehler_MA_144(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_144", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_144");
+ this.fehler_MA_144(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_144");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_144(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_144");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_144" : "#MA_144");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_147(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_147");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF92.set(context, ValueFactory.instance().valueFor(EF93.get(context)));
+ }
+ if(OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_147");
+ fehler_MA_147(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_147", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_147");
+ this.fehler_MA_147(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_147");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_147(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_147");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_147" : "#MA_147");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_150(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_150");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF101.set(context, ValueFactory.instance().valueFor(EF102.get(context)));
+ }
+ if(OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(EF103.get(context)));
+ }
+ if(OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF103.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_150");
+ fehler_MA_150(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_150", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_150");
+ this.fehler_MA_150(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_150");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_150(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_150");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_150" : "#MA_150");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_153(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_153");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF102.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF102.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(EF103.get(context)));
+ }
+ if(OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF103.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_153");
+ fehler_MA_153(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_153", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_153");
+ this.fehler_MA_153(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_153");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_153(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_153");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_153" : "#MA_153");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_154(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_154");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF135.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF151.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(vf.valueFor(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_154");
+ fehler_MA_154(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_154", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_154");
+ this.fehler_MA_154(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_154");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_154(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_154");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_154" : "#MA_154");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_156(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_156");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF101.set(context, ValueFactory.instance().valueFor(EF102.get(context)));
+ }
+ if(OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_156");
+ fehler_MA_156(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_156", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_156");
+ this.fehler_MA_156(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_156");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_156(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_156");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_156" : "#MA_156");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_159(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_159");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF94.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF96.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF103.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF105.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_159");
+ fehler_MA_159(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_159", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_159");
+ this.fehler_MA_159(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_159");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_159(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_159");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_159" : "#MA_159");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_160(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_160");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF91.set(context, ValueFactory.instance().valueFor(EF100.get(context)));
+ }
+ if(OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF92.set(context, ValueFactory.instance().valueFor(EF101.get(context)));
+ }
+ if(OperatorLib.eq(context, EF93.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(EF102.get(context)));
+ }
+ if(OperatorLib.eq(context, EF94.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF94.set(context, ValueFactory.instance().valueFor(EF103.get(context)));
+ }
+ if(OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF96.set(context, ValueFactory.instance().valueFor(EF105.get(context)));
+ }
+ if(OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF97.set(context, ValueFactory.instance().valueFor(EF106.get(context)));
+ }
+ if(OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF98.set(context, ValueFactory.instance().valueFor(EF107.get(context)));
+ }
+ if(OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(EF108.get(context)));
+ }
+ if(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF100.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF101.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF103.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF105.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF106.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF107.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_160");
+ fehler_MA_160(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_160", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_160");
+ this.fehler_MA_160(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_160");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_160(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_160");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_160" : "#MA_160");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_161(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_161");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF92.set(context, ValueFactory.instance().valueFor(__STR_LIT_543));
+ }
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF101.set(context, ValueFactory.instance().valueFor(__STR_LIT_543));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_161");
+ fehler_MA_161(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_161", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_161");
+ this.fehler_MA_161(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_161");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_161(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_161");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_161" : "#MA_161");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_162(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_162");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, EF98.get(context), __STR_LIT_20).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_162");
+ fehler_MA_162(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_162", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_162");
+ this.fehler_MA_162(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_162");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_162(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_162");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF99;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_162");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_165(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_165");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF107.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, EF107.get(context), __STR_LIT_20).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_165");
+ fehler_MA_165(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_165", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_165");
+ this.fehler_MA_165(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_165");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_165(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_165");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF108;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_165");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_168(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_168");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_24).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_168");
+ fehler_MA_168(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_168", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_168");
+ this.fehler_MA_168(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_168");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_168(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_168");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_168" : "#MA_168");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_169(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_169");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46)}), EF1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF134.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF135.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF134.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.eq(context, EF135.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF134.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, EF134.get(context), __STR_LIT_20).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_169");
+ fehler_MA_169(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_169", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_169");
+ this.fehler_MA_169(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_169");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_169(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_169");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF135;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_169");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_170(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_170");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46)}), EF1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF150.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF151.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF150.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.eq(context, EF151.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF150.get(context)).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, EF150.get(context), __STR_LIT_20).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_170");
+ fehler_MA_170(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_170", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_170");
+ this.fehler_MA_170(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_170");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_170(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_170");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF151;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_170");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_171(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_171");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF91.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF92.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF3.get(context), EF97.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF96.get(context), __STR_LIT_544).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF91.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), EF92.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF3.get(context), EF97.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF96.get(context), __STR_LIT_544).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF91.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF92.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_1), EF97.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF96.get(context)).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF3.get(context), EF97.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544)}), EF96.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF91.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), EF92.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_1), EF97.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF96.get(context)).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF3.get(context), EF97.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544)}), EF96.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF91.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF92.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF93.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF94.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF96.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF97.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF98.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_171");
+ fehler_MA_171(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_171", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_171");
+ this.fehler_MA_171(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_171");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_171(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_171");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_171" : "#MA_171");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_172(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_172");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF101.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF3.get(context), EF106.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF105.get(context), __STR_LIT_544).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), EF101.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF3.get(context), EF106.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF105.get(context), __STR_LIT_544).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF101.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_1), EF106.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF105.get(context)).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF3.get(context), EF106.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544)}), EF105.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_546).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), EF101.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_1), EF106.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF105.get(context)).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF3.get(context), EF106.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544)}), EF105.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF100.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF101.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF102.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF103.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF105.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF106.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF107.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_172");
+ fehler_MA_172(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_172", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_172");
+ this.fehler_MA_172(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_172");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_172(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_172");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_172" : "#MA_172");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_174(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_174");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF127.set(context, ValueFactory.instance().valueFor(EF128.get(context)));
+ }
+ if(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(EF129.get(context)));
+ }
+ if(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_174");
+ fehler_MA_174(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_174", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_174");
+ this.fehler_MA_174(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_174");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_174(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_174");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_174" : "#MA_174");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_177(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_177");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF128.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(EF129.get(context)));
+ }
+ if(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_177");
+ fehler_MA_177(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_177", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_177");
+ this.fehler_MA_177(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_177");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_177(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_177");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_177" : "#MA_177");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_180(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_180");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF127.set(context, ValueFactory.instance().valueFor(EF128.get(context)));
+ }
+ if(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_180");
+ fehler_MA_180(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_180", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_180");
+ this.fehler_MA_180(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_180");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_180(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_180");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_180" : "#MA_180");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_183(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_183");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF143.set(context, ValueFactory.instance().valueFor(EF144.get(context)));
+ }
+ if(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(EF145.get(context)));
+ }
+ if(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_183");
+ fehler_MA_183(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_183", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_183");
+ this.fehler_MA_183(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_183");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_183(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_183");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_183" : "#MA_183");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_186(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_186");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF144.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(EF145.get(context)));
+ }
+ if(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_186");
+ fehler_MA_186(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_186", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_186");
+ this.fehler_MA_186(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_186");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_186(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_186");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_186" : "#MA_186");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_189(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_189");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF143.set(context, ValueFactory.instance().valueFor(EF144.get(context)));
+ }
+ if(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_189");
+ fehler_MA_189(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_189", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_189");
+ this.fehler_MA_189(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_189");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_189(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_189");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_189" : "#MA_189");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_192(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_192");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF120.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF121.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF122.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF123.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF124.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF125.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF126.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF136.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF120.set(context, ValueFactory.instance().valueFor(EF136.get(context)));
+ }
+ if(OperatorLib.ne(context, EF137.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF121.set(context, ValueFactory.instance().valueFor(EF137.get(context)));
+ }
+ if(OperatorLib.ne(context, EF138.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF122.set(context, ValueFactory.instance().valueFor(EF138.get(context)));
+ }
+ if(OperatorLib.ne(context, EF139.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF123.set(context, ValueFactory.instance().valueFor(EF139.get(context)));
+ }
+ if(OperatorLib.ne(context, EF140.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF124.set(context, ValueFactory.instance().valueFor(EF140.get(context)));
+ }
+ if(OperatorLib.ne(context, EF141.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF125.set(context, ValueFactory.instance().valueFor(EF141.get(context)));
+ }
+ if(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF126.set(context, ValueFactory.instance().valueFor(EF142.get(context)));
+ }
+ if(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF127.set(context, ValueFactory.instance().valueFor(EF143.get(context)));
+ }
+ if(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF128.set(context, ValueFactory.instance().valueFor(EF144.get(context)));
+ }
+ if(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF129.set(context, ValueFactory.instance().valueFor(EF145.get(context)));
+ }
+ if(OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF132.set(context, ValueFactory.instance().valueFor(EF148.get(context)));
+ }
+ if(OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF133.set(context, ValueFactory.instance().valueFor(EF149.get(context)));
+ }
+ if(OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF134.set(context, ValueFactory.instance().valueFor(EF150.get(context)));
+ }
+ if(OperatorLib.ne(context, EF151.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(EF151.get(context)));
+ }
+ if(OperatorLib.ne(context, EF136.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF136.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF137.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF137.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF138.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF138.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF139.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF139.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF140.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF140.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF141.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF141.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF142.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF143.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF144.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF145.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF148.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF149.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF150.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF151.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_192");
+ fehler_MA_192(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_192", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_192");
+ this.fehler_MA_192(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_192");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_192(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_192");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_192" : "#MA_192");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_201(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_201");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF127.get(context), __STR_LIT_548).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF152.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_24), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_11, __NUM_LIT_12, __NUM_LIT_13)}), EF152.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_14, __NUM_LIT_15, __NUM_LIT_16)}), EF152.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_17, __NUM_LIT_18, __NUM_LIT_19)}), EF152.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_20, __NUM_LIT_21, __NUM_LIT_22)}), EF152.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_23, __NUM_LIT_24, __NUM_LIT_25)}), EF152.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_26)}), EF152.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_201");
+ fehler_MA_201(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_201", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_201");
+ this.fehler_MA_201(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_201");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_201(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_201");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_201" : "#MA_201");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_204(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_204");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(vf.valueFor(OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF69.set(context, ValueFactory.instance().valueFor(EF31.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF70.set(context, ValueFactory.instance().valueFor(EF32.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF71.set(context, ValueFactory.instance().valueFor(EF34.get(context)));
+ }
+ if(vf.valueFor(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF72.set(context, ValueFactory.instance().valueFor(EF36.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_204");
+ fehler_MA_204(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_204", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_204");
+ this.fehler_MA_204(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_204");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_204(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_204");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_204" : "#MA_204");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_207(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_207");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF64.get(context), __STR_LIT_12).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF64.get(context), __STR_LIT_12).asBoolean())
+ {
+ EF64.set(context, ValueFactory.instance().valueFor(__STR_LIT_12));
+ }
+ if(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean())
+ {
+ EF66.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_207");
+ fehler_MA_207(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_207", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_207");
+ this.fehler_MA_207(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_207");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_207(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_207");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_207" : "#MA_207");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_210(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_210");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF28.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF29.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF28.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF28.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF29.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF29.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF32.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF34.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF36.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_210");
+ fehler_MA_210(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_210", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_210");
+ this.fehler_MA_210(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_210");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_210(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_210");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_210" : "#MA_210");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_213(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_213");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF43.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF44.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF43.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF43.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF44.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF44.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF46.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF47.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF49.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ if(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF51.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_213");
+ fehler_MA_213(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_213", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_213");
+ this.fehler_MA_213(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_213");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_213(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_213");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_213" : "#MA_213");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_216(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_216");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF17.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF30.get(context))).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF30.get(context)))).asBoolean()).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), OperatorLib.minus(context, OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF2.get(context)))), OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF17.get(context)))))).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF19.set(context, ValueFactory.instance().valueFor(OperatorLib.minus(context, OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF2.get(context)))), OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF17.get(context)))))));
+ }
+ if(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF19.get(context))), __NUM_LIT_2).asBoolean())
+ {
+ EF19.set(context, ValueFactory.instance().valueFor(FunctionLib.KONKATENIEREN(context, vf.valueFor(__STR_LIT_29), vf.valueFor(EF19.get(context)))));
+ }
+ if(OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(OperatorLib.minus(context, OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF2.get(context)))), OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF17.get(context)))))));
+ }
+ if(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF30.get(context))), __NUM_LIT_2).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(FunctionLib.KONKATENIEREN(context, vf.valueFor(__STR_LIT_29), vf.valueFor(EF30.get(context)))));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_216");
+ fehler_MA_216(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_216", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_216");
+ this.fehler_MA_216(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_216");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_216(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_216");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_216" : "#MA_216");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_217(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_217");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.gt(context, EF30.get(context), __STR_LIT_41).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF17.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF30.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF19.get(context), EF30.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF19.get(context), OperatorLib.minus(context, OperatorLib.plus(context, OperatorLib.mult(context, EF3.get(context), __NUM_LIT_2), EF2.get(context)), OperatorLib.plus(context, OperatorLib.mult(context, EF18.get(context), __NUM_LIT_2), EF17.get(context)))).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF19.set(context, ValueFactory.instance().valueFor(OperatorLib.minus(context, OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF2.get(context)))), OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF17.get(context)))))));
+ }
+ if(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF19.get(context))), __NUM_LIT_2).asBoolean())
+ {
+ EF19.set(context, ValueFactory.instance().valueFor(FunctionLib.KONKATENIEREN(context, vf.valueFor(__STR_LIT_29), vf.valueFor(EF19.get(context)))));
+ }
+ if(OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF30.get(context))), __NUM_LIT_1)));
+ }
+ if(OperatorLib.lt(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF30.get(context))), __NUM_LIT_2).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(FunctionLib.KONKATENIEREN(context, vf.valueFor(__STR_LIT_29), vf.valueFor(EF30.get(context)))));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_217");
+ fehler_MA_217(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_217", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_217");
+ this.fehler_MA_217(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_217");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_217(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_217");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_217" : "#MA_217");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_219(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_219");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && OperatorLib.gt(context, EF9.get(context), __STR_LIT_15).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_549), new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_550), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_551), new SingleValueRange(__STR_LIT_36)}), EF110.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF4.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_27, __NUM_LIT_28, __NUM_LIT_29)}), prg_fkt_MA_219(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.gt(context, EF9.get(context), __STR_LIT_15).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_549), new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_550), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_551), new SingleValueRange(__STR_LIT_36), new SingleValueRange(__STR_LIT_38), new SingleValueRange(__STR_LIT_39), new SingleValueRange(__STR_LIT_40)}), EF110.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF4.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_27, __NUM_LIT_28, __NUM_LIT_29)}), prg_fkt_MA_219(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ EF110.set(context, ValueFactory.instance().valueFor(__STR_LIT_36));
+ context.getLogger().trace("Fehler angeschrieben: MA_219");
+ fehler_MA_219(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_219", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_219");
+ this.fehler_MA_219(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_219");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_219(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_219");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF110;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_219");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_220(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_220");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && OperatorLib.gt(context, EF9.get(context), __STR_LIT_15).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_549), new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_550), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_551), new SingleValueRange(__STR_LIT_36)}), EF110.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF4.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_27, __NUM_LIT_28, __NUM_LIT_29)}), prg_fkt_MA_219(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && OperatorLib.gt(context, EF9.get(context), __STR_LIT_15).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_549), new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_550), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_551), new SingleValueRange(__STR_LIT_36), new SingleValueRange(__STR_LIT_38), new SingleValueRange(__STR_LIT_39), new SingleValueRange(__STR_LIT_40)}), EF110.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF4.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_27, __NUM_LIT_28, __NUM_LIT_29)}), prg_fkt_MA_219(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ EF110.set(context, ValueFactory.instance().valueFor(__STR_LIT_34));
+ context.getLogger().trace("Fehler angeschrieben: MA_220");
+ fehler_MA_220(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_220", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_220");
+ this.fehler_MA_220(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_220");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_220(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_220");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF110;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_220");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_222(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_222");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF19.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF20.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF21.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF22.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF25.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF30.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF45.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF83.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF86.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF19.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF19.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF20.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF20.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF21.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF21.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.eq(context, EF22.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF22.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.eq(context, EF25.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF25.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF30.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF30.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF45.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF45.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF83.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF83.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF86.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF86.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_222");
+ fehler_MA_222(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_222", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_222");
+ this.fehler_MA_222(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_222");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_222(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_222");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_222" : "#MA_222");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_225(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_225");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF121.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF122.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF123.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF124.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF125.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF137.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF138.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF139.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF140.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF141.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF121.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF121.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF122.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF122.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF123.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF123.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.eq(context, EF124.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF124.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.eq(context, EF125.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF125.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.eq(context, EF137.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF137.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF138.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF138.set(context, ValueFactory.instance().valueFor(__STR_LIT_17));
+ }
+ if(OperatorLib.eq(context, EF139.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF139.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.eq(context, EF140.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF140.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ if(OperatorLib.eq(context, EF141.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF141.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_225");
+ fehler_MA_225(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_225", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_225");
+ this.fehler_MA_225(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_225");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_225(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_225");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_225" : "#MA_225");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_228(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_228");
+ try
+ {
+ if(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF99.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_30), new SequenceRange(__NUM_LIT_31, __NUM_LIT_32, __NUM_LIT_33), new SequenceRange(__NUM_LIT_34, __NUM_LIT_35, __NUM_LIT_36), new SequenceRange(__NUM_LIT_37, __NUM_LIT_38, __NUM_LIT_26), new SequenceRange(__NUM_LIT_24, __NUM_LIT_39, __NUM_LIT_40), new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_42), new SequenceRange(__NUM_LIT_43, __NUM_LIT_44, __NUM_LIT_45)}), EF99.get(context)).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_47)}), EF99.get(context)).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_48, __NUM_LIT_49, __NUM_LIT_50)}), EF99.get(context)).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_51, __NUM_LIT_52, __NUM_LIT_53)}), EF99.get(context)).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_54, __NUM_LIT_55, __NUM_LIT_56)}), EF99.get(context)).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_57, __NUM_LIT_58, __NUM_LIT_40)}), EF99.get(context)).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_45)}), EF99.get(context)).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_228");
+ fehler_MA_228(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_228", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_228");
+ this.fehler_MA_228(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_228");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_228(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_228");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF99;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_228");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_229(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_229");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF99.get(context)))).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF99.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean())
+ {
+ EF99.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_229");
+ fehler_MA_229(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_229", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_229");
+ this.fehler_MA_229(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_229");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_229(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_229");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF99;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_229");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_231(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_231");
+ try
+ {
+ if(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF108.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_30), new SequenceRange(__NUM_LIT_31, __NUM_LIT_32, __NUM_LIT_33), new SequenceRange(__NUM_LIT_34, __NUM_LIT_35, __NUM_LIT_36), new SequenceRange(__NUM_LIT_37, __NUM_LIT_38, __NUM_LIT_26), new SequenceRange(__NUM_LIT_24, __NUM_LIT_39, __NUM_LIT_40), new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_42), new SequenceRange(__NUM_LIT_43, __NUM_LIT_44, __NUM_LIT_45)}), EF108.get(context)).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_47)}), EF108.get(context)).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_48, __NUM_LIT_49, __NUM_LIT_50)}), EF108.get(context)).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_51, __NUM_LIT_52, __NUM_LIT_53)}), EF108.get(context)).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_54, __NUM_LIT_55, __NUM_LIT_56)}), EF108.get(context)).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_57, __NUM_LIT_58, __NUM_LIT_40)}), EF108.get(context)).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_45)}), EF108.get(context)).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_231");
+ fehler_MA_231(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_231", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_231");
+ this.fehler_MA_231(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_231");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_231(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_231");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF108;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_231");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_232(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_232");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF108.get(context)))).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF108.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean())
+ {
+ EF108.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_232");
+ fehler_MA_232(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_232", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_232");
+ this.fehler_MA_232(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_232");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_232(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_232");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF108;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_232");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_234(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_234");
+ try
+ {
+ if(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF135.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_30), new SequenceRange(__NUM_LIT_31, __NUM_LIT_32, __NUM_LIT_33), new SequenceRange(__NUM_LIT_34, __NUM_LIT_35, __NUM_LIT_36), new SequenceRange(__NUM_LIT_37, __NUM_LIT_38, __NUM_LIT_26), new SequenceRange(__NUM_LIT_24, __NUM_LIT_39, __NUM_LIT_40), new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_42), new SequenceRange(__NUM_LIT_43, __NUM_LIT_44, __NUM_LIT_45)}), EF135.get(context)).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_47)}), EF135.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_48, __NUM_LIT_49, __NUM_LIT_50)}), EF135.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_51, __NUM_LIT_52, __NUM_LIT_53)}), EF135.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_54, __NUM_LIT_55, __NUM_LIT_56)}), EF135.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_57, __NUM_LIT_58, __NUM_LIT_40)}), EF135.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_45)}), EF135.get(context)).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_234");
+ fehler_MA_234(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_234", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_234");
+ this.fehler_MA_234(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_234");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_234(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_234");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF135;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_234");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_235(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_235");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF135.get(context)))).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF135.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean())
+ {
+ EF135.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_235");
+ fehler_MA_235(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_235", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_235");
+ this.fehler_MA_235(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_235");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_235(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_235");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF135;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_235");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_237(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_237");
+ try
+ {
+ if(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF151.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_30), new SequenceRange(__NUM_LIT_31, __NUM_LIT_32, __NUM_LIT_33), new SequenceRange(__NUM_LIT_34, __NUM_LIT_35, __NUM_LIT_36), new SequenceRange(__NUM_LIT_37, __NUM_LIT_38, __NUM_LIT_26), new SequenceRange(__NUM_LIT_24, __NUM_LIT_39, __NUM_LIT_40), new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_42), new SequenceRange(__NUM_LIT_43, __NUM_LIT_44, __NUM_LIT_45)}), EF151.get(context)).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_47)}), EF151.get(context)).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_48, __NUM_LIT_49, __NUM_LIT_50)}), EF151.get(context)).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_51, __NUM_LIT_52, __NUM_LIT_53)}), EF151.get(context)).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_54, __NUM_LIT_55, __NUM_LIT_56)}), EF151.get(context)).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_57, __NUM_LIT_58, __NUM_LIT_40)}), EF151.get(context)).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_21, __NUM_LIT_41, __NUM_LIT_45)}), EF151.get(context)).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_237");
+ fehler_MA_237(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_237", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_237");
+ this.fehler_MA_237(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_237");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_237(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_237");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF151;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_237");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_238(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_238");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF151.get(context)))).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_29).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_15));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_531));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_532));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_533));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_534));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_535));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_536));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_538));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_540));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(__STR_LIT_542));
+ }
+ if(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), FunctionLib.TEIL(context, vf.valueFor(EF151.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean())
+ {
+ EF151.set(context, ValueFactory.instance().valueFor(InvalidValue.instance()));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_238");
+ fehler_MA_238(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_238", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_238");
+ this.fehler_MA_238(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_238");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_238(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_238");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF151;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_238");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_240(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_240");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF7.get(context), __STR_LIT_20).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF27.get(context), __STR_LIT_18).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF7.get(context), __STR_LIT_20).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF42.get(context), __STR_LIT_18).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF27.get(context), __STR_LIT_18).asBoolean())
+ {
+ EF27.set(context, ValueFactory.instance().valueFor(__STR_LIT_541));
+ }
+ if(OperatorLib.eq(context, EF42.get(context), __STR_LIT_18).asBoolean())
+ {
+ EF42.set(context, ValueFactory.instance().valueFor(__STR_LIT_541));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_240");
+ fehler_MA_240(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_240", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_240");
+ this.fehler_MA_240(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_240");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_240(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_240");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_240" : "#MA_240");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_243(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_243");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF7.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean()).asBoolean() && OperatorLib.eq(context, EF27.get(context), __STR_LIT_537).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF7.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF41.get(context), __STR_LIT_21).asBoolean()).asBoolean() && OperatorLib.eq(context, EF42.get(context), __STR_LIT_537).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF27.get(context), __STR_LIT_537).asBoolean())
+ {
+ EF27.set(context, ValueFactory.instance().valueFor(__STR_LIT_541));
+ }
+ if(OperatorLib.eq(context, EF42.get(context), __STR_LIT_537).asBoolean())
+ {
+ EF42.set(context, ValueFactory.instance().valueFor(__STR_LIT_541));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_243");
+ fehler_MA_243(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_243", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_243");
+ this.fehler_MA_243(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_243");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_243(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_243");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_243" : "#MA_243");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_246(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_246");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.eq(context, EF10U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF10U1.set(context, ValueFactory.instance().valueFor(__STR_LIT_552));
+ context.getLogger().trace("Fehler angeschrieben: MA_246");
+ fehler_MA_246(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_246", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_246");
+ this.fehler_MA_246(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_246");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_246(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_246");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF10U1;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_246");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_248(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_248");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.eq(context, EF10U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF10U2.set(context, ValueFactory.instance().valueFor(__STR_LIT_553));
+ context.getLogger().trace("Fehler angeschrieben: MA_248");
+ fehler_MA_248(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_248", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_248");
+ this.fehler_MA_248(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_248");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_248(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_248");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF10U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_248");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_250(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_250");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.eq(context, EF11U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF11U1.set(context, ValueFactory.instance().valueFor(__STR_LIT_552));
+ context.getLogger().trace("Fehler angeschrieben: MA_250");
+ fehler_MA_250(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_250", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_250");
+ this.fehler_MA_250(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_250");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_250(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_250");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF11U1;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_250");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_252(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_252");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.eq(context, EF11U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ EF11U2.set(context, ValueFactory.instance().valueFor(__STR_LIT_553));
+ context.getLogger().trace("Fehler angeschrieben: MA_252");
+ fehler_MA_252(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_252", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_252");
+ this.fehler_MA_252(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_252");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_252(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_252");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF11U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_252");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_254(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_254");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF12.get(context))).asBoolean()).asBoolean())
+ {
+ EF12.set(context, ValueFactory.instance().valueFor(__STR_LIT_12));
+ context.getLogger().trace("Fehler angeschrieben: MA_254");
+ fehler_MA_254(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_254", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_254");
+ this.fehler_MA_254(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_254");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_254(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_254");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF12;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_254");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_256(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_256");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_VOLLTEILZEIT, new FeldDeskriptorInterface[] {__material_ref_VOLLTEILZEIT.key}, new SatzFilter.FilterBedingung[] {}, context), EF29.get(context))).asBoolean()).asBoolean())
+ {
+ EF29.set(context, ValueFactory.instance().valueFor(__STR_LIT_12));
+ context.getLogger().trace("Fehler angeschrieben: MA_256");
+ fehler_MA_256(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_256", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_256");
+ this.fehler_MA_256(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_256");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_256(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_256");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF29;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_256");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_262(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_262");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF12.get(context), __STR_LIT_2).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_29)}), EF24.get(context))).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_554).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), __STR_LIT_555).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_12).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_556));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_20).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_557));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_558));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_21).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_559));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_560));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_19).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_561));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_537).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_562));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_563));
+ }
+ if(OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_541).asBoolean())
+ {
+ EF31.set(context, ValueFactory.instance().valueFor(__STR_LIT_564));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_262");
+ fehler_MA_262(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_262", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_262");
+ this.fehler_MA_262(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_262");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_262(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_262");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF31;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#MA_262");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_264(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_264");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF16.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.eq(context, EF16.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF16.set(context, ValueFactory.instance().valueFor(EF4.get(context)));
+ }
+ if(OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF17.set(context, ValueFactory.instance().valueFor(EF2.get(context)));
+ }
+ if(OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(EF3.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_264");
+ fehler_MA_264(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_264", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_264");
+ this.fehler_MA_264(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_264");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_264(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_264");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_264" : "#MA_264");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_266(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_266");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_565), new SingleValueRange(__STR_LIT_566), new SingleValueRange(__STR_LIT_567), new SingleValueRange(__STR_LIT_568), new SingleValueRange(__STR_LIT_569), new SingleValueRange(__STR_LIT_570), new SingleValueRange(__STR_LIT_571)}), EF4.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF28.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.ne(context, EF41.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_565), new SingleValueRange(__STR_LIT_566), new SingleValueRange(__STR_LIT_567), new SingleValueRange(__STR_LIT_568), new SingleValueRange(__STR_LIT_569), new SingleValueRange(__STR_LIT_570), new SingleValueRange(__STR_LIT_571)}), EF4.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF43.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF28.get(context)).asBoolean())
+ {
+ EF28.set(context, ValueFactory.instance().valueFor(__STR_LIT_20));
+ }
+ if(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), EF43.get(context)).asBoolean())
+ {
+ EF43.set(context, ValueFactory.instance().valueFor(__STR_LIT_20));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_266");
+ fehler_MA_266(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_266", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_266");
+ this.fehler_MA_266(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_266");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_266(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_266");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_266" : "#MA_266");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_MA_268(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung MA_268");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_4), new SingleValueRange(__NUM_LIT_6), new SequenceRange(__NUM_LIT_59, __NUM_LIT_60, __NUM_LIT_61)}), EF19.get(context)).asBoolean()).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(OperatorLib.div(context, OperatorLib.minus(context, OperatorLib.mult(context, EF3.get(context), __NUM_LIT_2), EF19.get(context)), __NUM_LIT_2)));
+ }
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_4), new SingleValueRange(__NUM_LIT_6), new SequenceRange(__NUM_LIT_59, __NUM_LIT_60, __NUM_LIT_61)}), EF19.get(context)).asBoolean()).asBoolean())
+ {
+ EF17.set(context, ValueFactory.instance().valueFor(__STR_LIT_20));
+ }
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_4), new SingleValueRange(__NUM_LIT_6), new SequenceRange(__NUM_LIT_59, __NUM_LIT_60, __NUM_LIT_61)}), EF19.get(context)).asBoolean()).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(OperatorLib.div(context, OperatorLib.minus(context, OperatorLib.plus(context, OperatorLib.mult(context, EF3.get(context), __NUM_LIT_2), __NUM_LIT_2), EF19.get(context)), __NUM_LIT_2)));
+ }
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_4), new SingleValueRange(__NUM_LIT_6), new SequenceRange(__NUM_LIT_59, __NUM_LIT_60, __NUM_LIT_61)}), EF19.get(context)).asBoolean()).asBoolean())
+ {
+ EF17.set(context, ValueFactory.instance().valueFor(__STR_LIT_12));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_3), new SingleValueRange(__NUM_LIT_5), new SingleValueRange(__NUM_LIT_7), new SequenceRange(__NUM_LIT_62, __NUM_LIT_63, __NUM_LIT_30)}), EF19.get(context)).asBoolean()).asBoolean())
+ {
+ EF18.set(context, ValueFactory.instance().valueFor(OperatorLib.div(context, OperatorLib.minus(context, OperatorLib.plus(context, OperatorLib.mult(context, EF3.get(context), __NUM_LIT_2), __NUM_LIT_1), EF19.get(context)), __NUM_LIT_2)));
+ }
+ if(vf.valueFor(OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_3), new SingleValueRange(__NUM_LIT_5), new SingleValueRange(__NUM_LIT_7), new SequenceRange(__NUM_LIT_62, __NUM_LIT_63, __NUM_LIT_30)}), EF19.get(context)).asBoolean()).asBoolean())
+ {
+ EF17.set(context, ValueFactory.instance().valueFor(EF2.get(context)));
+ }
+ context.getLogger().trace("Fehler angeschrieben: MA_268");
+ fehler_MA_268(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: MA_268", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): MA_268");
+ this.fehler_MA_268(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: MA_268");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_MA_268(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("MA_268");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#MA_268" : "#MA_268");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_001(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_001");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_572), new SingleValueRange(__STR_LIT_573), new SingleValueRange(__STR_LIT_574), new SingleValueRange(__STR_LIT_575), new SingleValueRange(__STR_LIT_576), new SingleValueRange(__STR_LIT_577), new SingleValueRange(__STR_LIT_578), new SingleValueRange(__STR_LIT_579), new SingleValueRange(__STR_LIT_580), new SingleValueRange(__STR_LIT_581), new SingleValueRange(__STR_LIT_582), new SingleValueRange(__STR_LIT_583), new SingleValueRange(__STR_LIT_584), new SingleValueRange(__STR_LIT_585), new SingleValueRange(__STR_LIT_586), new SingleValueRange(__STR_LIT_587), new SingleValueRange(__STR_LIT_588), new SingleValueRange(__STR_LIT_589), new SingleValueRange(__STR_LIT_590), new SingleValueRange(__STR_LIT_591), new SingleValueRange(__STR_LIT_592), new SingleValueRange(__STR_LIT_593), new SingleValueRange(__STR_LIT_594), new SingleValueRange(__STR_LIT_595), new SingleValueRange(__STR_LIT_596), new SingleValueRange(__STR_LIT_597), new SingleValueRange(__STR_LIT_598), new SingleValueRange(__STR_LIT_599), new SingleValueRange(__STR_LIT_600), new SingleValueRange(__STR_LIT_601), new SingleValueRange(__STR_LIT_602), new SingleValueRange(__STR_LIT_603), new SingleValueRange(__STR_LIT_604), new SingleValueRange(__STR_LIT_605), new SingleValueRange(__STR_LIT_606), new SingleValueRange(__STR_LIT_607), new SingleValueRange(__STR_LIT_608), new SingleValueRange(__STR_LIT_609), new SingleValueRange(__STR_LIT_610), new SingleValueRange(__STR_LIT_611), new SingleValueRange(__STR_LIT_612), new SingleValueRange(__STR_LIT_613), new SingleValueRange(__STR_LIT_614), new SingleValueRange(__STR_LIT_424), new SingleValueRange(__STR_LIT_615), new SingleValueRange(__STR_LIT_616), new SingleValueRange(__STR_LIT_617), new SingleValueRange(__STR_LIT_618), new SingleValueRange(__STR_LIT_619), new SingleValueRange(__STR_LIT_620), new SingleValueRange(__STR_LIT_621), new SingleValueRange(__STR_LIT_622), new SingleValueRange(__STR_LIT_623), new SingleValueRange(__STR_LIT_624), new SingleValueRange(__STR_LIT_625), new SingleValueRange(__STR_LIT_626), new SingleValueRange(__STR_LIT_389), new SingleValueRange(__STR_LIT_627), new SingleValueRange(__STR_LIT_628), new SingleValueRange(__STR_LIT_629), new SingleValueRange(__STR_LIT_630), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_631), new SingleValueRange(__STR_LIT_632), new SingleValueRange(__STR_LIT_633), new SingleValueRange(__STR_LIT_634), new SingleValueRange(__STR_LIT_635), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_636), new SingleValueRange(__STR_LIT_637), new SingleValueRange(__STR_LIT_638), new SingleValueRange(__STR_LIT_639), new SingleValueRange(__STR_LIT_640), new SingleValueRange(__STR_LIT_641)}), EF4.get(context)).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_572), new SingleValueRange(__STR_LIT_573), new SingleValueRange(__STR_LIT_574), new SingleValueRange(__STR_LIT_575), new SingleValueRange(__STR_LIT_576), new SingleValueRange(__STR_LIT_577), new SingleValueRange(__STR_LIT_578), new SingleValueRange(__STR_LIT_579), new SingleValueRange(__STR_LIT_580), new SingleValueRange(__STR_LIT_581), new SingleValueRange(__STR_LIT_582), new SingleValueRange(__STR_LIT_583), new SingleValueRange(__STR_LIT_584), new SingleValueRange(__STR_LIT_585), new SingleValueRange(__STR_LIT_586), new SingleValueRange(__STR_LIT_587), new SingleValueRange(__STR_LIT_588), new SingleValueRange(__STR_LIT_589), new SingleValueRange(__STR_LIT_590), new SingleValueRange(__STR_LIT_591), new SingleValueRange(__STR_LIT_592), new SingleValueRange(__STR_LIT_593), new SingleValueRange(__STR_LIT_594), new SingleValueRange(__STR_LIT_595), new SingleValueRange(__STR_LIT_596), new SingleValueRange(__STR_LIT_597), new SingleValueRange(__STR_LIT_598), new SingleValueRange(__STR_LIT_599), new SingleValueRange(__STR_LIT_600), new SingleValueRange(__STR_LIT_601), new SingleValueRange(__STR_LIT_602), new SingleValueRange(__STR_LIT_603), new SingleValueRange(__STR_LIT_604), new SingleValueRange(__STR_LIT_605), new SingleValueRange(__STR_LIT_606), new SingleValueRange(__STR_LIT_607), new SingleValueRange(__STR_LIT_608), new SingleValueRange(__STR_LIT_609), new SingleValueRange(__STR_LIT_610), new SingleValueRange(__STR_LIT_611), new SingleValueRange(__STR_LIT_612), new SingleValueRange(__STR_LIT_613), new SingleValueRange(__STR_LIT_614), new SingleValueRange(__STR_LIT_424), new SingleValueRange(__STR_LIT_615), new SingleValueRange(__STR_LIT_616), new SingleValueRange(__STR_LIT_617), new SingleValueRange(__STR_LIT_618), new SingleValueRange(__STR_LIT_619), new SingleValueRange(__STR_LIT_620), new SingleValueRange(__STR_LIT_621), new SingleValueRange(__STR_LIT_622), new SingleValueRange(__STR_LIT_623), new SingleValueRange(__STR_LIT_624), new SingleValueRange(__STR_LIT_625), new SingleValueRange(__STR_LIT_626), new SingleValueRange(__STR_LIT_389), new SingleValueRange(__STR_LIT_627), new SingleValueRange(__STR_LIT_628), new SingleValueRange(__STR_LIT_629), new SingleValueRange(__STR_LIT_630), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_631), new SingleValueRange(__STR_LIT_632), new SingleValueRange(__STR_LIT_633), new SingleValueRange(__STR_LIT_634), new SingleValueRange(__STR_LIT_635), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_636), new SingleValueRange(__STR_LIT_637), new SingleValueRange(__STR_LIT_638), new SingleValueRange(__STR_LIT_639), new SingleValueRange(__STR_LIT_640), new SingleValueRange(__STR_LIT_641)}), EF16.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_572), new SingleValueRange(__STR_LIT_573), new SingleValueRange(__STR_LIT_574), new SingleValueRange(__STR_LIT_575), new SingleValueRange(__STR_LIT_576), new SingleValueRange(__STR_LIT_577), new SingleValueRange(__STR_LIT_578), new SingleValueRange(__STR_LIT_579), new SingleValueRange(__STR_LIT_580), new SingleValueRange(__STR_LIT_581), new SingleValueRange(__STR_LIT_582), new SingleValueRange(__STR_LIT_583), new SingleValueRange(__STR_LIT_584), new SingleValueRange(__STR_LIT_585), new SingleValueRange(__STR_LIT_586), new SingleValueRange(__STR_LIT_587), new SingleValueRange(__STR_LIT_588), new SingleValueRange(__STR_LIT_589), new SingleValueRange(__STR_LIT_590), new SingleValueRange(__STR_LIT_591), new SingleValueRange(__STR_LIT_592), new SingleValueRange(__STR_LIT_593), new SingleValueRange(__STR_LIT_594), new SingleValueRange(__STR_LIT_595), new SingleValueRange(__STR_LIT_596), new SingleValueRange(__STR_LIT_597), new SingleValueRange(__STR_LIT_598), new SingleValueRange(__STR_LIT_599), new SingleValueRange(__STR_LIT_600), new SingleValueRange(__STR_LIT_601), new SingleValueRange(__STR_LIT_602), new SingleValueRange(__STR_LIT_603), new SingleValueRange(__STR_LIT_604), new SingleValueRange(__STR_LIT_605), new SingleValueRange(__STR_LIT_606), new SingleValueRange(__STR_LIT_607), new SingleValueRange(__STR_LIT_608), new SingleValueRange(__STR_LIT_609), new SingleValueRange(__STR_LIT_610), new SingleValueRange(__STR_LIT_611), new SingleValueRange(__STR_LIT_612), new SingleValueRange(__STR_LIT_613), new SingleValueRange(__STR_LIT_614), new SingleValueRange(__STR_LIT_424), new SingleValueRange(__STR_LIT_615), new SingleValueRange(__STR_LIT_616), new SingleValueRange(__STR_LIT_617), new SingleValueRange(__STR_LIT_618), new SingleValueRange(__STR_LIT_619), new SingleValueRange(__STR_LIT_620), new SingleValueRange(__STR_LIT_621), new SingleValueRange(__STR_LIT_622), new SingleValueRange(__STR_LIT_623), new SingleValueRange(__STR_LIT_624), new SingleValueRange(__STR_LIT_625), new SingleValueRange(__STR_LIT_626), new SingleValueRange(__STR_LIT_389), new SingleValueRange(__STR_LIT_627), new SingleValueRange(__STR_LIT_628), new SingleValueRange(__STR_LIT_629), new SingleValueRange(__STR_LIT_630), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_631), new SingleValueRange(__STR_LIT_632), new SingleValueRange(__STR_LIT_633), new SingleValueRange(__STR_LIT_634), new SingleValueRange(__STR_LIT_635), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_636), new SingleValueRange(__STR_LIT_637), new SingleValueRange(__STR_LIT_638), new SingleValueRange(__STR_LIT_639), new SingleValueRange(__STR_LIT_640), new SingleValueRange(__STR_LIT_641)}), EF56.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_572), new SingleValueRange(__STR_LIT_573), new SingleValueRange(__STR_LIT_574), new SingleValueRange(__STR_LIT_575), new SingleValueRange(__STR_LIT_576), new SingleValueRange(__STR_LIT_577), new SingleValueRange(__STR_LIT_578), new SingleValueRange(__STR_LIT_579), new SingleValueRange(__STR_LIT_580), new SingleValueRange(__STR_LIT_581), new SingleValueRange(__STR_LIT_582), new SingleValueRange(__STR_LIT_583), new SingleValueRange(__STR_LIT_584), new SingleValueRange(__STR_LIT_585), new SingleValueRange(__STR_LIT_586), new SingleValueRange(__STR_LIT_587), new SingleValueRange(__STR_LIT_588), new SingleValueRange(__STR_LIT_589), new SingleValueRange(__STR_LIT_590), new SingleValueRange(__STR_LIT_591), new SingleValueRange(__STR_LIT_592), new SingleValueRange(__STR_LIT_593), new SingleValueRange(__STR_LIT_594), new SingleValueRange(__STR_LIT_595), new SingleValueRange(__STR_LIT_596), new SingleValueRange(__STR_LIT_597), new SingleValueRange(__STR_LIT_598), new SingleValueRange(__STR_LIT_599), new SingleValueRange(__STR_LIT_600), new SingleValueRange(__STR_LIT_601), new SingleValueRange(__STR_LIT_602), new SingleValueRange(__STR_LIT_603), new SingleValueRange(__STR_LIT_604), new SingleValueRange(__STR_LIT_605), new SingleValueRange(__STR_LIT_606), new SingleValueRange(__STR_LIT_607), new SingleValueRange(__STR_LIT_608), new SingleValueRange(__STR_LIT_609), new SingleValueRange(__STR_LIT_610), new SingleValueRange(__STR_LIT_611), new SingleValueRange(__STR_LIT_612), new SingleValueRange(__STR_LIT_613), new SingleValueRange(__STR_LIT_614), new SingleValueRange(__STR_LIT_424), new SingleValueRange(__STR_LIT_615), new SingleValueRange(__STR_LIT_616), new SingleValueRange(__STR_LIT_617), new SingleValueRange(__STR_LIT_618), new SingleValueRange(__STR_LIT_619), new SingleValueRange(__STR_LIT_620), new SingleValueRange(__STR_LIT_621), new SingleValueRange(__STR_LIT_622), new SingleValueRange(__STR_LIT_623), new SingleValueRange(__STR_LIT_624), new SingleValueRange(__STR_LIT_625), new SingleValueRange(__STR_LIT_626), new SingleValueRange(__STR_LIT_389), new SingleValueRange(__STR_LIT_627), new SingleValueRange(__STR_LIT_628), new SingleValueRange(__STR_LIT_629), new SingleValueRange(__STR_LIT_630), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_631), new SingleValueRange(__STR_LIT_632), new SingleValueRange(__STR_LIT_633), new SingleValueRange(__STR_LIT_634), new SingleValueRange(__STR_LIT_635), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_636), new SingleValueRange(__STR_LIT_637), new SingleValueRange(__STR_LIT_638), new SingleValueRange(__STR_LIT_639), new SingleValueRange(__STR_LIT_640), new SingleValueRange(__STR_LIT_641)}), EF66.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_572), new SingleValueRange(__STR_LIT_573), new SingleValueRange(__STR_LIT_574), new SingleValueRange(__STR_LIT_575), new SingleValueRange(__STR_LIT_576), new SingleValueRange(__STR_LIT_577), new SingleValueRange(__STR_LIT_578), new SingleValueRange(__STR_LIT_579), new SingleValueRange(__STR_LIT_580), new SingleValueRange(__STR_LIT_581), new SingleValueRange(__STR_LIT_582), new SingleValueRange(__STR_LIT_583), new SingleValueRange(__STR_LIT_584), new SingleValueRange(__STR_LIT_585), new SingleValueRange(__STR_LIT_586), new SingleValueRange(__STR_LIT_587), new SingleValueRange(__STR_LIT_588), new SingleValueRange(__STR_LIT_589), new SingleValueRange(__STR_LIT_590), new SingleValueRange(__STR_LIT_591), new SingleValueRange(__STR_LIT_592), new SingleValueRange(__STR_LIT_593), new SingleValueRange(__STR_LIT_594), new SingleValueRange(__STR_LIT_595), new SingleValueRange(__STR_LIT_596), new SingleValueRange(__STR_LIT_597), new SingleValueRange(__STR_LIT_598), new SingleValueRange(__STR_LIT_599), new SingleValueRange(__STR_LIT_600), new SingleValueRange(__STR_LIT_601), new SingleValueRange(__STR_LIT_602), new SingleValueRange(__STR_LIT_603), new SingleValueRange(__STR_LIT_604), new SingleValueRange(__STR_LIT_605), new SingleValueRange(__STR_LIT_606), new SingleValueRange(__STR_LIT_607), new SingleValueRange(__STR_LIT_608), new SingleValueRange(__STR_LIT_609), new SingleValueRange(__STR_LIT_610), new SingleValueRange(__STR_LIT_611), new SingleValueRange(__STR_LIT_612), new SingleValueRange(__STR_LIT_613), new SingleValueRange(__STR_LIT_614), new SingleValueRange(__STR_LIT_424), new SingleValueRange(__STR_LIT_615), new SingleValueRange(__STR_LIT_616), new SingleValueRange(__STR_LIT_617), new SingleValueRange(__STR_LIT_618), new SingleValueRange(__STR_LIT_619), new SingleValueRange(__STR_LIT_620), new SingleValueRange(__STR_LIT_621), new SingleValueRange(__STR_LIT_622), new SingleValueRange(__STR_LIT_623), new SingleValueRange(__STR_LIT_624), new SingleValueRange(__STR_LIT_625), new SingleValueRange(__STR_LIT_626), new SingleValueRange(__STR_LIT_389), new SingleValueRange(__STR_LIT_627), new SingleValueRange(__STR_LIT_628), new SingleValueRange(__STR_LIT_629), new SingleValueRange(__STR_LIT_630), new SingleValueRange(__STR_LIT_125), new SingleValueRange(__STR_LIT_126), new SingleValueRange(__STR_LIT_631), new SingleValueRange(__STR_LIT_632), new SingleValueRange(__STR_LIT_633), new SingleValueRange(__STR_LIT_634), new SingleValueRange(__STR_LIT_635), new SingleValueRange(__STR_LIT_200), new SingleValueRange(__STR_LIT_201), new SingleValueRange(__STR_LIT_203), new SingleValueRange(__STR_LIT_204), new SingleValueRange(__STR_LIT_205), new SingleValueRange(__STR_LIT_206), new SingleValueRange(__STR_LIT_207), new SingleValueRange(__STR_LIT_636), new SingleValueRange(__STR_LIT_637), new SingleValueRange(__STR_LIT_638), new SingleValueRange(__STR_LIT_639), new SingleValueRange(__STR_LIT_640), new SingleValueRange(__STR_LIT_641)}), EF74.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_001");
+ fehler_SIG_001(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_001", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_001");
+ this.fehler_SIG_001(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_001");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_001(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_001");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#SIG_001" : "#SIG_001");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_003(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_003");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF7.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF7.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF7.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_003");
+ fehler_SIG_003(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_003", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_003");
+ this.fehler_SIG_003(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_003");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_003(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_003");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF7;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_003");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_006(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_006");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF8U1.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF8U1.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_8)}), EF8U1.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_006");
+ fehler_SIG_006(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_006", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_006");
+ this.fehler_SIG_006(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_006");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_006(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_006");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF8U1;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_006");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_009(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_009");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF8U2.get(context))), __NUM_LIT_4).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_64, __NUM_LIT_65, __NUM_LIT_66)}), EF8U2.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_009");
+ fehler_SIG_009(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_009", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_009");
+ this.fehler_SIG_009(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_009");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_009(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_009");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF8U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_009");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_012(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_012");
+ try
+ {
+ if(OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STAAT, new FeldDeskriptorInterface[] {__material_ref_STAAT.key}, new SatzFilter.FilterBedingung[] {}, context), EF9.get(context))).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_012");
+ fehler_SIG_012(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_012", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_012");
+ this.fehler_SIG_012(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_012");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_012(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_012");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF9;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_012");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_015(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_015");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_22), new SingleValueRange(__STR_LIT_23)}), EF4.get(context)).asBoolean() || OperatorLib.eq(context, prg_fkt_SIG_015(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULSTANDORT, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULSTANDORT.bundesland}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULSTANDORT.key, 1, prg_fkt_SIG_015(context))}, context), EF1.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.not(context, prg_EIG_A(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF4.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_015");
+ fehler_SIG_015(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_015", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_015");
+ this.fehler_SIG_015(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_015");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_015(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_015");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF4;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_015");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_021(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_021");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_BUNDESLAND, new FeldDeskriptorInterface[] {__material_ref_BUNDESLAND.key}, new SatzFilter.FilterBedingung[] {}, context), EF10U1.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_021");
+ fehler_SIG_021(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_021", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_021");
+ this.fehler_SIG_021(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_021");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_021(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_021");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF10U1;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_021");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_027(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_027");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF10U2.get(context))), __NUM_LIT_3).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF10U2.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_10)}), EF10U2.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_027");
+ fehler_SIG_027(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_027", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_027");
+ this.fehler_SIG_027(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_027");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_027(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_027");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF10U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_027");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_033(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_033");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_BUNDESLAND, new FeldDeskriptorInterface[] {__material_ref_BUNDESLAND.key}, new SatzFilter.FilterBedingung[] {}, context), EF11U1.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_033");
+ fehler_SIG_033(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_033", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_033");
+ this.fehler_SIG_033(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_033");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_033(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_033");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF11U1;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_033");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_039(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_039");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF11U2.get(context))), __NUM_LIT_3).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF11U2.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_10)}), EF11U2.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_039");
+ fehler_SIG_039(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_039", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_039");
+ this.fehler_SIG_039(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_039");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_039(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_039");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF11U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_039");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_045(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_045");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF16.get(context), __STR_LIT_23).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF16.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_045");
+ fehler_SIG_045(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_045", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_045");
+ this.fehler_SIG_045(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_045");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_045(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_045");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF16;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_045");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_048(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_048");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF17.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF17.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF17.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF17.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_048");
+ fehler_SIG_048(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_048", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_048");
+ this.fehler_SIG_048(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_048");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_048(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_048");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF17;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_048");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_051(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_051");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF18.get(context))), __NUM_LIT_4).asBoolean() && OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_67), new IntervalRange(__NUM_LIT_68, EF3.get(context), 4)}), EF18.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_051");
+ fehler_SIG_051(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_051", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_051");
+ this.fehler_SIG_051(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_051");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_051(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_051");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF18;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_051");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_054(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_054");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF19.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF19.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_054");
+ fehler_SIG_054(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_054", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_054");
+ this.fehler_SIG_054(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_054");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_054(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_054");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF19;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_054");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_058(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_058");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF20.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF20.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_058");
+ fehler_SIG_058(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_058", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_058");
+ this.fehler_SIG_058(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_058");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_058(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_058");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF20;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_058");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_060(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_060");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF21.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF21.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF21.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_060");
+ fehler_SIG_060(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_060", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_060");
+ this.fehler_SIG_060(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_060");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_060(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_060");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF21;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_060");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_063(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_063");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF22.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF22.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF22.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_063");
+ fehler_SIG_063(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_063", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_063");
+ this.fehler_SIG_063(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_063");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_063(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_063");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF22;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_063");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_066(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_066");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF23.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF23.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF23.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF23.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF23.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_066");
+ fehler_SIG_066(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_066", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_066");
+ this.fehler_SIG_066(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_066");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_066(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_066");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF23;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_066");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_069(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_069");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF24.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF24.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF24.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF24.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF24.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_069");
+ fehler_SIG_069(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_069", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_069");
+ this.fehler_SIG_069(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_069");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_069(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_069");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF24;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_069");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_072(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_072");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF25.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF25.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF25.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_072");
+ fehler_SIG_072(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_072", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_072");
+ this.fehler_SIG_072(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_072");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_072(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_072");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF25;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_072");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_075(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_075");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_EINSCHREIBUNGART, new FeldDeskriptorInterface[] {__material_ref_EINSCHREIBUNGART.key}, new SatzFilter.FilterBedingung[] {}, context), EF26.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_075");
+ fehler_SIG_075(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_075", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_075");
+ this.fehler_SIG_075(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_075");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_075(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_075");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF26;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_075");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_078(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_078");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF27.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF27.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF27.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_078");
+ fehler_SIG_078(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_078", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_078");
+ this.fehler_SIG_078(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_078");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_078(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_078");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF27;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_078");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_081(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_081");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIUMART, new FeldDeskriptorInterface[] {__material_ref_STUDIUMART.key}, new SatzFilter.FilterBedingung[] {}, context), EF28.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_081");
+ fehler_SIG_081(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_081", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_081");
+ this.fehler_SIG_081(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_081");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_081(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_081");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF28;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_081");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_087(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_087");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF30.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF30.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF30.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_087");
+ fehler_SIG_087(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_087", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_087");
+ this.fehler_SIG_087(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_087");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_087(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_087");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF30;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_087");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_090(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_090");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF31.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF31.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_090");
+ fehler_SIG_090(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_090", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_090");
+ this.fehler_SIG_090(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_090");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_090(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_090");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF31;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_090");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_093(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_093");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF31.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF31.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_093");
+ fehler_SIG_093(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_093", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_093");
+ this.fehler_SIG_093(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_093");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_093(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_093");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF31;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_093");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_096(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_096");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF32.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF32.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF32.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF32.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_096");
+ fehler_SIG_096(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_096", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_096");
+ this.fehler_SIG_096(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_096");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_096(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_096");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF32;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_096");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_099(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_099");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF32.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF32.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF32.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF32.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_099");
+ fehler_SIG_099(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_099", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_099");
+ this.fehler_SIG_099(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_099");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_099(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_099");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF32;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_099");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_102(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_102");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF34.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF34.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF34.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF34.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_102");
+ fehler_SIG_102(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_102", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_102");
+ this.fehler_SIG_102(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_102");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_102(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_102");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF34;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_102");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_105(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_105");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF36.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF36.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF36.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF36.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_105");
+ fehler_SIG_105(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_105", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_105");
+ this.fehler_SIG_105(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_105");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_105(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_105");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF36;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_105");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_108(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_108");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF41.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_EINSCHREIBUNGART, new FeldDeskriptorInterface[] {__material_ref_EINSCHREIBUNGART.key}, new SatzFilter.FilterBedingung[] {}, context), EF41.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_108");
+ fehler_SIG_108(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_108", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_108");
+ this.fehler_SIG_108(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_108");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_108(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_108");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF41;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_108");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_111(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_111");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF42.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF42.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF42.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF42.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_111");
+ fehler_SIG_111(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_111", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_111");
+ this.fehler_SIG_111(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_111");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_111(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_111");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF42;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_111");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_114(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_114");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF43.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIUMART, new FeldDeskriptorInterface[] {__material_ref_STUDIUMART.key}, new SatzFilter.FilterBedingung[] {}, context), EF43.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_114");
+ fehler_SIG_114(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_114", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_114");
+ this.fehler_SIG_114(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_114");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_114(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_114");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF43;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_114");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_117(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_117");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF44.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_VOLLTEILZEIT, new FeldDeskriptorInterface[] {__material_ref_VOLLTEILZEIT.key}, new SatzFilter.FilterBedingung[] {}, context), EF44.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_117");
+ fehler_SIG_117(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_117", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_117");
+ this.fehler_SIG_117(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_117");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_117(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_117");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF44;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_117");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_120(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_120");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF45.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF45.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF45.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_120");
+ fehler_SIG_120(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_120", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_120");
+ this.fehler_SIG_120(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_120");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_120(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_120");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF45;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_120");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_123(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_123");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF46.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF46.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_123");
+ fehler_SIG_123(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_123", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_123");
+ this.fehler_SIG_123(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_123");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_123(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_123");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF46;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_123");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_126(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_126");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF47.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF47.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF47.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF47.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_126");
+ fehler_SIG_126(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_126", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_126");
+ this.fehler_SIG_126(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_126");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_126(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_126");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF47;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_126");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_129(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_129");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF49.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF49.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF49.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF49.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_129");
+ fehler_SIG_129(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_129", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_129");
+ this.fehler_SIG_129(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_129");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_129(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_129");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF49;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_129");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_132(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_132");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF51.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF51.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF51.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF51.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_132");
+ fehler_SIG_132(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_132", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_132");
+ this.fehler_SIG_132(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_132");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_132(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_132");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF51;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_132");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_135(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_135");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF56.get(context), __STR_LIT_22).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF56.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF56.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_135");
+ fehler_SIG_135(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_135", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_135");
+ this.fehler_SIG_135(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_135");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_135(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_135");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF56;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_135");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_138(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_138");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF59.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF59.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF59.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF59.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_138");
+ fehler_SIG_138(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_138", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_138");
+ this.fehler_SIG_138(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_138");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_138(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_138");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF59;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_138");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_141(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_141");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF60.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF60.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF60.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF60.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_141");
+ fehler_SIG_141(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_141", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_141");
+ this.fehler_SIG_141(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_141");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_141(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_141");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF60;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_141");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_144(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_144");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF61.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF61.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF61.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF61.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_144");
+ fehler_SIG_144(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_144", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_144");
+ this.fehler_SIG_144(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_144");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_144(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_144");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF61;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_144");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_147(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_147");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF62.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF62.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF62.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF62.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_147");
+ fehler_SIG_147(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_147", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_147");
+ this.fehler_SIG_147(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_147");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_147(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_147");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF62;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_147");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_150(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_150");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF64.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF64.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF64.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF64.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF64.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_150");
+ fehler_SIG_150(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_150", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_150");
+ this.fehler_SIG_150(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_150");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_150(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_150");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF64;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_150");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_153(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_153");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF65U1.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF65U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF65U1.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF65U1.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF65U1.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_153");
+ fehler_SIG_153(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_153", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_153");
+ this.fehler_SIG_153(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_153");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_153(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_153");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF65U1;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_153");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_156(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_156");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF66.get(context), __STR_LIT_23).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF66.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF66.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_156");
+ fehler_SIG_156(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_156", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_156");
+ this.fehler_SIG_156(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_156");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_156(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_156");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF66;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_156");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_159(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_159");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF69.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF69.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF69.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF69.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_159");
+ fehler_SIG_159(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_159", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_159");
+ this.fehler_SIG_159(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_159");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_159(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_159");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF69;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_159");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_162(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_162");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF70.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF70.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF70.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF70.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_162");
+ fehler_SIG_162(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_162", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_162");
+ this.fehler_SIG_162(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_162");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_162(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_162");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF70;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_162");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_165(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_165");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF71.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF71.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF71.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF71.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_165");
+ fehler_SIG_165(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_165", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_165");
+ this.fehler_SIG_165(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_165");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_165(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_165");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF71;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_165");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_168(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_168");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF72.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF72.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF72.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF72.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_168");
+ fehler_SIG_168(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_168", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_168");
+ this.fehler_SIG_168(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_168");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_168(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_168");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF72;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_168");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_171(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_171");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF74.get(context), __STR_LIT_23).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF74.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.key}, new SatzFilter.FilterBedingung[] {}, context), EF74.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_171");
+ fehler_SIG_171(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_171", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_171");
+ this.fehler_SIG_171(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_171");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_171(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_171");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF74;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_171");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_174(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_174");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF77.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF77.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF77.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF77.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_174");
+ fehler_SIG_174(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_174", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_174");
+ this.fehler_SIG_174(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_174");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_174(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_174");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF77;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_174");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_177(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_177");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF78.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF78.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF78.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF78.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_177");
+ fehler_SIG_177(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_177", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_177");
+ this.fehler_SIG_177(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_177");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_177(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_177");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF78;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_177");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_180(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_180");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF79.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF79.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF79.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF79.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_180");
+ fehler_SIG_180(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_180", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_180");
+ this.fehler_SIG_180(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_180");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_180(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_180");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF79;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_180");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_183(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_183");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF80.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF80.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF80.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF80.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_183");
+ fehler_SIG_183(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_183", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_183");
+ this.fehler_SIG_183(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_183");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_183(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_183");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF80;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_183");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_186(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_186");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF82.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STAAT, new FeldDeskriptorInterface[] {__material_ref_STAAT.key}, new SatzFilter.FilterBedingung[] {}, context), EF82.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_186");
+ fehler_SIG_186(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_186", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_186");
+ this.fehler_SIG_186(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_186");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_186(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_186");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF82;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_186");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_189(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_189");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF83.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF83.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_189");
+ fehler_SIG_189(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_189", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_189");
+ this.fehler_SIG_189(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_189");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_189(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_189");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF83;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_189");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_192(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_192");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF85.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STAAT, new FeldDeskriptorInterface[] {__material_ref_STAAT.key}, new SatzFilter.FilterBedingung[] {}, context), EF85.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_192");
+ fehler_SIG_192(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_192", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_192");
+ this.fehler_SIG_192(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_192");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_192(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_192");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF85;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_192");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_195(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_195");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF86.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF86.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_195");
+ fehler_SIG_195(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_195", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_195");
+ this.fehler_SIG_195(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_195");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_195(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_195");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF86;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_195");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_198(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_198");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.ge(context, EF91.get(context), __STR_LIT_542).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF91.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF91.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_198");
+ fehler_SIG_198(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_198", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_198");
+ this.fehler_SIG_198(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_198");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_198(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_198");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF91;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_198");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_201(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_201");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF92.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF92.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF92.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF92.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_201");
+ fehler_SIG_201(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_201", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_201");
+ this.fehler_SIG_201(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_201");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_201(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_201");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF92;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_201");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_204(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_204");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF93.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF93.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF93.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF93.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_204");
+ fehler_SIG_204(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_204", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_204");
+ this.fehler_SIG_204(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_204");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_204(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_204");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF93;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_204");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_207(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_207");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF94.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF94.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF94.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF94.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_207");
+ fehler_SIG_207(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_207", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_207");
+ this.fehler_SIG_207(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_207");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_207(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_207");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF94;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_207");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_210(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_210");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF96.get(context))), __NUM_LIT_2).asBoolean() && OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF96.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_8)}), EF96.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_210");
+ fehler_SIG_210(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_210", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_210");
+ this.fehler_SIG_210(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_210");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_210(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_210");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF96;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_210");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_213(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_213");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF97.get(context))), __NUM_LIT_4).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF97.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_69), new IntervalRange(__NUM_LIT_70, EF3.get(context), 4)}), EF97.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_213");
+ fehler_SIG_213(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_213", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_213");
+ this.fehler_SIG_213(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_213");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_213(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_213");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF97;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_213");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_216(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_216");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF98.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF98.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF98.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_216");
+ fehler_SIG_216(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_216", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_216");
+ this.fehler_SIG_216(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_216");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_216(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_216");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF98;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_216");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_219(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_219");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF99.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF99.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540), new SingleValueRange(__STR_LIT_542)}), EF99.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_219");
+ fehler_SIG_219(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_219", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_219");
+ this.fehler_SIG_219(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_219");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_219(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_219");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF99;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_219");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_222(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_222");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.ge(context, EF100.get(context), __STR_LIT_542).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF100.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF100.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_222");
+ fehler_SIG_222(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_222", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_222");
+ this.fehler_SIG_222(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_222");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_222(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_222");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF100;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_222");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_225(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_225");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF101.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF101.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF101.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF101.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_225");
+ fehler_SIG_225(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_225", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_225");
+ this.fehler_SIG_225(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_225");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_225(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_225");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF101;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_225");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_228(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_228");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF102.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF102.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF102.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF102.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_228");
+ fehler_SIG_228(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_228", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_228");
+ this.fehler_SIG_228(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_228");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_228(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_228");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF102;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_228");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_231(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_231");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF103.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF103.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF103.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF103.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_231");
+ fehler_SIG_231(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_231", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_231");
+ this.fehler_SIG_231(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_231");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_231(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_231");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF103;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_231");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_234(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_234");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF105.get(context))), __NUM_LIT_2).asBoolean() && OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF105.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_8)}), EF105.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_234");
+ fehler_SIG_234(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_234", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_234");
+ this.fehler_SIG_234(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_234");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_234(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_234");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF105;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_234");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_237(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_237");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF106.get(context))), __NUM_LIT_4).asBoolean() && OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF106.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_69), new IntervalRange(__NUM_LIT_70, EF3.get(context), 4)}), EF106.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_237");
+ fehler_SIG_237(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_237", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_237");
+ this.fehler_SIG_237(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_237");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_237(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_237");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF106;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_237");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_240(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_240");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF107.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF107.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF107.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_240");
+ fehler_SIG_240(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_240", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_240");
+ this.fehler_SIG_240(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_240");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_240(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_240");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF107;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_240");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_243(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_243");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF108.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF108.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540), new SingleValueRange(__STR_LIT_542)}), EF108.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_243");
+ fehler_SIG_243(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_243", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_243");
+ this.fehler_SIG_243(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_243");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_243(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_243");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF108;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_243");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_246(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_246");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF109.get(context))), __NUM_LIT_4).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF109.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_67), new IntervalRange(__NUM_LIT_68, EF3.get(context), 4)}), EF109.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_246");
+ fehler_SIG_246(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_246", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_246");
+ this.fehler_SIG_246(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_246");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_246(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_246");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF109;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_246");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_249(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_249");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HZBART, new FeldDeskriptorInterface[] {__material_ref_HZBART.key}, new SatzFilter.FilterBedingung[] {}, context), EF110.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_249");
+ fehler_SIG_249(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_249", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_249");
+ this.fehler_SIG_249(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_249");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_249(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_249");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF110;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_249");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_255(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_255");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_BUNDESLAND, new FeldDeskriptorInterface[] {__material_ref_BUNDESLAND.key}, new SatzFilter.FilterBedingung[] {}, context), EF111U1.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_255");
+ fehler_SIG_255(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_255", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_255");
+ this.fehler_SIG_255(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_255");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_255(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_255");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF111U1;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_255");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_261(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_261");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF111U2.get(context))), __NUM_LIT_3).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF111U2.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_10)}), EF111U2.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_261");
+ fehler_SIG_261(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_261", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_261");
+ this.fehler_SIG_261(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_261");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_261(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_261");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF111U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_261");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_264(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_264");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF112.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF112.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF112.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF112.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12)}), EF112.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_264");
+ fehler_SIG_264(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_264", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_264");
+ this.fehler_SIG_264(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_264");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_264(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_264");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF112;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_264");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_267(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_267");
+ try
+ {
+ if(vf.valueFor(prg_EIG_A(context).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF113.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF113.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF113.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF113.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12)}), EF113.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_267");
+ fehler_SIG_267(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_267", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_267");
+ this.fehler_SIG_267(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_267");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_267(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_267");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF113;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_267");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_270(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_270");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.ne(context, EF120.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_642), new SingleValueRange(__STR_LIT_643), new SingleValueRange(__STR_LIT_644), new SingleValueRange(__STR_LIT_645), new SingleValueRange(__STR_LIT_646), new SingleValueRange(__STR_LIT_647), new SingleValueRange(__STR_LIT_648), new SingleValueRange(__STR_LIT_649), new SingleValueRange(__STR_LIT_650), new SingleValueRange(__STR_LIT_356), new SingleValueRange(__STR_LIT_514), new SingleValueRange(__STR_LIT_651), new SingleValueRange(__STR_LIT_652), new SingleValueRange(__STR_LIT_653), new SingleValueRange(__STR_LIT_654), new SingleValueRange(__STR_LIT_655)}), FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_656), new SingleValueRange(__STR_LIT_657), new SingleValueRange(__STR_LIT_658), new SingleValueRange(__STR_LIT_659), new SingleValueRange(__STR_LIT_660), new SingleValueRange(__STR_LIT_661), new SingleValueRange(__STR_LIT_662), new SingleValueRange(__STR_LIT_663), new SingleValueRange(__STR_LIT_664), new SingleValueRange(__STR_LIT_665), new SingleValueRange(__STR_LIT_666), new SingleValueRange(__STR_LIT_667), new SingleValueRange(__STR_LIT_668), new SingleValueRange(__STR_LIT_669), new SingleValueRange(__STR_LIT_670), new SingleValueRange(__STR_LIT_671)}), FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4)))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_270");
+ fehler_SIG_270(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_270", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_270");
+ this.fehler_SIG_270(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_270");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_270(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_270");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF120;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_270");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_273(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_273");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF120.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_642), new SingleValueRange(__STR_LIT_643), new SingleValueRange(__STR_LIT_644), new SingleValueRange(__STR_LIT_645), new SingleValueRange(__STR_LIT_646), new SingleValueRange(__STR_LIT_647), new SingleValueRange(__STR_LIT_648), new SingleValueRange(__STR_LIT_649), new SingleValueRange(__STR_LIT_650), new SingleValueRange(__STR_LIT_356), new SingleValueRange(__STR_LIT_514), new SingleValueRange(__STR_LIT_651), new SingleValueRange(__STR_LIT_652), new SingleValueRange(__STR_LIT_653), new SingleValueRange(__STR_LIT_654), new SingleValueRange(__STR_LIT_655), new SingleValueRange(__STR_LIT_656), new SingleValueRange(__STR_LIT_657), new SingleValueRange(__STR_LIT_658), new SingleValueRange(__STR_LIT_659), new SingleValueRange(__STR_LIT_660), new SingleValueRange(__STR_LIT_661), new SingleValueRange(__STR_LIT_662), new SingleValueRange(__STR_LIT_663), new SingleValueRange(__STR_LIT_664), new SingleValueRange(__STR_LIT_665), new SingleValueRange(__STR_LIT_666), new SingleValueRange(__STR_LIT_667), new SingleValueRange(__STR_LIT_668), new SingleValueRange(__STR_LIT_669), new SingleValueRange(__STR_LIT_670), new SingleValueRange(__STR_LIT_671)}), FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4)))).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF120.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.eq(context, prg_fkt_SIG_273(context), __STR_LIT_29).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF120.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULSTANDORT, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULSTANDORT.bundesland}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULSTANDORT.key, 1, prg_fkt_SIG_273(context))}, context), EF1.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_273");
+ fehler_SIG_273(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_273", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_273");
+ this.fehler_SIG_273(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_273");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_273(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_273");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF120;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_273");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_276(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_276");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_6), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_6), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_276");
+ fehler_SIG_276(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_276", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_276");
+ this.fehler_SIG_276(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_276");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_276(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_276");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF120;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_276");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_279(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_279");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF121.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF121.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF121.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_279");
+ fehler_SIG_279(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_279", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_279");
+ this.fehler_SIG_279(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_279");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_279(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_279");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF121;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_279");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_282(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_282");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF122.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF122.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF122.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_282");
+ fehler_SIG_282(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_282", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_282");
+ this.fehler_SIG_282(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_282");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_282(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_282");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF122;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_282");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_285(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_285");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF123.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF123.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF123.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_285");
+ fehler_SIG_285(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_285", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_285");
+ this.fehler_SIG_285(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_285");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_285(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_285");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF123;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_285");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_288(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_288");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF124.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF124.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF124.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_288");
+ fehler_SIG_288(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_288", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_288");
+ this.fehler_SIG_288(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_288");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_288(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_288");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF124;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_288");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_291(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_291");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF125.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF125.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF125.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_291");
+ fehler_SIG_291(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_291", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_291");
+ this.fehler_SIG_291(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_291");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_291(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_291");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF125;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_291");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_294(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_294");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ge(context, EF126.get(context), __STR_LIT_542).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF126.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF126.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_294");
+ fehler_SIG_294(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_294", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_294");
+ this.fehler_SIG_294(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_294");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_294(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_294");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF126;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_294");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_297(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_297");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF127.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF127.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF127.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF127.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_297");
+ fehler_SIG_297(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_297", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_297");
+ this.fehler_SIG_297(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_297");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_297(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_297");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF127;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_297");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_300(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_300");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.eq(context, EF127.get(context), __STR_LIT_548).asBoolean()).asBoolean() && OperatorLib.ne(context, EF152.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF152.get(context))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_13)}), EF152.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_300");
+ fehler_SIG_300(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_300", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_300");
+ this.fehler_SIG_300(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_300");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_300(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_300");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF152;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_300");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_303(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_303");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.eq(context, EF127.get(context), __STR_LIT_548).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)), __STR_LIT_44).asBoolean()).asBoolean() && OperatorLib.ne(context, EF152.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF152.get(context))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_13)}), EF152.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_303");
+ fehler_SIG_303(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_303", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_303");
+ this.fehler_SIG_303(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_303");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_303(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_303");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF152;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_303");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_306(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_306");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF128.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF128.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF128.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF128.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_306");
+ fehler_SIG_306(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_306", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_306");
+ this.fehler_SIG_306(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_306");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_306(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_306");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF128;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_306");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_309(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_309");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF129.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF129.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF129.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF129.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_309");
+ fehler_SIG_309(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_309", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_309");
+ this.fehler_SIG_309(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_309");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_309(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_309");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF129;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_309");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_312(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_312");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF132.get(context))), __NUM_LIT_2).asBoolean() && OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF132.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_8)}), EF132.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_312");
+ fehler_SIG_312(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_312", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_312");
+ this.fehler_SIG_312(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_312");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_312(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_312");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF132;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_312");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_315(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_315");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF133.get(context))), __NUM_LIT_4).asBoolean() && OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF133.get(context)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF133.get(context))).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF133.get(context), EF3.get(context)).asBoolean() && OperatorLib.ne(context, EF133.get(context), OperatorLib.minus(context, EF3.get(context), __NUM_LIT_1)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF133.get(context), OperatorLib.plus(context, EF3.get(context), __NUM_LIT_1)).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_315");
+ fehler_SIG_315(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_315", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_315");
+ this.fehler_SIG_315(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_315");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_315(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_315");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF133;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_315");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_318(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_318");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF134.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF134.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF134.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_318");
+ fehler_SIG_318(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_318", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_318");
+ this.fehler_SIG_318(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_318");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_318(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_318");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF134;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_318");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_321(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_321");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF135.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.ne(context, EF135.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF135.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF135.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540), new SingleValueRange(__STR_LIT_542)}), EF135.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_321");
+ fehler_SIG_321(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_321", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_321");
+ this.fehler_SIG_321(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_321");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_321(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_321");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF135;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_321");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_324(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_324");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.ne(context, EF136.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.ne(context, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18)}), FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_642), new SingleValueRange(__STR_LIT_643), new SingleValueRange(__STR_LIT_644), new SingleValueRange(__STR_LIT_645), new SingleValueRange(__STR_LIT_646), new SingleValueRange(__STR_LIT_647), new SingleValueRange(__STR_LIT_648), new SingleValueRange(__STR_LIT_649), new SingleValueRange(__STR_LIT_650), new SingleValueRange(__STR_LIT_356), new SingleValueRange(__STR_LIT_514), new SingleValueRange(__STR_LIT_651), new SingleValueRange(__STR_LIT_652), new SingleValueRange(__STR_LIT_653), new SingleValueRange(__STR_LIT_654), new SingleValueRange(__STR_LIT_655)}), FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_18).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_656), new SingleValueRange(__STR_LIT_657), new SingleValueRange(__STR_LIT_658), new SingleValueRange(__STR_LIT_659), new SingleValueRange(__STR_LIT_660), new SingleValueRange(__STR_LIT_661), new SingleValueRange(__STR_LIT_662), new SingleValueRange(__STR_LIT_663), new SingleValueRange(__STR_LIT_664), new SingleValueRange(__STR_LIT_665), new SingleValueRange(__STR_LIT_666), new SingleValueRange(__STR_LIT_667), new SingleValueRange(__STR_LIT_668), new SingleValueRange(__STR_LIT_669), new SingleValueRange(__STR_LIT_670), new SingleValueRange(__STR_LIT_671)}), FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4)))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_324");
+ fehler_SIG_324(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_324", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_324");
+ this.fehler_SIG_324(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_324");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_324(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_324");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF136;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_324");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_327(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_327");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF136.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_642), new SingleValueRange(__STR_LIT_643), new SingleValueRange(__STR_LIT_644), new SingleValueRange(__STR_LIT_645), new SingleValueRange(__STR_LIT_646), new SingleValueRange(__STR_LIT_647), new SingleValueRange(__STR_LIT_648), new SingleValueRange(__STR_LIT_649), new SingleValueRange(__STR_LIT_650), new SingleValueRange(__STR_LIT_356), new SingleValueRange(__STR_LIT_514), new SingleValueRange(__STR_LIT_651), new SingleValueRange(__STR_LIT_652), new SingleValueRange(__STR_LIT_653), new SingleValueRange(__STR_LIT_654), new SingleValueRange(__STR_LIT_655), new SingleValueRange(__STR_LIT_656), new SingleValueRange(__STR_LIT_657), new SingleValueRange(__STR_LIT_658), new SingleValueRange(__STR_LIT_659), new SingleValueRange(__STR_LIT_660), new SingleValueRange(__STR_LIT_661), new SingleValueRange(__STR_LIT_662), new SingleValueRange(__STR_LIT_663), new SingleValueRange(__STR_LIT_664), new SingleValueRange(__STR_LIT_665), new SingleValueRange(__STR_LIT_666), new SingleValueRange(__STR_LIT_667), new SingleValueRange(__STR_LIT_668), new SingleValueRange(__STR_LIT_669), new SingleValueRange(__STR_LIT_670), new SingleValueRange(__STR_LIT_671)}), FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4)))).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF136.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.eq(context, prg_fkt_SIG_327(context), __STR_LIT_29).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF136.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULSTANDORT, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULSTANDORT.bundesland}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULSTANDORT.key, 1, prg_fkt_SIG_327(context))}, context), EF1.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_327");
+ fehler_SIG_327(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_327", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_327");
+ this.fehler_SIG_327(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_327");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_327(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_327");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF136;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_327");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_330(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_330");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_6), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_6), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_330");
+ fehler_SIG_330(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_330", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_330");
+ this.fehler_SIG_330(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_330");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_330(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_330");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF136;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_330");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_333(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_333");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF137.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF137.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF137.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_333");
+ fehler_SIG_333(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_333", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_333");
+ this.fehler_SIG_333(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_333");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_333(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_333");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF137;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_333");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_336(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_336");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF138.get(context))), __NUM_LIT_2).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF138.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_30)}), EF138.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_336");
+ fehler_SIG_336(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_336", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_336");
+ this.fehler_SIG_336(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_336");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_336(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_336");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF138;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_336");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_339(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_339");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF139.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF139.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF139.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_339");
+ fehler_SIG_339(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_339", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_339");
+ this.fehler_SIG_339(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_339");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_339(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_339");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF139;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_339");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_342(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_342");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF140.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF140.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF140.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_342");
+ fehler_SIG_342(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_342", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_342");
+ this.fehler_SIG_342(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_342");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_342(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_342");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF140;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_342");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_345(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_345");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF141.get(context))), __NUM_LIT_1).asBoolean() || vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF141.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_46, __NUM_LIT_1, __NUM_LIT_62)}), EF141.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_345");
+ fehler_SIG_345(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_345", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_345");
+ this.fehler_SIG_345(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_345");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_345(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_345");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF141;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_345");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_348(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_348");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ge(context, EF142.get(context), __STR_LIT_542).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER_LAND, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_ABSCHLUSS3STELLER_LAND.land, 1, EF1.get(context))}, context), EF142.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_ABSCHLUSS3STELLER, new FeldDeskriptorInterface[] {__material_ref_ABSCHLUSS3STELLER.key}, new SatzFilter.FilterBedingung[] {}, context), EF142.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_348");
+ fehler_SIG_348(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_348", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_348");
+ this.fehler_SIG_348(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_348");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_348(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_348");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF142;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_348");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_351(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_351");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF143.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF143.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF143.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF143.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_351");
+ fehler_SIG_351(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_351", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_351");
+ this.fehler_SIG_351(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_351");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_351(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_351");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF143;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_351");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_354(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_354");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF144.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF144.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF144.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF144.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_354");
+ fehler_SIG_354(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_354", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_354");
+ this.fehler_SIG_354(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_354");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_354(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_354");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF144;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_354");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_357(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_357");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF145.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_1)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF145.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH.key}, new SatzFilter.FilterBedingung[] {}, context), EF145.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACH_LAND, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACH_LAND.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACH_LAND.land, 1, EF1.get(context))}, context), EF145.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_357");
+ fehler_SIG_357(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_357", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_357");
+ this.fehler_SIG_357(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_357");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_357(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_357");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF145;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_357");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_360(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_360");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF148.get(context))), __NUM_LIT_2).asBoolean() && OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF148.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_1, __NUM_LIT_2, __NUM_LIT_8)}), EF148.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_360");
+ fehler_SIG_360(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_360", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_360");
+ this.fehler_SIG_360(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_360");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_360(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_360");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF148;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_360");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_363(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_363");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF149.get(context))), __NUM_LIT_4).asBoolean() && OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF149.get(context)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF149.get(context))).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF149.get(context), EF3.get(context)).asBoolean() && OperatorLib.ne(context, EF149.get(context), OperatorLib.minus(context, EF3.get(context), __NUM_LIT_1)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF149.get(context), OperatorLib.plus(context, EF3.get(context), __NUM_LIT_1)).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_363");
+ fehler_SIG_363(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_363", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_363");
+ this.fehler_SIG_363(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_363");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_363(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_363");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF149;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_363");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_366(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_366");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF150.get(context))), __NUM_LIT_1).asBoolean() && OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF150.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF150.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_366");
+ fehler_SIG_366(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_366", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_366");
+ this.fehler_SIG_366(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_366");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_366(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_366");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF150;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_366");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_SIG_369(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung SIG_369");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF151.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.ne(context, EF151.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF151.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.not(context, FunctionLib.NUMERISCH(context, vf.valueFor(EF151.get(context)))).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540), new SingleValueRange(__STR_LIT_542)}), EF151.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: SIG_369");
+ fehler_SIG_369(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: SIG_369", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): SIG_369");
+ this.fehler_SIG_369(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: SIG_369");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_SIG_369(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("SIG_369");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF151;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#SIG_369");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_003K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_003K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_1)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF3.get(context), EF18.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF30.get(context), __STR_LIT_41).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF41.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF41.get(context), __STR_LIT_24).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF45.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF45.get(context), __STR_LIT_16).asBoolean()).asBoolean() || OperatorLib.eq(context, EF45.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.gt(context, EF45.get(context), __STR_LIT_41).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_003K");
+ fehler_UF_003K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_003K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_003K");
+ this.fehler_UF_003K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_003K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_003K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_003K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_003K" : "#UF_003K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_006M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_006M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF10U1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_KREISE, new FeldDeskriptorInterface[] {__material_ref_KREISE.key}, new SatzFilter.FilterBedingung[] {}, context), FunctionLib.KONKATENIEREN(context, vf.valueFor(EF10U1.get(context)), vf.valueFor(EF10U2.get(context))))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF10U1.get(context), __STR_LIT_552).asBoolean() && OperatorLib.ne(context, EF10U2.get(context), __STR_LIT_553).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_006M");
+ fehler_UF_006M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_006M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_006M");
+ this.fehler_UF_006M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_006M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_006M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_006M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF10U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_006M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_009M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_009M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF10U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STAAT, new FeldDeskriptorInterface[] {__material_ref_STAAT.key}, new SatzFilter.FilterBedingung[] {}, context), EF10U2.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF10U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.eq(context, EF10U2.get(context), __STR_LIT_15).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_009M");
+ fehler_UF_009M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_009M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_009M");
+ this.fehler_UF_009M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_009M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_009M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_009M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF10U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_009M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_012M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_012M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF11U1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_KREISE, new FeldDeskriptorInterface[] {__material_ref_KREISE.key}, new SatzFilter.FilterBedingung[] {}, context), FunctionLib.KONKATENIEREN(context, vf.valueFor(EF11U1.get(context)), vf.valueFor(EF11U2.get(context))))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_552).asBoolean() && OperatorLib.ne(context, EF11U2.get(context), __STR_LIT_553).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_012M");
+ fehler_UF_012M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_012M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_012M");
+ this.fehler_UF_012M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_012M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_012M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_012M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF11U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_012M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_015M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_015M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STAAT, new FeldDeskriptorInterface[] {__material_ref_STAAT.key}, new SatzFilter.FilterBedingung[] {}, context), EF11U2.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF11U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.eq(context, EF11U2.get(context), __STR_LIT_15).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_015M");
+ fehler_UF_015M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_015M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_015M");
+ this.fehler_UF_015M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_015M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_015M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_015M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF11U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_015M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_018M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_018M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF111U1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_KREISE, new FeldDeskriptorInterface[] {__material_ref_KREISE.key}, new SatzFilter.FilterBedingung[] {}, context), FunctionLib.KONKATENIEREN(context, vf.valueFor(EF111U1.get(context)), vf.valueFor(EF111U2.get(context))))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_552).asBoolean() && OperatorLib.ne(context, EF111U2.get(context), __STR_LIT_553).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_018M");
+ fehler_UF_018M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_018M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_018M");
+ this.fehler_UF_018M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_018M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_018M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_018M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF111U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_018M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_021M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_021M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STAAT, new FeldDeskriptorInterface[] {__material_ref_STAAT.key}, new SatzFilter.FilterBedingung[] {}, context), EF111U2.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean() && OperatorLib.eq(context, EF111U2.get(context), __STR_LIT_15).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_021M");
+ fehler_UF_021M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_021M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_021M");
+ this.fehler_UF_021M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_021M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_021M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_021M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF111U2;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_021M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_024K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_024K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.eq(context, EF12.get(context), __STR_LIT_2).asBoolean() && OperatorLib.eq(context, EF9.get(context), __STR_LIT_15).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_024K");
+ fehler_UF_024K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_024K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_024K");
+ this.fehler_UF_024K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_024K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_024K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_024K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_024K" : "#UF_024K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_027M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_027M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), __STR_LIT_555).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF12.get(context), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_29)}), EF24.get(context)).asBoolean() || OperatorLib.ne(context, EF32.get(context), __STR_LIT_555).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF32.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.eq(context, EF12.get(context), __STR_LIT_2).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_29)}), EF24.get(context)).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF32.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_027M");
+ fehler_UF_027M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_027M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_027M");
+ this.fehler_UF_027M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_027M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_027M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_027M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_027M" : "#UF_027M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_033M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_033M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), __STR_LIT_555).asBoolean() || OperatorLib.eq(context, EF34.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF47.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF49.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF60.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF61.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF62.get(context), __STR_LIT_555).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_13).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF127.get(context), __STR_LIT_555).asBoolean() || OperatorLib.eq(context, EF128.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF129.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF143.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF144.get(context), __STR_LIT_555).asBoolean()).asBoolean() || OperatorLib.eq(context, EF145.get(context), __STR_LIT_555).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF32.get(context)).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF34.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF36.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF47.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF49.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF51.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF60.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF61.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF62.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF127.get(context)).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF128.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF129.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF143.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF144.get(context)).asBoolean()).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_672)}), EF145.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_033M");
+ fehler_UF_033M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_033M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_033M");
+ this.fehler_UF_033M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_033M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_033M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_033M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_033M" : "#UF_033M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_036M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_036M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.eq(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF2.get(context)), vf.valueFor(EF3.get(context))), FunctionLib.KONKATENIEREN(context, vf.valueFor(EF17.get(context)), vf.valueFor(EF18.get(context)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.ne(context, EF4.get(context), EF16.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF2.get(context)), vf.valueFor(EF3.get(context))), FunctionLib.KONKATENIEREN(context, vf.valueFor(EF17.get(context)), vf.valueFor(EF18.get(context)))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_036M");
+ fehler_UF_036M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_036M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_036M");
+ this.fehler_UF_036M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_036M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_036M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_036M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_036M" : "#UF_036M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_042M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_042M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF26.get(context), __STR_LIT_12).asBoolean() && OperatorLib.ne(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean() && OperatorLib.eq(context, EF20.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF41.get(context), __STR_LIT_12).asBoolean() && OperatorLib.ne(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean() && OperatorLib.eq(context, EF20.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_042M");
+ fehler_UF_042M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_042M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_042M");
+ this.fehler_UF_042M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_042M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_042M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_042M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_042M" : "#UF_042M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_045M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_045M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.eq(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF17.get(context)), vf.valueFor(EF18.get(context))), FunctionLib.KONKATENIEREN(context, vf.valueFor(EF2.get(context)), vf.valueFor(EF3.get(context)))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean() && OperatorLib.ne(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF17.get(context)), vf.valueFor(EF18.get(context))), FunctionLib.KONKATENIEREN(context, vf.valueFor(EF2.get(context)), vf.valueFor(EF3.get(context)))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_045M");
+ fehler_UF_045M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_045M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_045M");
+ this.fehler_UF_045M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_045M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_045M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_045M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_045M" : "#UF_045M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_048M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_048M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF41.get(context)).asBoolean() && OperatorLib.ne(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_048M");
+ fehler_UF_048M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_048M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_048M");
+ this.fehler_UF_048M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_048M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_048M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_048M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_048M" : "#UF_048M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_051M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_051M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3)}), EF1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean()).asBoolean() && OperatorLib.eq(context, EF19.get(context), EF20.get(context)).asBoolean()).asBoolean() && OperatorLib.gt(context, EF19.get(context), __STR_LIT_43).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_051M");
+ fehler_UF_051M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_051M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_051M");
+ this.fehler_UF_051M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_051M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_051M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_051M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF19;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_051M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_054M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_054M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF26.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF30.get(context), __STR_LIT_17).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF45.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_054M");
+ fehler_UF_054M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_054M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_054M");
+ this.fehler_UF_054M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_054M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_054M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_054M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_054M" : "#UF_054M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_057M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_057M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_541)}), EF27.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), EF27.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_541)}), EF27.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_539)}), EF27.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_057M");
+ fehler_UF_057M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_057M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_057M");
+ this.fehler_UF_057M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_057M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_057M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_057M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_057M" : "#UF_057M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_060M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_060M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_541)}), EF42.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_539)}), EF42.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF41.get(context), __STR_LIT_21).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_541)}), EF42.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_29), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539), new SingleValueRange(__STR_LIT_541)}), EF42.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_060M");
+ fehler_UF_060M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_060M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_060M");
+ this.fehler_UF_060M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_060M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_060M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_060M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_060M" : "#UF_060M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_063M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_063M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.eq(context, EF19.get(context), EF20.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF26.get(context), __STR_LIT_21).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_21)}), EF41.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean() && OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() && OperatorLib.ne(context, EF20.get(context), __STR_LIT_41).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_063M");
+ fehler_UF_063M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_063M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_063M");
+ this.fehler_UF_063M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_063M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_063M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_063M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_063M" : "#UF_063M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_066M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_066M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean() || OperatorLib.eq(context, EF41.get(context), __STR_LIT_21).asBoolean()).asBoolean() && OperatorLib.eq(context, EF20.get(context), __STR_LIT_17).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_066M");
+ fehler_UF_066M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_066M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_066M");
+ this.fehler_UF_066M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_066M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_066M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_066M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF20;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_066M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_069K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_069K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_069K");
+ fehler_UF_069K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_069K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_069K");
+ this.fehler_UF_069K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_069K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_069K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_069K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_069K" : "#UF_069K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_072M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_072M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean() && OperatorLib.eq(context, EF19.get(context), __STR_LIT_41).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF26.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2)}), EF65U1.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF30.get(context), __STR_LIT_41).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19)}), EF41.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF65U1.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF45.get(context), __STR_LIT_41).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_072M");
+ fehler_UF_072M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_072M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_072M");
+ this.fehler_UF_072M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_072M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_072M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_072M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_072M" : "#UF_072M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_075M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_075M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_2).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF66.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_20).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF66.get(context), EF4.get(context)).asBoolean() || OperatorLib.eq(context, EF74.get(context), EF4.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_12).asBoolean() && vf.valueFor(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF74.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF74.get(context), EF4.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF64.get(context), __STR_LIT_21).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF66.get(context), EF4.get(context)).asBoolean() && OperatorLib.ne(context, EF74.get(context), EF4.get(context)).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF66.get(context), EF4.get(context)).asBoolean() && OperatorLib.eq(context, EF74.get(context), EF4.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF66.get(context), EF4.get(context)).asBoolean() && OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_075M");
+ fehler_UF_075M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_075M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_075M");
+ this.fehler_UF_075M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_075M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_075M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_075M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_075M" : "#UF_075M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_078M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_078M");
+ try
+ {
+ if(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_673), new SingleValueRange(__STR_LIT_565), new SingleValueRange(__STR_LIT_674), new SingleValueRange(__STR_LIT_675), new SingleValueRange(__STR_LIT_370), new SingleValueRange(__STR_LIT_373), new SingleValueRange(__STR_LIT_421), new SingleValueRange(__STR_LIT_374), new SingleValueRange(__STR_LIT_375), new SingleValueRange(__STR_LIT_376), new SingleValueRange(__STR_LIT_382), new SingleValueRange(__STR_LIT_378), new SingleValueRange(__STR_LIT_377), new SingleValueRange(__STR_LIT_676), new SingleValueRange(__STR_LIT_387), new SingleValueRange(__STR_LIT_677), new SingleValueRange(__STR_LIT_678), new SingleValueRange(__STR_LIT_679), new SingleValueRange(__STR_LIT_680), new SingleValueRange(__STR_LIT_410), new SingleValueRange(__STR_LIT_681), new SingleValueRange(__STR_LIT_422), new SingleValueRange(__STR_LIT_423), new SingleValueRange(__STR_LIT_682), new SingleValueRange(__STR_LIT_683), new SingleValueRange(__STR_LIT_684), new SingleValueRange(__STR_LIT_685), new SingleValueRange(__STR_LIT_686), new SingleValueRange(__STR_LIT_687), new SingleValueRange(__STR_LIT_688), new SingleValueRange(__STR_LIT_689), new SingleValueRange(__STR_LIT_690), new SingleValueRange(__STR_LIT_691), new SingleValueRange(__STR_LIT_692), new SingleValueRange(__STR_LIT_522), new SingleValueRange(__STR_LIT_521), new SingleValueRange(__STR_LIT_566), new SingleValueRange(__STR_LIT_693), new SingleValueRange(__STR_LIT_694), new SingleValueRange(__STR_LIT_695), new SingleValueRange(__STR_LIT_379), new SingleValueRange(__STR_LIT_381), new SingleValueRange(__STR_LIT_380), new SingleValueRange(__STR_LIT_696), new SingleValueRange(__STR_LIT_697), new SingleValueRange(__STR_LIT_698), new SingleValueRange(__STR_LIT_699), new SingleValueRange(__STR_LIT_567), new SingleValueRange(__STR_LIT_700), new SingleValueRange(__STR_LIT_568), new SingleValueRange(__STR_LIT_448), new SingleValueRange(__STR_LIT_447), new SingleValueRange(__STR_LIT_368), new SingleValueRange(__STR_LIT_369), new SingleValueRange(__STR_LIT_701), new SingleValueRange(__STR_LIT_361), new SingleValueRange(__STR_LIT_362), new SingleValueRange(__STR_LIT_435), new SingleValueRange(__STR_LIT_702), new SingleValueRange(__STR_LIT_703), new SingleValueRange(__STR_LIT_704), new SingleValueRange(__STR_LIT_705), new SingleValueRange(__STR_LIT_706), new SingleValueRange(__STR_LIT_707), new SingleValueRange(__STR_LIT_708), new SingleValueRange(__STR_LIT_709), new SingleValueRange(__STR_LIT_464), new SingleValueRange(__STR_LIT_710), new SingleValueRange(__STR_LIT_463), new SingleValueRange(__STR_LIT_285), new SingleValueRange(__STR_LIT_711), new SingleValueRange(__STR_LIT_712), new SingleValueRange(__STR_LIT_713), new SingleValueRange(__STR_LIT_714), new SingleValueRange(__STR_LIT_715), new SingleValueRange(__STR_LIT_569), new SingleValueRange(__STR_LIT_716), new SingleValueRange(__STR_LIT_717), new SingleValueRange(__STR_LIT_718), new SingleValueRange(__STR_LIT_472), new SingleValueRange(__STR_LIT_719), new SingleValueRange(__STR_LIT_720), new SingleValueRange(__STR_LIT_721), new SingleValueRange(__STR_LIT_475), new SingleValueRange(__STR_LIT_476), new SingleValueRange(__STR_LIT_722), new SingleValueRange(__STR_LIT_723), new SingleValueRange(__STR_LIT_570), new SingleValueRange(__STR_LIT_571), new SingleValueRange(__STR_LIT_505), new SingleValueRange(__STR_LIT_724), new SingleValueRange(__STR_LIT_504), new SingleValueRange(__STR_LIT_725), new SingleValueRange(__STR_LIT_517), new SingleValueRange(__STR_LIT_353), new SingleValueRange(__STR_LIT_726), new SingleValueRange(__STR_LIT_727), new SingleValueRange(__STR_LIT_372), new SingleValueRange(__STR_LIT_728), new SingleValueRange(__STR_LIT_729), new SingleValueRange(__STR_LIT_730), new SingleValueRange(__STR_LIT_731), new SingleValueRange(__STR_LIT_732), new SingleValueRange(__STR_LIT_733), new SingleValueRange(__STR_LIT_734), new SingleValueRange(__STR_LIT_735), new SingleValueRange(__STR_LIT_511), new SingleValueRange(__STR_LIT_736), new SingleValueRange(__STR_LIT_510), new SingleValueRange(__STR_LIT_737), new SingleValueRange(__STR_LIT_738), new SingleValueRange(__STR_LIT_739), new SingleValueRange(__STR_LIT_740), new SingleValueRange(__STR_LIT_741), new SingleValueRange(__STR_LIT_742), new SingleValueRange(__STR_LIT_743), new SingleValueRange(__STR_LIT_744), new SingleValueRange(__STR_LIT_745), new SingleValueRange(__STR_LIT_746), new SingleValueRange(__STR_LIT_747), new SingleValueRange(__STR_LIT_748), new SingleValueRange(__STR_LIT_749), new SingleValueRange(__STR_LIT_750), new SingleValueRange(__STR_LIT_751), new SingleValueRange(__STR_LIT_752)}), EF4.get(context))).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF28.get(context), __STR_LIT_20).asBoolean() || OperatorLib.eq(context, EF43.get(context), __STR_LIT_20).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_078M");
+ fehler_UF_078M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_078M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_078M");
+ this.fehler_UF_078M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_078M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_078M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_078M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF4;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_078M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_084M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_084M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_18)}), EF28.get(context)).asBoolean() || OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_18)}), EF43.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF21.get(context), __STR_LIT_29).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_084M");
+ fehler_UF_084M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_084M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_084M");
+ this.fehler_UF_084M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_084M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_084M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_084M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF21;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_084M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_087K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_087K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, EF25.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ge(context, EF25.get(context), EF19.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_087K");
+ fehler_UF_087K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_087K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_087K");
+ this.fehler_UF_087K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_087K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_087K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_087K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_087K" : "#UF_087K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_090M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_090M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.eq(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_530)}), EF1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_21).asBoolean()).asBoolean() && OperatorLib.lt(context, EF20.get(context), EF19.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF30.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_090M");
+ fehler_UF_090M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_090M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_090M");
+ this.fehler_UF_090M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_090M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_090M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_090M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_090M" : "#UF_090M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_093K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_093K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_516).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755)}), EF31.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755)}), EF46.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF31.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF46.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF31.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF46.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_3, __NUM_LIT_4, __NUM_LIT_30)}), EF30.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_3, __NUM_LIT_4, __NUM_LIT_30)}), EF45.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21), new SingleValueRange(__STR_LIT_18), new SingleValueRange(__STR_LIT_19), new SingleValueRange(__STR_LIT_537), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_093K");
+ fehler_UF_093K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_093K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_093K");
+ this.fehler_UF_093K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_093K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_093K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_093K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF91;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_093K");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_096M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_096M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_516).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755)}), EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755)}), EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_765), new SingleValueRange(__STR_LIT_766), new SingleValueRange(__STR_LIT_767), new SingleValueRange(__STR_LIT_768), new SingleValueRange(__STR_LIT_769), new SingleValueRange(__STR_LIT_770), new SingleValueRange(__STR_LIT_771), new SingleValueRange(__STR_LIT_548), new SingleValueRange(__STR_LIT_772), new SingleValueRange(__STR_LIT_773), new SingleValueRange(__STR_LIT_774), new SingleValueRange(__STR_LIT_775), new SingleValueRange(__STR_LIT_776), new SingleValueRange(__STR_LIT_777), new SingleValueRange(__STR_LIT_778), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_779)}), EF31.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_765), new SingleValueRange(__STR_LIT_766), new SingleValueRange(__STR_LIT_767), new SingleValueRange(__STR_LIT_768), new SingleValueRange(__STR_LIT_769), new SingleValueRange(__STR_LIT_770), new SingleValueRange(__STR_LIT_771), new SingleValueRange(__STR_LIT_548), new SingleValueRange(__STR_LIT_772), new SingleValueRange(__STR_LIT_773), new SingleValueRange(__STR_LIT_774), new SingleValueRange(__STR_LIT_775), new SingleValueRange(__STR_LIT_776), new SingleValueRange(__STR_LIT_777), new SingleValueRange(__STR_LIT_778), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_779)}), EF46.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_794)}), EF31.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_794)}), EF46.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF31.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF46.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance())}), EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_765), new SingleValueRange(__STR_LIT_766), new SingleValueRange(__STR_LIT_767), new SingleValueRange(__STR_LIT_768), new SingleValueRange(__STR_LIT_769), new SingleValueRange(__STR_LIT_770), new SingleValueRange(__STR_LIT_771), new SingleValueRange(__STR_LIT_548), new SingleValueRange(__STR_LIT_772), new SingleValueRange(__STR_LIT_773), new SingleValueRange(__STR_LIT_774), new SingleValueRange(__STR_LIT_775), new SingleValueRange(__STR_LIT_776), new SingleValueRange(__STR_LIT_777), new SingleValueRange(__STR_LIT_778), new SingleValueRange(__STR_LIT_779)}), EF31.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_765), new SingleValueRange(__STR_LIT_766), new SingleValueRange(__STR_LIT_767), new SingleValueRange(__STR_LIT_768), new SingleValueRange(__STR_LIT_769), new SingleValueRange(__STR_LIT_770), new SingleValueRange(__STR_LIT_771), new SingleValueRange(__STR_LIT_548), new SingleValueRange(__STR_LIT_772), new SingleValueRange(__STR_LIT_773), new SingleValueRange(__STR_LIT_774), new SingleValueRange(__STR_LIT_775), new SingleValueRange(__STR_LIT_776), new SingleValueRange(__STR_LIT_777), new SingleValueRange(__STR_LIT_778), new SingleValueRange(__STR_LIT_779)}), EF46.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544)}), EF1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_794)}), EF31.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544)}), EF1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_794)}), EF46.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF31.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF31.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_13).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_759), new SingleValueRange(__STR_LIT_760), new SingleValueRange(__STR_LIT_761), new SingleValueRange(__STR_LIT_762), new SingleValueRange(__STR_LIT_763), new SingleValueRange(__STR_LIT_764)}), EF46.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_72), new SingleValueRange(__NUM_LIT_33)}), EF46.get(context)).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() || OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF91.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF91.get(context)).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF100.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF100.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_096M");
+ fehler_UF_096M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_096M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_096M");
+ this.fehler_UF_096M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_096M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_096M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_096M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_096M" : "#UF_096M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_099K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_099K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF91.get(context), EF31.get(context)).asBoolean() || OperatorLib.eq(context, EF100.get(context), EF31.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF91.get(context), EF46.get(context)).asBoolean() || OperatorLib.eq(context, EF100.get(context), EF46.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_099K");
+ fehler_UF_099K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_099K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_099K");
+ this.fehler_UF_099K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_099K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_099K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_099K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_099K" : "#UF_099K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_102M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_102M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_43).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), __STR_LIT_795).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF46.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF47.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_43).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF46.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF47.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_102M");
+ fehler_UF_102M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_102M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_102M");
+ this.fehler_UF_102M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_102M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_102M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_102M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_102M" : "#UF_102M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_105M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_105M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF91.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF92.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), EF101.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF91.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), EF92.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF46.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), EF101.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_105M");
+ fehler_UF_105M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_105M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_105M");
+ this.fehler_UF_105M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_105M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_105M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_105M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_105M" : "#UF_105M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_108K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_108K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_804), new SingleValueRange(__STR_LIT_805)}), FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), EF34.get(context)).asBoolean() || OperatorLib.eq(context, EF32.get(context), EF36.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF34.get(context), EF36.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_804), new SingleValueRange(__STR_LIT_805)}), FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), EF49.get(context)).asBoolean() || OperatorLib.eq(context, EF47.get(context), EF51.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF49.get(context), EF51.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF59.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_804), new SingleValueRange(__STR_LIT_805)}), FunctionLib.TEIL(context, vf.valueFor(EF59.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF60.get(context), EF61.get(context)).asBoolean() || OperatorLib.eq(context, EF60.get(context), EF62.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF61.get(context), EF62.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF69.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_804), new SingleValueRange(__STR_LIT_805)}), FunctionLib.TEIL(context, vf.valueFor(EF69.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF70.get(context), EF71.get(context)).asBoolean() || OperatorLib.eq(context, EF70.get(context), EF72.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF71.get(context), EF72.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF77.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_804), new SingleValueRange(__STR_LIT_805)}), FunctionLib.TEIL(context, vf.valueFor(EF77.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF78.get(context), EF79.get(context)).asBoolean() || OperatorLib.eq(context, EF78.get(context), EF80.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF79.get(context), EF80.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF91.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), FunctionLib.TEIL(context, vf.valueFor(EF91.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF93.get(context)).asBoolean() || OperatorLib.eq(context, EF92.get(context), EF94.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF94.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF100.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), FunctionLib.TEIL(context, vf.valueFor(EF100.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), EF102.get(context)).asBoolean() || OperatorLib.eq(context, EF101.get(context), EF103.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF102.get(context), EF103.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF127.get(context), EF128.get(context)).asBoolean() || OperatorLib.eq(context, EF127.get(context), EF129.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF128.get(context), EF129.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43)}), FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF143.get(context), EF144.get(context)).asBoolean() || OperatorLib.eq(context, EF143.get(context), EF145.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF144.get(context), EF145.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_108K");
+ fehler_UF_108K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_108K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_108K");
+ this.fehler_UF_108K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_108K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_108K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_108K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_108K" : "#UF_108K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_114M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_114M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF22.get(context), __STR_LIT_29).asBoolean() && OperatorLib.eq(context, EF23.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF23.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF22.get(context), __STR_LIT_29).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_114M");
+ fehler_UF_114M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_114M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_114M");
+ this.fehler_UF_114M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_114M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_114M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_114M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_114M" : "#UF_114M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_117M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_117M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF28.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF29.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_117M");
+ fehler_UF_117M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_117M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_117M");
+ this.fehler_UF_117M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_117M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_117M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_117M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_117M" : "#UF_117M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_120M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_120M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20)}), EF12.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF43.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF44.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_120M");
+ fehler_UF_120M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_120M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_120M");
+ this.fehler_UF_120M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_120M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_120M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_120M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_120M" : "#UF_120M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_123M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_123M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF12.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_123M");
+ fehler_UF_123M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_123M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_123M");
+ this.fehler_UF_123M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_123M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_123M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_123M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF56;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_123M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_126K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_126K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF56.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF59.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF59.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF59.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_126K");
+ fehler_UF_126K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_126K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_126K");
+ this.fehler_UF_126K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_126K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_126K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_126K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_126K" : "#UF_126K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_129K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_129K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, EF26.get(context), __STR_LIT_19).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context)).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF66.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF66.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context))).asBoolean() || OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF69.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context))).asBoolean() || OperatorLib.eq(context, EF66.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context))).asBoolean() || OperatorLib.eq(context, EF66.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF74.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context))).asBoolean() || OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF77.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context))).asBoolean() || OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_21)}), EF64.get(context))).asBoolean() || OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_129K");
+ fehler_UF_129K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_129K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_129K");
+ this.fehler_UF_129K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_129K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_129K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_129K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_129K" : "#UF_129K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_132K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_132K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_132K");
+ fehler_UF_132K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_132K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_132K");
+ this.fehler_UF_132K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_132K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_132K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_132K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_132K" : "#UF_132K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_138M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_138M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_138M");
+ fehler_UF_138M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_138M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_138M");
+ this.fehler_UF_138M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_138M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_138M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_138M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_138M" : "#UF_138M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_141M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_141M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF31.get(context))}, context), EF32.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF31.get(context))}, context), EF34.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF31.get(context))}, context), EF36.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF31.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.vollteildual, 1, EF29.get(context))}, context), EF32.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF31.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.vollteildual, 1, EF29.get(context))}, context), EF34.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF31.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.vollteildual, 1, EF29.get(context))}, context), EF36.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_141M");
+ fehler_UF_141M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_141M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_141M");
+ this.fehler_UF_141M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_141M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_141M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_141M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_141M" : "#UF_141M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_144M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_144M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF46.get(context))}, context), EF47.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF46.get(context))}, context), EF49.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF46.get(context))}, context), EF51.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF46.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.vollteildual, 1, EF44.get(context))}, context), EF47.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF46.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.vollteildual, 1, EF44.get(context))}, context), EF49.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF4.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF46.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.vollteildual, 1, EF44.get(context))}, context), EF51.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_144M");
+ fehler_UF_144M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_144M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_144M");
+ this.fehler_UF_144M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_144M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_144M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_144M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_144M" : "#UF_144M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_147M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_147M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_22), new SingleValueRange(__STR_LIT_23)}), EF56.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context))}, context), EF56.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF56.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF59.get(context))}, context), EF60.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF56.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF59.get(context))}, context), EF61.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF56.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF59.get(context))}, context), EF62.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_147M");
+ fehler_UF_147M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_147M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_147M");
+ this.fehler_UF_147M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_147M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_147M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_147M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_147M" : "#UF_147M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_150K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_150K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context))}, context), EF66.get(context)).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF66.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF69.get(context))}, context), EF70.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF66.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF69.get(context))}, context), EF71.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF66.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF69.get(context))}, context), EF72.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_150K");
+ fehler_UF_150K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_150K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_150K");
+ this.fehler_UF_150K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_150K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_150K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_150K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_150K" : "#UF_150K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_153K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_153K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.key}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context))}, context), EF74.get(context)).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF74.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF77.get(context))}, context), EF78.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF74.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF77.get(context))}, context), EF79.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, EF74.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF77.get(context))}, context), EF80.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_153K");
+ fehler_UF_153K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_153K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_153K");
+ this.fehler_UF_153K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_153K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_153K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_153K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_153K" : "#UF_153K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_156M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_156M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF126.get(context))}, context), EF127.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_156M");
+ fehler_UF_156M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_156M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_156M");
+ this.fehler_UF_156M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_156M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_156M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_156M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF127;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_156M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_159M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_159M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean() && OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF142.get(context))}, context), EF143.get(context))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_159M");
+ fehler_UF_159M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_159M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_159M");
+ this.fehler_UF_159M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_159M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_159M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_159M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF143;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_159M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_162K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_162K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF134.get(context), __STR_LIT_2).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), EF126.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF127.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF127.get(context)).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF127.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF127.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF128.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF128.get(context)).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF128.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF128.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF129.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF129.get(context)).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF129.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF129.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF150.get(context), __STR_LIT_2).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), EF142.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF143.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF143.get(context)).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF143.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF143.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF144.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF144.get(context)).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF144.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF144.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF145.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF145.get(context)).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF145.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF145.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF134.get(context), __STR_LIT_2).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF100.get(context), EF126.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF127.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), EF127.get(context)).asBoolean() || OperatorLib.eq(context, EF102.get(context), EF127.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF103.get(context), EF127.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF128.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), EF128.get(context)).asBoolean() || OperatorLib.eq(context, EF102.get(context), EF128.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF103.get(context), EF128.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF129.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), EF129.get(context)).asBoolean() || OperatorLib.eq(context, EF102.get(context), EF129.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF103.get(context), EF129.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF150.get(context), __STR_LIT_2).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF100.get(context), EF142.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF143.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), EF143.get(context)).asBoolean() || OperatorLib.eq(context, EF102.get(context), EF143.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF103.get(context), EF143.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF144.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), EF144.get(context)).asBoolean() || OperatorLib.eq(context, EF102.get(context), EF144.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF103.get(context), EF144.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF145.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF101.get(context), EF145.get(context)).asBoolean() || OperatorLib.eq(context, EF102.get(context), EF145.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF103.get(context), EF145.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_162K");
+ fehler_UF_162K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_162K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_162K");
+ this.fehler_UF_162K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_162K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_162K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_162K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_162K" : "#UF_162K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_165M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_165M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.not(context, prg_EIG_A(context)).asBoolean() && OperatorLib.eq(context, EF4.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.not(context, prg_EIG_A(context)).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_22), new SingleValueRange(__STR_LIT_23)}), EF4.get(context))).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, prg_fkt_UF_165M(context), __STR_LIT_29).asBoolean() || OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_HOCHSCHULSTANDORT, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULSTANDORT.bundesland}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULSTANDORT.key, 1, prg_fkt_UF_165M(context))}, context), EF1.get(context))).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_165M");
+ fehler_UF_165M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_165M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_165M");
+ this.fehler_UF_165M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_165M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_165M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_165M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF4;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_165M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_168K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_168K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.le(context, EF31.get(context), __STR_LIT_806).asBoolean() || OperatorLib.ge(context, EF31.get(context), __STR_LIT_542).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF126.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF127.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), EF127.get(context)).asBoolean() || OperatorLib.eq(context, EF34.get(context), EF127.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), EF127.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF128.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), EF128.get(context)).asBoolean() || OperatorLib.eq(context, EF34.get(context), EF128.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), EF128.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF129.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), EF129.get(context)).asBoolean() || OperatorLib.eq(context, EF34.get(context), EF129.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), EF129.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF26.get(context)).asBoolean() && OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.le(context, EF31.get(context), __STR_LIT_806).asBoolean() || OperatorLib.ge(context, EF31.get(context), __STR_LIT_542).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF142.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF143.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), EF143.get(context)).asBoolean() || OperatorLib.eq(context, EF34.get(context), EF143.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), EF143.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF144.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), EF144.get(context)).asBoolean() || OperatorLib.eq(context, EF34.get(context), EF144.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), EF144.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF145.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF32.get(context), EF145.get(context)).asBoolean() || OperatorLib.eq(context, EF34.get(context), EF145.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF36.get(context), EF145.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean() && OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.le(context, EF46.get(context), __STR_LIT_806).asBoolean() || OperatorLib.ge(context, EF46.get(context), __STR_LIT_542).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF126.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF127.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), EF127.get(context)).asBoolean() || OperatorLib.eq(context, EF49.get(context), EF127.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), EF127.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF128.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), EF128.get(context)).asBoolean() || OperatorLib.eq(context, EF49.get(context), EF128.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), EF128.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF129.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), EF129.get(context)).asBoolean() || OperatorLib.eq(context, EF49.get(context), EF129.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), EF129.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2), new SingleValueRange(__STR_LIT_21)}), EF41.get(context)).asBoolean() && OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.le(context, EF46.get(context), __STR_LIT_806).asBoolean() || OperatorLib.ge(context, EF46.get(context), __STR_LIT_542).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), EF142.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF143.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), EF143.get(context)).asBoolean() || OperatorLib.eq(context, EF49.get(context), EF143.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), EF143.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF144.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), EF144.get(context)).asBoolean() || OperatorLib.eq(context, EF49.get(context), EF144.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), EF144.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF145.get(context), __STR_LIT_14).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF47.get(context), EF145.get(context)).asBoolean() || OperatorLib.eq(context, EF49.get(context), EF145.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF51.get(context), EF145.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_168K");
+ fehler_UF_168K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_168K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_168K");
+ this.fehler_UF_168K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_168K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_168K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_168K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_168K" : "#UF_168K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_171M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_171M");
+ try
+ {
+ if(OperatorLib.gt(context, EF122.get(context), EF121.get(context)).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_171M");
+ fehler_UF_171M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_171M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_171M");
+ this.fehler_UF_171M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_171M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_171M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_171M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF122;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_171M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_174K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_174K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.gt(context, EF121.get(context), __STR_LIT_17).asBoolean() && OperatorLib.eq(context, EF122.get(context), EF121.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_174K");
+ fehler_UF_174K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_174K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_174K");
+ this.fehler_UF_174K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_174K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_174K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_174K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF122;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_174K");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_177M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_177M");
+ try
+ {
+ if(OperatorLib.gt(context, EF138.get(context), EF137.get(context)).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_177M");
+ fehler_UF_177M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_177M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_177M");
+ this.fehler_UF_177M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_177M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_177M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_177M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF138;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_177M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_180K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_180K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.gt(context, EF137.get(context), __STR_LIT_17).asBoolean() && OperatorLib.eq(context, EF138.get(context), EF137.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_180K");
+ fehler_UF_180K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_180K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_180K");
+ this.fehler_UF_180K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_180K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_180K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_180K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF138;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_180K");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_183M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_183M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF122.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF123.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF125.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF123.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF125.get(context)))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF122.get(context)))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF138.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF139.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF141.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF139.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF141.get(context)))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF138.get(context)))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_183M");
+ fehler_UF_183M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_183M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_183M");
+ this.fehler_UF_183M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_183M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_183M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_183M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_183M" : "#UF_183M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_186M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_186M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF124.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF122.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF124.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF122.get(context)))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF140.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF138.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF140.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF138.get(context)))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_186M");
+ fehler_UF_186M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_186M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_186M");
+ this.fehler_UF_186M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_186M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_186M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_186M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_186M" : "#UF_186M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_189K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_189K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF109.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.ge(context, OperatorLib.minus(context, EF109.get(context), EF8U2.get(context)), __NUM_LIT_63).asBoolean() && OperatorLib.le(context, OperatorLib.minus(context, EF109.get(context), EF8U2.get(context)), __NUM_LIT_75).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_189K");
+ fehler_UF_189K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_189K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_189K");
+ this.fehler_UF_189K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_189K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_189K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_189K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_189K" : "#UF_189K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_191M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_191M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), OperatorLib.plus(context, OperatorLib.div(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), __NUM_LIT_2), OperatorLib.div(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF83.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF86.get(context)))), __NUM_LIT_8))), __NUM_LIT_63).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_191M");
+ fehler_UF_191M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_191M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_191M");
+ this.fehler_UF_191M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_191M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_191M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_191M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_191M" : "#UF_191M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_194K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_194K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && OperatorLib.ge(context, OperatorLib.minus(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), OperatorLib.plus(context, OperatorLib.div(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), __NUM_LIT_2), OperatorLib.div(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF83.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF86.get(context)))), __NUM_LIT_8))), __NUM_LIT_63).asBoolean()).asBoolean() && OperatorLib.le(context, OperatorLib.minus(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), OperatorLib.plus(context, OperatorLib.div(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), __NUM_LIT_2), OperatorLib.div(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF83.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF86.get(context)))), __NUM_LIT_8))), __NUM_LIT_75).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_194K");
+ fehler_UF_194K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_194K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_194K");
+ this.fehler_UF_194K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_194K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_194K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_194K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_194K" : "#UF_194K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_197M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_197M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF4.get(context), __STR_LIT_807).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF18.get(context), EF8U2.get(context)), __NUM_LIT_63).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF4.get(context), __STR_LIT_807).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF18.get(context), EF8U2.get(context)), __NUM_LIT_60).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_197M");
+ fehler_UF_197M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_197M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_197M");
+ this.fehler_UF_197M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_197M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_197M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_197M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_197M" : "#UF_197M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_200K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_200K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ge(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), __NUM_LIT_63).asBoolean()).asBoolean() && OperatorLib.le(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), __NUM_LIT_75).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_200K");
+ fehler_UF_200K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_200K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_200K");
+ this.fehler_UF_200K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_200K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_200K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_200K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_200K" : "#UF_200K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_203M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_203M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF4.get(context), __STR_LIT_807).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF109.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF109.get(context), EF8U2.get(context)), __NUM_LIT_63).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF4.get(context), __STR_LIT_807).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF109.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF109.get(context), EF8U2.get(context)), __NUM_LIT_60).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_203M");
+ fehler_UF_203M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_203M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_203M");
+ this.fehler_UF_203M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_203M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_203M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_203M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_203M" : "#UF_203M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_206K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_206K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF30.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.plus(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF20.get(context)))), OperatorLib.div(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF83.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF86.get(context)))), __NUM_LIT_6)), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF30.get(context)))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF45.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.plus(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF20.get(context)))), OperatorLib.div(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF83.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF86.get(context)))), __NUM_LIT_6)), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF45.get(context)))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_206K");
+ fehler_UF_206K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_206K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_206K");
+ this.fehler_UF_206K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_206K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_206K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_206K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_206K" : "#UF_206K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_209M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_209M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_3).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_808), new SingleValueRange(__STR_LIT_809)}), EF110.get(context)).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF19.get(context), EF20.get(context)), __NUM_LIT_4).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_808), new SingleValueRange(__STR_LIT_809)}), EF110.get(context)).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF19.get(context), EF20.get(context)), __NUM_LIT_2).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_209M");
+ fehler_UF_209M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_209M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_209M");
+ this.fehler_UF_209M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_209M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_209M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_209M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF19;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_209M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_211K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_211K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF109.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF3.get(context), OperatorLib.plus(context, OperatorLib.div(context, OperatorLib.minus(context, EF19.get(context), __NUM_LIT_1), __NUM_LIT_2), OperatorLib.div(context, OperatorLib.plus(context, EF83.get(context), EF86.get(context)), __NUM_LIT_8))), EF109.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_3)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF109.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF3.get(context), OperatorLib.plus(context, OperatorLib.div(context, OperatorLib.minus(context, EF19.get(context), __NUM_LIT_2), __NUM_LIT_2), OperatorLib.div(context, OperatorLib.plus(context, EF83.get(context), EF86.get(context)), __NUM_LIT_8))), EF109.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_211K");
+ fehler_UF_211K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_211K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_211K");
+ this.fehler_UF_211K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_211K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_211K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_211K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_211K" : "#UF_211K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_214K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_214K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_808), new SingleValueRange(__STR_LIT_809)}), EF110.get(context)).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_214K");
+ fehler_UF_214K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_214K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_214K");
+ this.fehler_UF_214K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_214K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_214K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_214K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_214K" : "#UF_214K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_217M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_217M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF91.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.le(context, EF97.get(context), EF18.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF100.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.le(context, EF106.get(context), EF18.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_217M");
+ fehler_UF_217M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_217M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_217M");
+ this.fehler_UF_217M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_217M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_217M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_217M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_217M" : "#UF_217M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_220M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_220M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF97.get(context))).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF106.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF106.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF97.get(context)))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_220M");
+ fehler_UF_220M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_220M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_220M");
+ this.fehler_UF_220M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_220M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_220M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_220M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_220M" : "#UF_220M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_223K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_223K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF91.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.plus(context, OperatorLib.minus(context, EF19.get(context), EF20.get(context)), OperatorLib.div(context, OperatorLib.plus(context, EF83.get(context), EF86.get(context)), __NUM_LIT_6)), __NUM_LIT_4).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_555), new SingleValueRange(__STR_LIT_796), new SingleValueRange(__STR_LIT_797), new SingleValueRange(__STR_LIT_798), new SingleValueRange(__STR_LIT_799), new SingleValueRange(__STR_LIT_800), new SingleValueRange(__STR_LIT_801), new SingleValueRange(__STR_LIT_802), new SingleValueRange(__STR_LIT_803)}), EF100.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.plus(context, OperatorLib.minus(context, EF19.get(context), EF20.get(context)), OperatorLib.div(context, OperatorLib.plus(context, EF83.get(context), EF86.get(context)), __NUM_LIT_6)), __NUM_LIT_4).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_223K");
+ fehler_UF_223K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_223K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_223K");
+ this.fehler_UF_223K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_223K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_223K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_223K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_223K" : "#UF_223K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_226K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_226K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF97.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF97.get(context), EF8U2.get(context)), __NUM_LIT_84).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF106.get(context))).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF106.get(context), EF8U2.get(context)), __NUM_LIT_84).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_226K");
+ fehler_UF_226K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_226K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_226K");
+ this.fehler_UF_226K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_226K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_226K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_226K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_226K" : "#UF_226K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_229M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_229M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF97.get(context))).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF97.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context)))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_229M");
+ fehler_UF_229M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_229M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_229M");
+ this.fehler_UF_229M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_229M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_229M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_229M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF97;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_229M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_231M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_231M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF97.get(context), EF3.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13)}), EF96.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF97.get(context), EF3.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530)}), EF96.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_231M");
+ fehler_UF_231M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_231M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_231M");
+ this.fehler_UF_231M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_231M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_231M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_231M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_231M" : "#UF_231M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_237M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_237M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF106.get(context), EF3.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13)}), EF105.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF106.get(context), EF3.get(context)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530)}), EF105.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_237M");
+ fehler_UF_237M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_237M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_237M");
+ this.fehler_UF_237M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_237M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_237M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_237M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_237M" : "#UF_237M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_243M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_243M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF133.get(context), __STR_LIT_25).asBoolean()).asBoolean() && OperatorLib.ne(context, EF132.get(context), __STR_LIT_16).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF133.get(context))).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.eq(context, EF3.get(context), EF133.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF132.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.eq(context, EF3.get(context), OperatorLib.minus(context, EF133.get(context), __NUM_LIT_1)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF132.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF133.get(context), __STR_LIT_25).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF133.get(context))).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF133.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context)))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF133.get(context))), OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_1)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_243M");
+ fehler_UF_243M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_243M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_243M");
+ this.fehler_UF_243M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_243M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_243M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_243M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_243M" : "#UF_243M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_251M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_251M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF149.get(context))).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF3.get(context), EF149.get(context)).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45)}), EF148.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF3.get(context), OperatorLib.minus(context, EF149.get(context), __NUM_LIT_1)).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544)}), EF148.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_12).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF149.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context)))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF2.get(context), __STR_LIT_20).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF149.get(context))), OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_1)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_251M");
+ fehler_UF_251M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_251M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_251M");
+ this.fehler_UF_251M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_251M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_251M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_251M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_251M" : "#UF_251M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_260M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_260M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF69.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF69.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(FunctionLib.TEIL(context, vf.valueFor(EF69.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF69.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF69.get(context), EF77.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF70.get(context), EF78.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF66.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF69.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(FunctionLib.TEIL(context, vf.valueFor(EF69.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF69.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF66.get(context), EF74.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF69.get(context), EF77.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF70.get(context), EF78.get(context)).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_260M");
+ fehler_UF_260M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_260M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_260M");
+ this.fehler_UF_260M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_260M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_260M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_260M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_260M" : "#UF_260M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_263M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_263M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.le(context, EF3.get(context), __STR_LIT_811).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF92.get(context), EF101.get(context)).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ge(context, EF3.get(context), __STR_LIT_812).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_47)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), EF100.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF92.get(context), EF101.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ge(context, EF3.get(context), __STR_LIT_812).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF1.get(context)).asBoolean()).asBoolean() && OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), EF100.get(context)).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF92.get(context), EF101.get(context)).asBoolean() || OperatorLib.eq(context, EF92.get(context), EF102.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF92.get(context), EF103.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF93.get(context), EF101.get(context)).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF102.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF93.get(context), EF103.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF94.get(context), EF101.get(context)).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF102.get(context)).asBoolean()).asBoolean() || OperatorLib.eq(context, EF94.get(context), EF103.get(context)).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_263M");
+ fehler_UF_263M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_263M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_263M");
+ this.fehler_UF_263M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_263M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_263M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_263M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_263M" : "#UF_263M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_266M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_266M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF126.get(context), EF142.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF127.get(context), EF143.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_266M");
+ fehler_UF_266M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_266M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_266M");
+ this.fehler_UF_266M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_266M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_266M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_266M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_266M" : "#UF_266M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_269M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_269M");
+ try
+ {
+ if(prg_EIG_C(context).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_269M");
+ fehler_UF_269M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_269M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_269M");
+ this.fehler_UF_269M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_269M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_269M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_269M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_269M" : "#UF_269M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_271M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_271M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF126.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF132.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF133.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF134.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF142.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF148.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF149.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF150.get(context), InvalidValue.instance()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_47)}), EF1.get(context)).asBoolean() && OperatorLib.eq(context, EF120.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_47)}), EF1.get(context)).asBoolean() && OperatorLib.eq(context, EF136.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF142.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_271M");
+ fehler_UF_271M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_271M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_271M");
+ this.fehler_UF_271M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_271M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_271M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_271M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_271M" : "#UF_271M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_274M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_274M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF98.get(context), __STR_LIT_12).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF99.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF98.get(context), __STR_LIT_12).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF99.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF99.get(context), __STR_LIT_542).asBoolean() && OperatorLib.ne(context, EF98.get(context), __STR_LIT_20).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF107.get(context), __STR_LIT_12).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF108.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ne(context, EF107.get(context), __STR_LIT_12).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF108.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF108.get(context), __STR_LIT_542).asBoolean() && OperatorLib.ne(context, EF107.get(context), __STR_LIT_20).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_274M");
+ fehler_UF_274M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_274M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_274M");
+ this.fehler_UF_274M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_274M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_274M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_274M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_274M" : "#UF_274M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_277M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_277M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF134.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF135.get(context))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_20)}), EF134.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF135.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF134.get(context), __STR_LIT_20).asBoolean() && OperatorLib.ne(context, EF135.get(context), __STR_LIT_542).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF135.get(context), __STR_LIT_542).asBoolean() && OperatorLib.ne(context, EF134.get(context), __STR_LIT_20).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF150.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF150.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF151.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(InvalidValue.instance()), new SingleValueRange(__STR_LIT_20)}), EF150.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_15), new SingleValueRange(__STR_LIT_531), new SingleValueRange(__STR_LIT_532), new SingleValueRange(__STR_LIT_533), new SingleValueRange(__STR_LIT_534), new SingleValueRange(__STR_LIT_538), new SingleValueRange(__STR_LIT_540)}), EF151.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF150.get(context), __STR_LIT_20).asBoolean() && OperatorLib.ne(context, EF151.get(context), __STR_LIT_542).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF151.get(context), __STR_LIT_542).asBoolean() && OperatorLib.ne(context, EF150.get(context), __STR_LIT_20).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_277M");
+ fehler_UF_277M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_277M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_277M");
+ this.fehler_UF_277M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_277M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_277M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_277M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_277M" : "#UF_277M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_283M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_283M");
+ try
+ {
+ if(vf.valueFor(OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_283M");
+ fehler_UF_283M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_283M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_283M");
+ this.fehler_UF_283M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_283M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_283M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_283M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF17;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_283M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_286M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_286M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_514), new SingleValueRange(__STR_LIT_651), new SingleValueRange(__STR_LIT_813)}), EF4.get(context))).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF32.get(context), __STR_LIT_814).asBoolean() || OperatorLib.ne(context, EF31.get(context), __STR_LIT_815).asBoolean()).asBoolean() || OperatorLib.ne(context, EF70.get(context), __STR_LIT_814).asBoolean()).asBoolean() || OperatorLib.ne(context, EF69.get(context), __STR_LIT_815).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_813)}), EF4.get(context)).asBoolean()).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF17.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context)))), OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF2.get(context))))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_514), new SingleValueRange(__STR_LIT_651), new SingleValueRange(__STR_LIT_813)}), EF4.get(context))).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF32.get(context), __STR_LIT_814).asBoolean() || OperatorLib.ne(context, EF31.get(context), __STR_LIT_815).asBoolean()).asBoolean() || OperatorLib.ne(context, EF70.get(context), __STR_LIT_814).asBoolean()).asBoolean() || OperatorLib.ne(context, EF69.get(context), __STR_LIT_815).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_813)}), EF4.get(context)).asBoolean()).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF3.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF18.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF17.get(context), __STR_LIT_20).asBoolean()).asBoolean() && OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.plus(context, OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF18.get(context))), __NUM_LIT_2), __NUM_LIT_1), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context)))), OperatorLib.plus(context, OperatorLib.mult(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF3.get(context))), __NUM_LIT_2), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF2.get(context))))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_286M");
+ fehler_UF_286M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_286M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_286M");
+ this.fehler_UF_286M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_286M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_286M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_286M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);FeatureVariable __refField = EF19;
+ fehler.setFehlerId(__refField.hierarchyAsString() + "#UF_286M");
+ fehler.setReferenzFeld(__refField);
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_289K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_289K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF20.get(context))), __NUM_LIT_85).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF25.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF25.get(context))), __NUM_LIT_85).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF30.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF30.get(context))), __NUM_LIT_85).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF45.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF45.get(context))), __NUM_LIT_85).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF121.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF121.get(context))), __NUM_LIT_85).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF122.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF122.get(context))), __NUM_LIT_85).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF137.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF137.get(context))), __NUM_LIT_85).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF138.get(context))).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF138.get(context))), __NUM_LIT_85).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_289K");
+ fehler_UF_289K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_289K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_289K");
+ this.fehler_UF_289K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_289K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_289K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_289K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_289K" : "#UF_289K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_292M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_292M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_32).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_549), new SingleValueRange(__STR_LIT_550), new SingleValueRange(__STR_LIT_551)}), EF110.get(context)).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36)}), EF110.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF111U1.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36)}), EF110.get(context))).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_37).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_549), new SingleValueRange(__STR_LIT_550), new SingleValueRange(__STR_LIT_551)}), EF110.get(context)).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36), new SingleValueRange(__STR_LIT_38), new SingleValueRange(__STR_LIT_39), new SingleValueRange(__STR_LIT_40)}), EF110.get(context)).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_41), new SingleValueRange(__STR_LIT_42), new SingleValueRange(__STR_LIT_544), new SingleValueRange(__STR_LIT_545), new SingleValueRange(__STR_LIT_13), new SingleValueRange(__STR_LIT_528), new SingleValueRange(__STR_LIT_43), new SingleValueRange(__STR_LIT_44), new SingleValueRange(__STR_LIT_3), new SingleValueRange(__STR_LIT_547), new SingleValueRange(__STR_LIT_530), new SingleValueRange(__STR_LIT_45), new SingleValueRange(__STR_LIT_46), new SingleValueRange(__STR_LIT_47), new SingleValueRange(__STR_LIT_1), new SingleValueRange(__STR_LIT_529)}), EF111U1.get(context)).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_34), new SingleValueRange(__STR_LIT_35), new SingleValueRange(__STR_LIT_36), new SingleValueRange(__STR_LIT_38), new SingleValueRange(__STR_LIT_39), new SingleValueRange(__STR_LIT_40)}), EF110.get(context))).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), __STR_LIT_33).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_292M");
+ fehler_UF_292M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_292M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_292M");
+ this.fehler_UF_292M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_292M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_292M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_292M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_292M" : "#UF_292M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_295M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_295M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF30.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF30.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context)))), __NUM_LIT_60).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF45.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF45.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context)))), __NUM_LIT_60).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean() && OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF121.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF121.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context)))), __NUM_LIT_60).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean() && OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF137.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF137.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context)))), __NUM_LIT_60).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_295M");
+ fehler_UF_295M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_295M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_295M");
+ this.fehler_UF_295M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_295M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_295M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_295M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_295M" : "#UF_295M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_296M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_296M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF20.get(context))), __NUM_LIT_2).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF19.get(context))), __NUM_LIT_2).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF20.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context)))).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_296M");
+ fehler_UF_296M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_296M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_296M");
+ this.fehler_UF_296M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_296M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_296M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_296M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_296M" : "#UF_296M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_298M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_298M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_45).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF126.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_86), new SingleValueRange(__NUM_LIT_36), new SequenceRange(__NUM_LIT_87, __NUM_LIT_88, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF126.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF121.get(context), __STR_LIT_17).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_45).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF142.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(__NUM_LIT_71, __NUM_LIT_31, __NUM_LIT_86), new SingleValueRange(__NUM_LIT_36), new SequenceRange(__NUM_LIT_87, __NUM_LIT_88, __NUM_LIT_73), new SingleValueRange(__NUM_LIT_22)}), EF142.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF137.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_298M");
+ fehler_UF_298M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_298M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_298M");
+ this.fehler_UF_298M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_298M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_298M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_298M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_298M" : "#UF_298M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_301K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_301K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.le(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_516).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_794), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(__STR_LIT_899)}), EF126.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.le(context, EF121.get(context), __NUM_LIT_5).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_794), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(__STR_LIT_899)}), EF142.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.le(context, EF137.get(context), __NUM_LIT_5).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_794), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(__STR_LIT_899)}), EF126.get(context)).asBoolean() && OperatorLib.le(context, EF121.get(context), __NUM_LIT_3).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_792), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_793), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_753), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_794), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_780), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_781), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_782), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_783), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_784), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_785), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_786), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_787), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_757), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_789), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_788), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_790), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_758), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_791), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_756), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_754), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_755), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(__STR_LIT_899)}), EF142.get(context)).asBoolean() && OperatorLib.le(context, EF137.get(context), __NUM_LIT_3).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.ge(context, FunctionLib.KONKATENIEREN(context, vf.valueFor(EF3.get(context)), vf.valueFor(EF2.get(context))), __STR_LIT_84).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_900), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_901), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_902), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_806), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_903), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_904), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_905), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_906), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_907), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_908), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_909), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_910), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_911), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_912), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_913), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_914), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_915), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_916), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_917), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_918), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_919), new SingleValueRange(__STR_LIT_899)}), EF126.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.le(context, EF121.get(context), __NUM_LIT_5).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_900), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_901), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_902), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_806), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_903), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_904), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_905), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_906), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_907), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_908), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_909), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_910), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_911), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_912), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_913), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_914), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_915), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_916), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_917), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_918), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_919), new SingleValueRange(__STR_LIT_899)}), EF142.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_539)}), FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1))).asBoolean()).asBoolean() && OperatorLib.le(context, EF137.get(context), __NUM_LIT_5).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_900), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_901), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_902), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_806), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_903), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_904), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_905), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_906), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_907), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_908), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_909), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_910), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_911), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_912), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_913), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_914), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_915), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_916), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_917), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_918), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_919), new SingleValueRange(__STR_LIT_899)}), EF126.get(context)).asBoolean() && OperatorLib.le(context, EF121.get(context), __NUM_LIT_3).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_816), new SingleValueRange(__STR_LIT_817), new SingleValueRange(__STR_LIT_818), new SingleValueRange(__STR_LIT_819), new SingleValueRange(__STR_LIT_820), new SingleValueRange(__STR_LIT_821), new SingleValueRange(__STR_LIT_822), new SingleValueRange(__STR_LIT_900), new SingleValueRange(__STR_LIT_823), new SingleValueRange(__STR_LIT_824), new SingleValueRange(__STR_LIT_901), new SingleValueRange(__STR_LIT_825), new SingleValueRange(__STR_LIT_826), new SingleValueRange(__STR_LIT_827), new SingleValueRange(__STR_LIT_828), new SingleValueRange(__STR_LIT_829), new SingleValueRange(__STR_LIT_830), new SingleValueRange(__STR_LIT_831), new SingleValueRange(__STR_LIT_832), new SingleValueRange(__STR_LIT_833), new SingleValueRange(__STR_LIT_834), new SingleValueRange(__STR_LIT_902), new SingleValueRange(__STR_LIT_835), new SingleValueRange(__STR_LIT_836), new SingleValueRange(__STR_LIT_837), new SingleValueRange(__STR_LIT_806), new SingleValueRange(__STR_LIT_838), new SingleValueRange(__STR_LIT_839), new SingleValueRange(__STR_LIT_840), new SingleValueRange(__STR_LIT_903), new SingleValueRange(__STR_LIT_841), new SingleValueRange(__STR_LIT_842), new SingleValueRange(__STR_LIT_843), new SingleValueRange(__STR_LIT_904), new SingleValueRange(__STR_LIT_844), new SingleValueRange(__STR_LIT_845), new SingleValueRange(__STR_LIT_846), new SingleValueRange(__STR_LIT_905), new SingleValueRange(__STR_LIT_847), new SingleValueRange(__STR_LIT_848), new SingleValueRange(__STR_LIT_849), new SingleValueRange(__STR_LIT_906), new SingleValueRange(__STR_LIT_850), new SingleValueRange(__STR_LIT_851), new SingleValueRange(__STR_LIT_852), new SingleValueRange(__STR_LIT_907), new SingleValueRange(__STR_LIT_853), new SingleValueRange(__STR_LIT_854), new SingleValueRange(__STR_LIT_855), new SingleValueRange(__STR_LIT_908), new SingleValueRange(__STR_LIT_856), new SingleValueRange(__STR_LIT_857), new SingleValueRange(__STR_LIT_858), new SingleValueRange(__STR_LIT_909), new SingleValueRange(__STR_LIT_859), new SingleValueRange(__STR_LIT_860), new SingleValueRange(__STR_LIT_861), new SingleValueRange(__STR_LIT_910), new SingleValueRange(__STR_LIT_862), new SingleValueRange(__STR_LIT_863), new SingleValueRange(__STR_LIT_864), new SingleValueRange(__STR_LIT_911), new SingleValueRange(__STR_LIT_865), new SingleValueRange(__STR_LIT_866), new SingleValueRange(__STR_LIT_867), new SingleValueRange(__STR_LIT_912), new SingleValueRange(__STR_LIT_868), new SingleValueRange(__STR_LIT_869), new SingleValueRange(__STR_LIT_870), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_913), new SingleValueRange(__STR_LIT_871), new SingleValueRange(__STR_LIT_872), new SingleValueRange(__STR_LIT_873), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_914), new SingleValueRange(__STR_LIT_874), new SingleValueRange(__STR_LIT_875), new SingleValueRange(__STR_LIT_876), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_915), new SingleValueRange(__STR_LIT_877), new SingleValueRange(__STR_LIT_878), new SingleValueRange(__STR_LIT_879), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_916), new SingleValueRange(__STR_LIT_880), new SingleValueRange(__STR_LIT_881), new SingleValueRange(__STR_LIT_882), new SingleValueRange(__STR_LIT_883), new SingleValueRange(__STR_LIT_884), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_917), new SingleValueRange(__STR_LIT_885), new SingleValueRange(__STR_LIT_886), new SingleValueRange(__STR_LIT_887), new SingleValueRange(__STR_LIT_888), new SingleValueRange(__STR_LIT_889), new SingleValueRange(__STR_LIT_890), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_918), new SingleValueRange(__STR_LIT_891), new SingleValueRange(__STR_LIT_810), new SingleValueRange(__STR_LIT_892), new SingleValueRange(__STR_LIT_893), new SingleValueRange(__STR_LIT_894), new SingleValueRange(__STR_LIT_895), new SingleValueRange(__STR_LIT_543), new SingleValueRange(__STR_LIT_896), new SingleValueRange(__STR_LIT_897), new SingleValueRange(__STR_LIT_898), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_919), new SingleValueRange(__STR_LIT_899)}), EF142.get(context)).asBoolean() && OperatorLib.le(context, EF137.get(context), __NUM_LIT_3).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_301K");
+ fehler_UF_301K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_301K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_301K");
+ this.fehler_UF_301K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_301K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_301K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_301K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_301K" : "#UF_301K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_307M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_307M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_43).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean() && OperatorLib.ne(context, EF134.get(context), __STR_LIT_2).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_43).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean() && OperatorLib.ne(context, EF150.get(context), __STR_LIT_2).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_43).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2)}), EF134.get(context))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_43).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2)}), EF150.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_307M");
+ fehler_UF_307M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_307M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_307M");
+ this.fehler_UF_307M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_307M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_307M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_307M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_307M" : "#UF_307M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_310M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_310M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_44).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __NUM_LIT_59).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean() && OperatorLib.ne(context, EF98.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __NUM_LIT_59).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF46.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, FunctionLib.TEIL(context, vf.valueFor(EF46.get(context)), vf.valueFor(__NUM_LIT_1), vf.valueFor(__NUM_LIT_1)), __STR_LIT_539).asBoolean()).asBoolean() && OperatorLib.ne(context, EF98.get(context), __STR_LIT_12).asBoolean()).asBoolean() && OperatorLib.ne(context, EF107.get(context), __STR_LIT_12).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_310M");
+ fehler_UF_310M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_310M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_310M");
+ this.fehler_UF_310M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_310M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_310M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_310M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_310M" : "#UF_310M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_313M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_313M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF82.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF83.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.eq(context, EF26.get(context), __STR_LIT_12).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF120.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.gt(context, EF121.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.gt(context, EF122.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.gt(context, EF123.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.gt(context, EF124.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.gt(context, EF125.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.ne(context, EF126.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF135.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_313M");
+ fehler_UF_313M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_313M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_313M");
+ this.fehler_UF_313M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_313M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_313M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_313M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_313M" : "#UF_313M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_316M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_316M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF31.get(context))), __NUM_LIT_3).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF31.get(context))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF31.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), EF46.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_316M");
+ fehler_UF_316M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_316M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_316M");
+ this.fehler_UF_316M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_316M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_316M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_316M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_316M" : "#UF_316M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_319M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_319M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF91.get(context))), __NUM_LIT_3).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(FunctionLib.TEIL(context, vf.valueFor(EF91.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF91.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), EF100.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_319M");
+ fehler_UF_319M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_319M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_319M");
+ this.fehler_UF_319M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_319M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_319M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_319M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_319M" : "#UF_319M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_322M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_322M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean() && OperatorLib.eq(context, EF126.get(context), EF142.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_322M");
+ fehler_UF_322M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_322M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_322M");
+ this.fehler_UF_322M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_322M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_322M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_322M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_322M" : "#UF_322M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_325M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_325M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF65U1.get(context))).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __NUM_LIT_3).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF65U1.get(context))).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_20), new SingleValueRange(__STR_LIT_2)}), EF65U1.get(context)).asBoolean()).asBoolean() && OperatorLib.eq(context, EF64.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF65U1.get(context))).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __NUM_LIT_2).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF65U1.get(context))).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_325M");
+ fehler_UF_325M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_325M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_325M");
+ this.fehler_UF_325M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_325M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_325M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_325M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_325M" : "#UF_325M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_328K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_328K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF126.get(context))}, context), EF128.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF126.get(context))}, context), EF129.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_328K");
+ fehler_UF_328K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_328K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_328K");
+ this.fehler_UF_328K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_328K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_328K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_328K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_328K" : "#UF_328K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_331K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_331K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF142.get(context))}, context), EF144.get(context))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_13)}), EF1.get(context))).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean()).asBoolean() && OperatorLib.ne(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new Material(__material_ref_STUDIENFACHMERKMALSKOMBINATION, new FeldDeskriptorInterface[] {__material_ref_STUDIENFACHMERKMALSKOMBINATION.studienfach}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.land, 1, EF1.get(context)), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.key, 1, FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))), new SatzFilter.FilterBedingung(__material_ref_STUDIENFACHMERKMALSKOMBINATION.abschluss3steller, 1, EF142.get(context))}, context), EF145.get(context))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_331K");
+ fehler_UF_331K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_331K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_331K");
+ this.fehler_UF_331K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_331K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_331K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_331K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_331K" : "#UF_331K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_334K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_334K");
+ try
+ {
+ if(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_89, Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_90, Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_91)}), prg_fkt_UF_334K(context)).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF133.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ge(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF133.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), __NUM_LIT_74).asBoolean()).asBoolean() && OperatorLib.le(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF133.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), __NUM_LIT_84).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF149.get(context))).asBoolean()).asBoolean() && OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.ge(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF149.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), __NUM_LIT_74).asBoolean()).asBoolean() && OperatorLib.le(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF149.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF8U2.get(context)))), __NUM_LIT_84).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_334K");
+ fehler_UF_334K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_334K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_334K");
+ this.fehler_UF_334K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_334K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_334K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_334K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_334K" : "#UF_334K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_337K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_337K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, EF18.get(context), EF109.get(context)).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_337K");
+ fehler_UF_337K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_337K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_337K");
+ this.fehler_UF_337K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_337K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_337K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_337K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_337K" : "#UF_337K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_340K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_340K");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF121.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, EF121.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.eq(context, EF122.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.plus(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF20.get(context)))), OperatorLib.div(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF83.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF86.get(context)))), __NUM_LIT_6)), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF121.get(context)))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(FunctionLib.NUMERISCH(context, vf.valueFor(EF19.get(context))).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF20.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF83.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF86.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF137.get(context))).asBoolean()).asBoolean() && OperatorLib.gt(context, EF137.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.eq(context, EF138.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.plus(context, OperatorLib.minus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF19.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF20.get(context)))), OperatorLib.div(context, OperatorLib.plus(context, FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF83.get(context))), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF86.get(context)))), __NUM_LIT_6)), FunctionLib.ALS_GANZZAHL(context, vf.valueFor(EF137.get(context)))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_340K");
+ fehler_UF_340K(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_340K", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_340K");
+ this.fehler_UF_340K(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_340K");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_340K(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_340K");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_340K" : "#UF_340K");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_343M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_343M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_920), new SingleValueRange(__STR_LIT_546), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_921)}), FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean() && OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_920), new SingleValueRange(__STR_LIT_546), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__STR_LIT_921)}), FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2))).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_343M");
+ fehler_UF_343M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_343M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_343M");
+ this.fehler_UF_343M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_343M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_343M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_343M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_343M" : "#UF_343M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_346M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_346M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF1.get(context), __STR_LIT_3).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF99.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF91.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF91.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF108.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF100.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF100.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF135.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF151.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(OperatorLib.eq(context, EF1.get(context), __STR_LIT_3).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF99.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF91.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_92), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF91.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF108.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF100.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_92), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF100.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF135.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF126.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_92), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF126.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF151.get(context), __STR_LIT_538).asBoolean() && OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF142.get(context))), __NUM_LIT_3).asBoolean()).asBoolean() && OperatorLib.not(context, OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__NUM_LIT_2), new SingleValueRange(__NUM_LIT_59), new SingleValueRange(__NUM_LIT_62), new SingleValueRange(__NUM_LIT_74), new SingleValueRange(__NUM_LIT_75), new SequenceRange(__NUM_LIT_76, __NUM_LIT_77, __NUM_LIT_47), new SingleValueRange(__NUM_LIT_49), new SingleValueRange(__NUM_LIT_78), new SingleValueRange(__NUM_LIT_79), new SingleValueRange(__NUM_LIT_80), new SequenceRange(__NUM_LIT_81, __NUM_LIT_82, __NUM_LIT_83), new SingleValueRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_92), new SingleValueRange(__NUM_LIT_61), new SingleValueRange(__NUM_LIT_30)}), FunctionLib.TEIL(context, vf.valueFor(EF142.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_2)))).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_346M");
+ fehler_UF_346M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_346M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_346M");
+ this.fehler_UF_346M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_346M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_346M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_346M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_346M" : "#UF_346M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public Value prg_UF_349M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ if (1 >= context.getPlausiKontext().getFehlerGewichtSchranke())
+ {
+ context.startNewPruefSection("Prüfung UF_349M");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_89, Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_90, Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_91)}), prg_fkt_UF_349M(context)).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF133.get(context))).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF149.get(context), InvalidValue.instance()).asBoolean() || FunctionLib.NUMERISCH(context, vf.valueFor(EF149.get(context))).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2)}), EF134.get(context)).asBoolean() && OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF133.get(context), EF8U2.get(context)), __NUM_LIT_74).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2)}), EF150.get(context)).asBoolean() && OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF149.get(context), EF8U2.get(context)), __NUM_LIT_74).asBoolean()).asBoolean()).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SequenceRange(Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_93, Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_94, Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_95), new SequenceRange(__NUM_LIT_27, __NUM_LIT_28, Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN_Segment1.__NUM_LIT_96)}), prg_fkt_UF_349M(context)).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF8U2.get(context))).asBoolean()).asBoolean() && FunctionLib.NUMERISCH(context, vf.valueFor(EF133.get(context))).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF149.get(context), InvalidValue.instance()).asBoolean() || FunctionLib.NUMERISCH(context, vf.valueFor(EF149.get(context))).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2)}), EF134.get(context)).asBoolean() && OperatorLib.ne(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF133.get(context), EF8U2.get(context)), __NUM_LIT_77).asBoolean()).asBoolean() || vf.valueFor(vf.valueFor(OperatorLib.contains(context, new RangeSeries(new Range[] {new SingleValueRange(__STR_LIT_12), new SingleValueRange(__STR_LIT_2)}), EF150.get(context)).asBoolean() && OperatorLib.ne(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.lt(context, OperatorLib.minus(context, EF149.get(context), EF8U2.get(context)), __NUM_LIT_77).asBoolean()).asBoolean()).asBoolean()).asBoolean()).asBoolean())
+ {
+ context.getLogger().trace("Fehler angeschrieben: UF_349M");
+ fehler_UF_349M(context, 0, null);
+ return vf.valueFor(true);
+ }
+ return vf.valueFor(false);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ catch (Exception e)
+ {
+ context.getLogger().error("Fehler waehrend Ausfuehrung: UF_349M", e);
+ context.getLogger().trace("Fehler angeschrieben (wg. Exception): UF_349M");
+ this.fehler_UF_349M(context, 0, e);
+ return vf.valueFor(true);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ else
+ {
+ context.getLogger().trace("Pruefung wg. Fehlergewichtsschranke ausgelassen: UF_349M");
+ return vf.valueFor(false);
+ }
+ }
+
+ protected void fehler_UF_349M(PlausiRuntimeContext context, int errorNum, Throwable thr)
+ {
+ PlausiFehler fehler = createPlausiFehler("UF_349M");
+ fehler.setFehlerInfoTyp(errorNum);
+ context.writeSectionInfosToError(fehler);
+ fehler.setFehlerId(context.getCurrentField() != null ? context.getCurrentField().hierarchyAsString()+ "#UF_349M" : "#UF_349M");
+ fehler.setReferenzFeld(context.getCurrentField());
+ fehler.setLaufzeitFehlerAufgetreten(thr != null);
+ fehler.setLaufzeitException(thr);
+ context.getLogger().trace("FehlerID angeschrieben: " + fehler.getFehlerId());
+ context.getPlausiKontext().setFehler(fehler);
+ }
+
+ public void prg_Ablauf_Studenten_Pruefungen(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Ablauf Ablauf_Studenten_Pruefungen");
+ try
+ {
+ prg_LAND_000(context);
+ prg_LAND_000K(context);
+ prg_LAND_001(context);
+ prg_LAND_002(context);
+ prg_LAND_003(context);
+ prg_LAND_008(context);
+ prg_LAND_009(context);
+ prg_LAND_006(context);
+ prg_LAND_007(context);
+ prg_LAND_004(context);
+ prg_LAND_005(context);
+ prg_LAND_010(context);
+ prg_LAND_012(context);
+ prg_LAND_013(context);
+ prg_LAND_014(context);
+ prg_LAND_015(context);
+ prg_LAND_016(context);
+ prg_LAND_017(context);
+ prg_MA_003(context);
+ prg_MA_006(context);
+ prg_MA_009(context);
+ prg_MA_012(context);
+ prg_MA_015(context);
+ prg_MA_018(context);
+ prg_MA_021(context);
+ prg_MA_024(context);
+ prg_MA_027(context);
+ prg_MA_030(context);
+ prg_MA_033(context);
+ prg_MA_036(context);
+ prg_MA_039(context);
+ prg_MA_042(context);
+ prg_MA_045(context);
+ prg_MA_048(context);
+ prg_MA_051(context);
+ prg_MA_054(context);
+ prg_MA_057(context);
+ prg_MA_060(context);
+ prg_MA_063(context);
+ prg_MA_066(context);
+ prg_MA_069(context);
+ prg_MA_072(context);
+ prg_MA_075(context);
+ prg_MA_078(context);
+ prg_MA_081(context);
+ prg_MA_084(context);
+ prg_MA_087(context);
+ prg_MA_090(context);
+ prg_MA_093(context);
+ prg_MA_096(context);
+ prg_MA_099(context);
+ prg_MA_102(context);
+ prg_MA_105(context);
+ prg_MA_108(context);
+ prg_MA_111(context);
+ prg_MA_114(context);
+ prg_MA_115(context);
+ prg_MA_116(context);
+ prg_MA_117(context);
+ prg_MA_118(context);
+ prg_MA_119(context);
+ prg_MA_120(context);
+ prg_MA_121(context);
+ prg_MA_122(context);
+ prg_MA_123(context);
+ prg_MA_124(context);
+ prg_MA_127(context);
+ prg_MA_129(context);
+ prg_MA_132(context);
+ prg_MA_135(context);
+ prg_MA_138(context);
+ prg_MA_141(context);
+ prg_MA_144(context);
+ prg_MA_147(context);
+ prg_MA_150(context);
+ prg_MA_153(context);
+ prg_MA_154(context);
+ prg_MA_156(context);
+ prg_MA_159(context);
+ prg_MA_160(context);
+ prg_MA_161(context);
+ prg_MA_162(context);
+ prg_MA_165(context);
+ prg_MA_168(context);
+ prg_MA_169(context);
+ prg_MA_170(context);
+ prg_MA_171(context);
+ prg_MA_172(context);
+ prg_MA_174(context);
+ prg_MA_177(context);
+ prg_MA_180(context);
+ prg_MA_183(context);
+ prg_MA_186(context);
+ prg_MA_189(context);
+ prg_MA_192(context);
+ prg_MA_201(context);
+ prg_MA_204(context);
+ prg_MA_207(context);
+ prg_MA_210(context);
+ prg_MA_213(context);
+ prg_MA_216(context);
+ prg_MA_217(context);
+ prg_MA_219(context);
+ prg_MA_220(context);
+ prg_MA_222(context);
+ prg_MA_225(context);
+ prg_MA_228(context);
+ prg_MA_229(context);
+ prg_MA_231(context);
+ prg_MA_232(context);
+ prg_MA_234(context);
+ prg_MA_235(context);
+ prg_MA_237(context);
+ prg_MA_238(context);
+ prg_MA_240(context);
+ prg_MA_243(context);
+ prg_SIG_001(context);
+ prg_SIG_003(context);
+ prg_SIG_006(context);
+ prg_SIG_009(context);
+ prg_SIG_012(context);
+ prg_SIG_015(context);
+ prg_MA_246(context);
+ prg_SIG_021(context);
+ prg_MA_248(context);
+ prg_SIG_027(context);
+ prg_MA_250(context);
+ prg_SIG_033(context);
+ prg_MA_252(context);
+ prg_SIG_039(context);
+ prg_MA_254(context);
+ prg_SIG_045(context);
+ prg_SIG_048(context);
+ prg_SIG_051(context);
+ prg_SIG_054(context);
+ prg_SIG_058(context);
+ prg_SIG_060(context);
+ prg_SIG_063(context);
+ prg_SIG_066(context);
+ prg_SIG_069(context);
+ prg_SIG_072(context);
+ prg_SIG_075(context);
+ prg_SIG_078(context);
+ prg_SIG_081(context);
+ prg_MA_256(context);
+ prg_SIG_087(context);
+ prg_SIG_090(context);
+ prg_SIG_093(context);
+ prg_SIG_096(context);
+ prg_SIG_099(context);
+ prg_SIG_102(context);
+ prg_SIG_105(context);
+ prg_SIG_108(context);
+ prg_SIG_111(context);
+ prg_SIG_114(context);
+ prg_SIG_117(context);
+ prg_SIG_120(context);
+ prg_SIG_123(context);
+ prg_SIG_126(context);
+ prg_SIG_129(context);
+ prg_SIG_132(context);
+ prg_SIG_135(context);
+ prg_SIG_138(context);
+ prg_SIG_141(context);
+ prg_SIG_144(context);
+ prg_SIG_147(context);
+ prg_SIG_150(context);
+ prg_SIG_153(context);
+ prg_SIG_156(context);
+ prg_SIG_159(context);
+ prg_SIG_162(context);
+ prg_SIG_165(context);
+ prg_SIG_168(context);
+ prg_SIG_171(context);
+ prg_SIG_174(context);
+ prg_SIG_177(context);
+ prg_SIG_180(context);
+ prg_SIG_183(context);
+ prg_SIG_186(context);
+ prg_SIG_189(context);
+ prg_SIG_192(context);
+ prg_SIG_195(context);
+ prg_SIG_198(context);
+ prg_SIG_201(context);
+ prg_SIG_204(context);
+ prg_SIG_207(context);
+ prg_SIG_210(context);
+ prg_SIG_213(context);
+ prg_SIG_216(context);
+ prg_SIG_219(context);
+ prg_SIG_222(context);
+ prg_SIG_225(context);
+ prg_SIG_228(context);
+ prg_SIG_231(context);
+ prg_SIG_234(context);
+ prg_SIG_237(context);
+ prg_SIG_240(context);
+ prg_SIG_243(context);
+ prg_SIG_246(context);
+ prg_SIG_249(context);
+ prg_SIG_255(context);
+ prg_SIG_261(context);
+ prg_SIG_264(context);
+ prg_SIG_267(context);
+ prg_SIG_270(context);
+ prg_SIG_273(context);
+ prg_SIG_276(context);
+ prg_SIG_279(context);
+ prg_SIG_282(context);
+ prg_SIG_285(context);
+ prg_SIG_288(context);
+ prg_SIG_291(context);
+ prg_SIG_294(context);
+ prg_SIG_297(context);
+ prg_SIG_300(context);
+ prg_SIG_303(context);
+ prg_SIG_306(context);
+ prg_SIG_309(context);
+ prg_SIG_312(context);
+ prg_SIG_315(context);
+ prg_SIG_318(context);
+ prg_SIG_321(context);
+ prg_SIG_324(context);
+ prg_SIG_327(context);
+ prg_SIG_330(context);
+ prg_SIG_333(context);
+ prg_SIG_336(context);
+ prg_SIG_339(context);
+ prg_SIG_342(context);
+ prg_SIG_345(context);
+ prg_SIG_348(context);
+ prg_SIG_351(context);
+ prg_SIG_354(context);
+ prg_SIG_357(context);
+ prg_SIG_360(context);
+ prg_SIG_363(context);
+ prg_SIG_366(context);
+ prg_SIG_369(context);
+ prg_UF_003K(context);
+ prg_UF_006M(context);
+ prg_UF_009M(context);
+ prg_UF_012M(context);
+ prg_UF_015M(context);
+ prg_UF_018M(context);
+ prg_UF_021M(context);
+ prg_UF_024K(context);
+ prg_UF_027M(context);
+ prg_MA_262(context);
+ prg_UF_033M(context);
+ prg_UF_036M(context);
+ prg_MA_264(context);
+ prg_UF_042M(context);
+ prg_UF_045M(context);
+ prg_UF_048M(context);
+ prg_UF_051M(context);
+ prg_UF_054M(context);
+ prg_UF_057M(context);
+ prg_UF_060M(context);
+ prg_UF_063M(context);
+ prg_UF_066M(context);
+ prg_UF_069K(context);
+ prg_UF_072M(context);
+ prg_UF_075M(context);
+ prg_UF_078M(context);
+ prg_MA_266(context);
+ prg_UF_084M(context);
+ prg_UF_087K(context);
+ prg_UF_090M(context);
+ prg_UF_093K(context);
+ prg_UF_096M(context);
+ prg_UF_099K(context);
+ prg_UF_102M(context);
+ prg_UF_105M(context);
+ prg_UF_108K(context);
+ prg_UF_114M(context);
+ prg_UF_117M(context);
+ prg_UF_120M(context);
+ prg_UF_123M(context);
+ prg_UF_126K(context);
+ prg_UF_129K(context);
+ prg_UF_132K(context);
+ prg_UF_138M(context);
+ prg_UF_141M(context);
+ prg_UF_144M(context);
+ prg_UF_147M(context);
+ prg_UF_150K(context);
+ prg_UF_153K(context);
+ prg_UF_156M(context);
+ prg_UF_159M(context);
+ prg_UF_162K(context);
+ prg_UF_165M(context);
+ prg_UF_168K(context);
+ prg_UF_171M(context);
+ prg_UF_174K(context);
+ prg_UF_177M(context);
+ prg_UF_180K(context);
+ prg_UF_183M(context);
+ prg_UF_186M(context);
+ prg_UF_189K(context);
+ prg_UF_191M(context);
+ prg_UF_194K(context);
+ prg_UF_197M(context);
+ prg_UF_200K(context);
+ prg_UF_203M(context);
+ prg_UF_206K(context);
+ prg_UF_209M(context);
+ prg_UF_211K(context);
+ prg_UF_214K(context);
+ prg_UF_217M(context);
+ prg_UF_220M(context);
+ prg_UF_223K(context);
+ prg_UF_226K(context);
+ prg_UF_229M(context);
+ prg_UF_231M(context);
+ prg_UF_237M(context);
+ prg_UF_243M(context);
+ prg_UF_251M(context);
+ prg_UF_260M(context);
+ prg_UF_263M(context);
+ prg_UF_266M(context);
+ prg_UF_269M(context);
+ prg_UF_271M(context);
+ prg_UF_274M(context);
+ prg_UF_277M(context);
+ prg_MA_268(context);
+ prg_UF_283M(context);
+ prg_UF_286M(context);
+ prg_UF_289K(context);
+ prg_UF_292M(context);
+ prg_UF_295M(context);
+ prg_UF_296M(context);
+ prg_UF_298M(context);
+ prg_UF_301K(context);
+ prg_UF_307M(context);
+ prg_UF_310M(context);
+ prg_UF_313M(context);
+ prg_UF_316M(context);
+ prg_UF_319M(context);
+ prg_UF_322M(context);
+ prg_UF_325M(context);
+ prg_UF_328K(context);
+ prg_UF_331K(context);
+ prg_UF_334K(context);
+ prg_UF_337K(context);
+ prg_UF_340K(context);
+ prg_UF_343M(context);
+ prg_UF_346M(context);
+ prg_UF_349M(context);
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_EIG_A(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Eigenschaft EIG_A");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.ne(context, EF10U1.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.ne(context, EF10U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF11U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF11U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF12.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF16.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.gt(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.gt(context, EF20.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.gt(context, EF21.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.gt(context, EF22.get(context), __STR_LIT_29).asBoolean()).asBoolean() || OperatorLib.ne(context, EF23.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF24.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.gt(context, EF25.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.ne(context, EF26.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF28.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF29.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.gt(context, EF30.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.ne(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF41.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF43.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF44.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.gt(context, EF45.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.ne(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF59.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF64.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF65U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF66.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF82.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.gt(context, EF83.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.ne(context, EF85.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.gt(context, EF86.get(context), __STR_LIT_17).asBoolean()).asBoolean() || OperatorLib.ne(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF110.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF111U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF111U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF112.get(context), InvalidValue.instance()).asBoolean()).asBoolean() || OperatorLib.ne(context, EF113.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ return BooleanValue.TRUE;
+ }
+ else
+ {
+ return BooleanValue.FALSE;
+ }
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_EIG_B(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Eigenschaft EIG_B");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF10U1.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF10U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF11U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF11U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF12.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF16.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF19.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF20.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF20.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF21.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF21.get(context), __STR_LIT_29).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF22.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF22.get(context), __STR_LIT_29).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF23.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF24.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF25.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF25.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF26.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF28.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF29.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF30.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF30.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF41.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF43.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF44.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF45.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF45.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF59.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF64.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF66.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF82.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF83.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF83.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF85.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF86.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF86.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF110.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF112.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF113.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ return BooleanValue.TRUE;
+ }
+ else
+ {
+ return BooleanValue.FALSE;
+ }
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_EIG_C(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Eigenschaft EIG_C");
+ try
+ {
+ if(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(vf.valueFor(OperatorLib.eq(context, EF10U1.get(context), InvalidValue.instance()).asBoolean() && OperatorLib.eq(context, EF10U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF11U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF11U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF12.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF16.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF17.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF18.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF19.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF19.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF20.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF20.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF21.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF21.get(context), __STR_LIT_29).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF22.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF22.get(context), __STR_LIT_29).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF23.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF24.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF25.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF25.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF26.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF27.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF28.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF29.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF30.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF30.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF31.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF32.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF34.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF36.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF41.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF42.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF43.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF44.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF45.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF45.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF46.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF47.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF49.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF51.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF56.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF59.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF60.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF61.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF62.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF64.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF65U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF66.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF69.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF70.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF71.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF72.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF74.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF77.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF78.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF79.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF80.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF82.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF83.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF83.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF85.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF86.get(context), InvalidValue.instance()).asBoolean() || OperatorLib.eq(context, EF86.get(context), __STR_LIT_17).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF91.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF92.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF93.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF94.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF96.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF97.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF98.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF99.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF100.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF101.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF102.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF103.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF105.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF106.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF107.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF108.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF109.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF110.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U1.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF111U2.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF112.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF113.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF120.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF121.get(context), __STR_LIT_17).asBoolean() || OperatorLib.eq(context, EF121.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF122.get(context), __STR_LIT_17).asBoolean() || OperatorLib.eq(context, EF122.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF123.get(context), __STR_LIT_29).asBoolean() || OperatorLib.eq(context, EF123.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF124.get(context), __STR_LIT_29).asBoolean() || OperatorLib.eq(context, EF124.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF125.get(context), __STR_LIT_29).asBoolean() || OperatorLib.eq(context, EF125.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF126.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF127.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF128.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF129.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF132.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF133.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF134.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF135.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF136.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF137.get(context), __STR_LIT_17).asBoolean() || OperatorLib.eq(context, EF137.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF138.get(context), __STR_LIT_17).asBoolean() || OperatorLib.eq(context, EF138.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF139.get(context), __STR_LIT_29).asBoolean() || OperatorLib.eq(context, EF139.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF140.get(context), __STR_LIT_29).asBoolean() || OperatorLib.eq(context, EF140.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && vf.valueFor(OperatorLib.eq(context, EF141.get(context), __STR_LIT_29).asBoolean() || OperatorLib.eq(context, EF141.get(context), InvalidValue.instance()).asBoolean()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF142.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF143.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF144.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF145.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF148.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF149.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF150.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF151.get(context), InvalidValue.instance()).asBoolean()).asBoolean() && OperatorLib.eq(context, EF152.get(context), InvalidValue.instance()).asBoolean()).asBoolean())
+ {
+ return BooleanValue.TRUE;
+ }
+ else
+ {
+ return BooleanValue.FALSE;
+ }
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_fkt_MA_219(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Funktion fkt_MA_219");
+ try
+ {
+ Variable SORT = new LocalVariable();
+ context.defineVariable("SORT", SORT);
+ SORT.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ SORT.set(context, ValueFactory.instance().valueFor(new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.sortKey}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULFACHBEREICH.key, 1, EF4.get(context))}, context).firstValue()));
+ return SORT.get(context);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_fkt_SIG_015(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Funktion fkt_SIG_015");
+ try
+ {
+ Variable KOMB = new LocalVariable();
+ context.defineVariable("KOMB", KOMB);
+ KOMB.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ KOMB.set(context, ValueFactory.instance().valueFor(new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.hochschulStandort}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULFACHBEREICH.key, 1, EF4.get(context))}, context).firstValue()));
+ return KOMB.get(context);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_fkt_SIG_273(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Funktion fkt_SIG_273");
+ try
+ {
+ Variable SCHULE = new LocalVariable();
+ context.defineVariable("SCHULE", SCHULE);
+ Variable FELD1 = new LocalVariable();
+ context.defineVariable("FELD1", FELD1);
+ FELD1.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ if(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF120.get(context))), __NUM_LIT_7).asBoolean())
+ {
+ SCHULE.set(context, ValueFactory.instance().valueFor(FunctionLib.TEIL(context, vf.valueFor(EF120.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))));
+ FELD1.set(context, ValueFactory.instance().valueFor(new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.hochschulStandort}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULFACHBEREICH.key, 1, SCHULE.get(context))}, context).firstValue()));
+ }
+ return FELD1.get(context);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_fkt_SIG_327(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Funktion fkt_SIG_327");
+ try
+ {
+ Variable SCHULE1 = new LocalVariable();
+ context.defineVariable("SCHULE1", SCHULE1);
+ Variable FELD2 = new LocalVariable();
+ context.defineVariable("FELD2", FELD2);
+ FELD2.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ if(OperatorLib.eq(context, FunctionLib.WERTLAENGE(context, vf.valueFor(EF136.get(context))), __NUM_LIT_7).asBoolean())
+ {
+ SCHULE1.set(context, ValueFactory.instance().valueFor(FunctionLib.TEIL(context, vf.valueFor(EF136.get(context)), vf.valueFor(__NUM_LIT_2), vf.valueFor(__NUM_LIT_4))));
+ FELD2.set(context, ValueFactory.instance().valueFor(new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.hochschulStandort}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULFACHBEREICH.key, 1, SCHULE1.get(context))}, context).firstValue()));
+ }
+ return FELD2.get(context);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_fkt_UF_165M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Funktion fkt_UF_165M");
+ try
+ {
+ Variable KOMB1 = new LocalVariable();
+ context.defineVariable("KOMB1", KOMB1);
+ KOMB1.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ KOMB1.set(context, ValueFactory.instance().valueFor(new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.hochschulStandort}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULFACHBEREICH.key, 1, EF4.get(context))}, context).firstValue()));
+ return KOMB1.get(context);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_fkt_UF_334K(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Funktion fkt_UF_334K");
+ try
+ {
+ Variable SORT1 = new LocalVariable();
+ context.defineVariable("SORT1", SORT1);
+ SORT1.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ SORT1.set(context, ValueFactory.instance().valueFor(new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.sortKey}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULFACHBEREICH.key, 1, EF4.get(context))}, context).firstValue()));
+ return SORT1.get(context);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+
+ public Value prg_fkt_UF_349M(PlausiRuntimeContext context)
+ {
+ ValueFactory vf = ValueFactory.instance();
+ context.startNewSection("Funktion fkt_UF_349M");
+ try
+ {
+ Variable SORT2 = new LocalVariable();
+ context.defineVariable("SORT2", SORT2);
+ SORT2.set(context, ValueFactory.instance().valueFor(__STR_LIT_29));
+ SORT2.set(context, ValueFactory.instance().valueFor(new Material(__material_ref_HOCHSCHULFACHBEREICH, new FeldDeskriptorInterface[] {__material_ref_HOCHSCHULFACHBEREICH.sortKey}, new SatzFilter.FilterBedingung[] {new SatzFilter.FilterBedingung(__material_ref_HOCHSCHULFACHBEREICH.key, 1, EF4.get(context))}, context).firstValue()));
+ return SORT2.get(context);
+ }
+ catch (ReturnStatementException e)
+ {
+ return e.getReturnValue();
+ }
+ finally
+ {
+ context.leaveCurrentSection();
+ }
+ }
+ }
+
+ public class MaterialTB_T_Studenten_Pruefungen extends MaterialThemenbereich
+ {
+ public MaterialVariable EF1;
+ public MaterialVariable EF100;
+ public MaterialVariable EF101;
+ public MaterialVariable EF102;
+ public MaterialVariable EF103;
+ public MaterialVariable EF104;
+ public MaterialVariable EF105;
+ public MaterialVariable EF106;
+ public MaterialVariable EF107;
+ public MaterialVariable EF108;
+ public MaterialVariable EF109;
+ public MaterialVariable EF10U1;
+ public MaterialVariable EF10U2;
+ public MaterialVariable EF110;
+ public MaterialVariable EF111U1;
+ public MaterialVariable EF111U2;
+ public MaterialVariable EF112;
+ public MaterialVariable EF113;
+ public MaterialVariable EF114;
+ public MaterialVariable EF115;
+ public MaterialVariable EF116;
+ public MaterialVariable EF117;
+ public MaterialVariable EF118;
+ public MaterialVariable EF119;
+ public MaterialVariable EF11U1;
+ public MaterialVariable EF11U2;
+ public MaterialVariable EF12;
+ public MaterialVariable EF120;
+ public MaterialVariable EF121;
+ public MaterialVariable EF122;
+ public MaterialVariable EF123;
+ public MaterialVariable EF124;
+ public MaterialVariable EF125;
+ public MaterialVariable EF126;
+ public MaterialVariable EF127;
+ public MaterialVariable EF128;
+ public MaterialVariable EF129;
+ public MaterialVariable EF13;
+ public MaterialVariable EF130;
+ public MaterialVariable EF131;
+ public MaterialVariable EF132;
+ public MaterialVariable EF133;
+ public MaterialVariable EF134;
+ public MaterialVariable EF135;
+ public MaterialVariable EF136;
+ public MaterialVariable EF137;
+ public MaterialVariable EF138;
+ public MaterialVariable EF139;
+ public MaterialVariable EF14;
+ public MaterialVariable EF140;
+ public MaterialVariable EF141;
+ public MaterialVariable EF142;
+ public MaterialVariable EF143;
+ public MaterialVariable EF144;
+ public MaterialVariable EF145;
+ public MaterialVariable EF146;
+ public MaterialVariable EF147;
+ public MaterialVariable EF148;
+ public MaterialVariable EF149;
+ public MaterialVariable EF15;
+ public MaterialVariable EF150;
+ public MaterialVariable EF151;
+ public MaterialVariable EF152;
+ public MaterialVariable EF16;
+ public MaterialVariable EF17;
+ public MaterialVariable EF18;
+ public MaterialVariable EF19;
+ public MaterialVariable EF2;
+ public MaterialVariable EF20;
+ public MaterialVariable EF21;
+ public MaterialVariable EF22;
+ public MaterialVariable EF23;
+ public MaterialVariable EF24;
+ public MaterialVariable EF25;
+ public MaterialVariable EF26;
+ public MaterialVariable EF27;
+ public MaterialVariable EF28;
+ public MaterialVariable EF29;
+ public MaterialVariable EF3;
+ public MaterialVariable EF30;
+ public MaterialVariable EF31;
+ public MaterialVariable EF32;
+ public MaterialVariable EF33;
+ public MaterialVariable EF34;
+ public MaterialVariable EF35;
+ public MaterialVariable EF36;
+ public MaterialVariable EF37;
+ public MaterialVariable EF38;
+ public MaterialVariable EF39;
+ public MaterialVariable EF4;
+ public MaterialVariable EF40;
+ public MaterialVariable EF41;
+ public MaterialVariable EF42;
+ public MaterialVariable EF43;
+ public MaterialVariable EF44;
+ public MaterialVariable EF45;
+ public MaterialVariable EF46;
+ public MaterialVariable EF47;
+ public MaterialVariable EF48;
+ public MaterialVariable EF49;
+ public MaterialVariable EF5;
+ public MaterialVariable EF50;
+ public MaterialVariable EF51;
+ public MaterialVariable EF52;
+ public MaterialVariable EF53;
+ public MaterialVariable EF54;
+ public MaterialVariable EF55;
+ public MaterialVariable EF56;
+ public MaterialVariable EF57;
+ public MaterialVariable EF58;
+ public MaterialVariable EF59;
+ public MaterialVariable EF6;
+ public MaterialVariable EF60;
+ public MaterialVariable EF61;
+ public MaterialVariable EF62;
+ public MaterialVariable EF63;
+ public MaterialVariable EF64;
+ public MaterialVariable EF65U1;
+ public MaterialVariable EF65U2;
+ public MaterialVariable EF66;
+ public MaterialVariable EF67;
+ public MaterialVariable EF68;
+ public MaterialVariable EF69;
+ public MaterialVariable EF7;
+ public MaterialVariable EF70;
+ public MaterialVariable EF71;
+ public MaterialVariable EF72;
+ public MaterialVariable EF73;
+ public MaterialVariable EF74;
+ public MaterialVariable EF75;
+ public MaterialVariable EF76;
+ public MaterialVariable EF77;
+ public MaterialVariable EF78;
+ public MaterialVariable EF79;
+ public MaterialVariable EF80;
+ public MaterialVariable EF81;
+ public MaterialVariable EF82;
+ public MaterialVariable EF83;
+ public MaterialVariable EF84;
+ public MaterialVariable EF85;
+ public MaterialVariable EF86;
+ public MaterialVariable EF87;
+ public MaterialVariable EF88;
+ public MaterialVariable EF89;
+ public MaterialVariable EF8U1;
+ public MaterialVariable EF8U2;
+ public MaterialVariable EF9;
+ public MaterialVariable EF90;
+ public MaterialVariable EF91;
+ public MaterialVariable EF92;
+ public MaterialVariable EF93;
+ public MaterialVariable EF94;
+ public MaterialVariable EF95;
+ public MaterialVariable EF96;
+ public MaterialVariable EF97;
+ public MaterialVariable EF98;
+ public MaterialVariable EF99;
+ public MaterialTB_T_Studenten_Pruefungen(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.EF1 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF1", null, 3), null);
+ this.EF100 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF100", null, 3), null);
+ this.EF101 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF101", null, 3), null);
+ this.EF102 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF102", null, 3), null);
+ this.EF103 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF103", null, 3), null);
+ this.EF104 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF104", null, 3), null);
+ this.EF105 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF105", null, 3), null);
+ this.EF106 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF106", null, 3), null);
+ this.EF107 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF107", null, 3), null);
+ this.EF108 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF108", null, 3), null);
+ this.EF109 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF109", null, 3), null);
+ this.EF10U1 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF10U1", null, 3), null);
+ this.EF10U2 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF10U2", null, 3), null);
+ this.EF110 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF110", null, 3), null);
+ this.EF111U1 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF111U1", null, 3), null);
+ this.EF111U2 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF111U2", null, 3), null);
+ this.EF112 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF112", null, 3), null);
+ this.EF113 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF113", null, 3), null);
+ this.EF114 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF114", null, 3), null);
+ this.EF115 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF115", null, 3), null);
+ this.EF116 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF116", null, 3), null);
+ this.EF117 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF117", null, 3), null);
+ this.EF118 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF118", null, 3), null);
+ this.EF119 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF119", null, 3), null);
+ this.EF11U1 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF11U1", null, 3), null);
+ this.EF11U2 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF11U2", null, 3), null);
+ this.EF12 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF12", null, 3), null);
+ this.EF120 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF120", null, 3), null);
+ this.EF121 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF121", null, 3), null);
+ this.EF122 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF122", null, 3), null);
+ this.EF123 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF123", null, 3), null);
+ this.EF124 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF124", null, 3), null);
+ this.EF125 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF125", null, 3), null);
+ this.EF126 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF126", null, 3), null);
+ this.EF127 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF127", null, 3), null);
+ this.EF128 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF128", null, 3), null);
+ this.EF129 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF129", null, 3), null);
+ this.EF13 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF13", null, 3), null);
+ this.EF130 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF130", null, 3), null);
+ this.EF131 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF131", null, 3), null);
+ this.EF132 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF132", null, 3), null);
+ this.EF133 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF133", null, 3), null);
+ this.EF134 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF134", null, 3), null);
+ this.EF135 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF135", null, 3), null);
+ this.EF136 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF136", null, 3), null);
+ this.EF137 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF137", null, 3), null);
+ this.EF138 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF138", null, 3), null);
+ this.EF139 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF139", null, 3), null);
+ this.EF14 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF14", null, 3), null);
+ this.EF140 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF140", null, 3), null);
+ this.EF141 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF141", null, 3), null);
+ this.EF142 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF142", null, 3), null);
+ this.EF143 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF143", null, 3), null);
+ this.EF144 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF144", null, 3), null);
+ this.EF145 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF145", null, 3), null);
+ this.EF146 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF146", null, 3), null);
+ this.EF147 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF147", null, 3), null);
+ this.EF148 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF148", null, 3), null);
+ this.EF149 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF149", null, 3), null);
+ this.EF15 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF15", null, 3), null);
+ this.EF150 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF150", null, 3), null);
+ this.EF151 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF151", null, 3), null);
+ this.EF152 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF152", null, 3), null);
+ this.EF16 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF16", null, 3), null);
+ this.EF17 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF17", null, 3), null);
+ this.EF18 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF18", null, 3), null);
+ this.EF19 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF19", null, 3), null);
+ this.EF2 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF2", null, 3), null);
+ this.EF20 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF20", null, 3), null);
+ this.EF21 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF21", null, 3), null);
+ this.EF22 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF22", null, 3), null);
+ this.EF23 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF23", null, 3), null);
+ this.EF24 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF24", null, 3), null);
+ this.EF25 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF25", null, 3), null);
+ this.EF26 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF26", null, 3), null);
+ this.EF27 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF27", null, 3), null);
+ this.EF28 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF28", null, 3), null);
+ this.EF29 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF29", null, 3), null);
+ this.EF3 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF3", null, 3), null);
+ this.EF30 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF30", null, 3), null);
+ this.EF31 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF31", null, 3), null);
+ this.EF32 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF32", null, 3), null);
+ this.EF33 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF33", null, 3), null);
+ this.EF34 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF34", null, 3), null);
+ this.EF35 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF35", null, 3), null);
+ this.EF36 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF36", null, 3), null);
+ this.EF37 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF37", null, 3), null);
+ this.EF38 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF38", null, 3), null);
+ this.EF39 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF39", null, 3), null);
+ this.EF4 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF4", null, 3), null);
+ this.EF40 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF40", null, 3), null);
+ this.EF41 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF41", null, 3), null);
+ this.EF42 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF42", null, 3), null);
+ this.EF43 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF43", null, 3), null);
+ this.EF44 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF44", null, 3), null);
+ this.EF45 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF45", null, 3), null);
+ this.EF46 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF46", null, 3), null);
+ this.EF47 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF47", null, 3), null);
+ this.EF48 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF48", null, 3), null);
+ this.EF49 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF49", null, 3), null);
+ this.EF5 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF5", null, 3), null);
+ this.EF50 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF50", null, 3), null);
+ this.EF51 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF51", null, 3), null);
+ this.EF52 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF52", null, 3), null);
+ this.EF53 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF53", null, 3), null);
+ this.EF54 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF54", null, 3), null);
+ this.EF55 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF55", null, 3), null);
+ this.EF56 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF56", null, 3), null);
+ this.EF57 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF57", null, 3), null);
+ this.EF58 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF58", null, 3), null);
+ this.EF59 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF59", null, 3), null);
+ this.EF6 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF6", null, 3), null);
+ this.EF60 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF60", null, 3), null);
+ this.EF61 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF61", null, 3), null);
+ this.EF62 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF62", null, 3), null);
+ this.EF63 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF63", null, 3), null);
+ this.EF64 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF64", null, 3), null);
+ this.EF65U1 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF65U1", null, 3), null);
+ this.EF65U2 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF65U2", null, 3), null);
+ this.EF66 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF66", null, 3), null);
+ this.EF67 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF67", null, 3), null);
+ this.EF68 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF68", null, 3), null);
+ this.EF69 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF69", null, 3), null);
+ this.EF7 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF7", null, 3), null);
+ this.EF70 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF70", null, 3), null);
+ this.EF71 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF71", null, 3), null);
+ this.EF72 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF72", null, 3), null);
+ this.EF73 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF73", null, 3), null);
+ this.EF74 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF74", null, 3), null);
+ this.EF75 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF75", null, 3), null);
+ this.EF76 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF76", null, 3), null);
+ this.EF77 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF77", null, 3), null);
+ this.EF78 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF78", null, 3), null);
+ this.EF79 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF79", null, 3), null);
+ this.EF80 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF80", null, 3), null);
+ this.EF81 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF81", null, 3), null);
+ this.EF82 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF82", null, 3), null);
+ this.EF83 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF83", null, 3), null);
+ this.EF84 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF84", null, 3), null);
+ this.EF85 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF85", null, 3), null);
+ this.EF86 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF86", null, 3), null);
+ this.EF87 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF87", null, 3), null);
+ this.EF88 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF88", null, 3), null);
+ this.EF89 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF89", null, 3), null);
+ this.EF8U1 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF8U1", null, 3), null);
+ this.EF8U2 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF8U2", null, 3), null);
+ this.EF9 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF9", null, 3), null);
+ this.EF90 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF90", null, 3), null);
+ this.EF91 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF91", null, 3), null);
+ this.EF92 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF92", null, 3), null);
+ this.EF93 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF93", null, 3), null);
+ this.EF94 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF94", null, 3), null);
+ this.EF95 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF95", null, 3), null);
+ this.EF96 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF96", null, 3), null);
+ this.EF97 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF97", null, 3), null);
+ this.EF98 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF98", null, 3), null);
+ this.EF99 = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "EF99", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_T_Studenten_Pruefungen(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public class TB_VollTeilzeit extends TopicField
+ {
+ public transient FeatureVariable gueltigAbJahr;
+ public transient FeatureVariable gueltigAbSemester;
+ public transient FeatureVariable gueltigBisJahr;
+ public transient FeatureVariable gueltigBisSemester;
+ public transient FeatureVariable key;
+ public transient FeatureVariable name;
+ public transient FeatureVariable sortKey;
+ public TB_VollTeilzeit(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices)
+ {
+ super(parent, feldDeskriptor, indices);
+
+ this.gueltigAbJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3, null, "Gültigkeit ab Jahr"), null);
+ this.gueltigAbSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3, null, "Gültigkeit ab Semester"), null);
+ this.gueltigBisJahr = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3, null, "Gültigkeit bis Jahr"), null);
+ this.gueltigBisSemester = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3, null, "Gültigkeit bis Semester"), null);
+ this.key = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "key", null, 3, null, "Signierschlüssel Voll-/Teilzeit/Duales Studium"), null);
+ this.name = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "name", null, 3, null, "Text Voll-/Teilzeit/Duales Studium"), null);
+ this.sortKey = new FeatureVariable(null, new FeldDeskriptorExt(feldDeskriptor.getMappings(), "sortKey", null, 3, null, "LEER"), null);
+ }
+
+ public TopicField getInstance(int[] indizes)
+ {
+ return new TB_VollTeilzeit(getVorgaenger(), getFeldDeskriptor(), indizes);
+ }
+ }
+
+ public class MaterialTB_VollTeilzeit extends MaterialThemenbereich
+ {
+ public MaterialVariable gueltigAbJahr;
+ public MaterialVariable gueltigAbSemester;
+ public MaterialVariable gueltigBisJahr;
+ public MaterialVariable gueltigBisSemester;
+ public MaterialVariable key;
+ public MaterialVariable name;
+ public MaterialVariable sortKey;
+ public MaterialTB_VollTeilzeit(FeldDeskriptorInterface parent, FeldDeskriptor feldDeskriptor, int[] indices, String materialName, String materialDSB, boolean isReference)
+ {
+ super(parent, feldDeskriptor, indices, materialName, materialDSB);
+
+ this.gueltigAbJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbJahr", null, 3), null);
+ this.gueltigAbSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigAbSemester", null, 3), null);
+ this.gueltigBisJahr = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisJahr", null, 3), null);
+ this.gueltigBisSemester = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "gueltigBisSemester", null, 3), null);
+ this.key = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "key", null, 3), null);
+ this.name = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "name", null, 3), null);
+ this.sortKey = new MaterialVariable(null, new FeldDeskriptor(feldDeskriptor.getMappings(), "sortKey", null, 3), null);
+ }
+
+ public MaterialThemenbereich getInstance(int[] indizes)
+ {
+ return new MaterialTB_VollTeilzeit(getVorgaenger(), getFeldDeskriptor(), indizes, getMaterialName(), getMaterialDSBName(), true);
+ }
+ }
+
+ public static final NumberValue __NUM_LIT_1 = new NumberValue(1.0);
+ public static final NumberValue __NUM_LIT_2 = new NumberValue(2.0);
+ public static final NumberValue __NUM_LIT_3 = new NumberValue(3.0);
+ public static final NumberValue __NUM_LIT_4 = new NumberValue(4.0);
+ public static final NumberValue __NUM_LIT_5 = new NumberValue(5.0);
+ public static final NumberValue __NUM_LIT_6 = new NumberValue(6.0);
+ public static final NumberValue __NUM_LIT_7 = new NumberValue(7.0);
+ public static final NumberValue __NUM_LIT_8 = new NumberValue(12.0);
+ public static final StringValue __STR_LIT_1 = new StringValue("15");
+ public static final StringValue __STR_LIT_2 = new StringValue("3");
+ public static final StringValue __STR_LIT_3 = new StringValue("09");
+ public static final StringValue __STR_LIT_4 = new StringValue("1320");
+ public static final StringValue __STR_LIT_5 = new StringValue("e98");
+ public static final StringValue __STR_LIT_6 = new StringValue("e99");
+ public static final StringValue __STR_LIT_7 = new StringValue("f00");
+ public static final StringValue __STR_LIT_8 = new StringValue("f01");
+ public static final StringValue __STR_LIT_9 = new StringValue("34");
+ public static final StringValue __STR_LIT_10 = new StringValue("53");
+ public static final StringValue __STR_LIT_11 = new StringValue("71");
+ public static final StringValue __STR_LIT_12 = new StringValue("1");
+ public static final StringValue __STR_LIT_13 = new StringValue("05");
+ public static final StringValue __STR_LIT_14 = new StringValue(" ");
+ public static final StringValue __STR_LIT_15 = new StringValue("000");
+ public static final StringValue __STR_LIT_16 = new StringValue(" ");
+ public static final StringValue __STR_LIT_17 = new StringValue("00");
+ public static final StringValue __STR_LIT_18 = new StringValue("5");
+ public static final StringValue __STR_LIT_19 = new StringValue("6");
+ public static final StringValue __STR_LIT_20 = new StringValue("2");
+ public static final StringValue __STR_LIT_21 = new StringValue("4");
+ public static final StringValue __STR_LIT_22 = new StringValue("9000");
+ public static final StringValue __STR_LIT_23 = new StringValue("9990");
+ public static final StringValue __STR_LIT_24 = new StringValue(" ");
+ public static final StringValue __STR_LIT_25 = new StringValue(" ");
+ public static final StringValue __STR_LIT_26 = new StringValue(" ");
+ public static final StringValue __STR_LIT_27 = new StringValue(" ");
+ public static final StringValue __STR_LIT_28 = new StringValue(" ");
+ public static final StringValue __STR_LIT_29 = new StringValue("0");
+ public static final StringValue __STR_LIT_30 = new StringValue("0000");
+ public static final StringValue __STR_LIT_31 = new StringValue("0000000");
+ public static final StringValue __STR_LIT_32 = new StringValue("20081");
+ public static final StringValue __STR_LIT_33 = new StringValue("99");
+ public static final StringValue __STR_LIT_34 = new StringValue("39");
+ public static final StringValue __STR_LIT_35 = new StringValue("59");
+ public static final StringValue __STR_LIT_36 = new StringValue("79");
+ public static final StringValue __STR_LIT_37 = new StringValue("20082");
+ public static final StringValue __STR_LIT_38 = new StringValue("17");
+ public static final StringValue __STR_LIT_39 = new StringValue("47");
+ public static final StringValue __STR_LIT_40 = new StringValue("67");
+ public static final NumberValue __NUM_LIT_9 = new NumberValue(998.0);
+ public static final NumberValue __NUM_LIT_10 = new NumberValue(999.0);
+ public static final StringValue __STR_LIT_41 = new StringValue("01");
+ public static final StringValue __STR_LIT_42 = new StringValue("02");
+ public static final StringValue __STR_LIT_43 = new StringValue("07");
+ public static final StringValue __STR_LIT_44 = new StringValue("08");
+ public static final StringValue __STR_LIT_45 = new StringValue("12");
+ public static final StringValue __STR_LIT_46 = new StringValue("13");
+ public static final StringValue __STR_LIT_47 = new StringValue("14");
+ public static final StringValue __STR_LIT_48 = new StringValue("0330");
+ public static final StringValue __STR_LIT_49 = new StringValue("0350");
+ public static final StringValue __STR_LIT_50 = new StringValue("1400");
+ public static final StringValue __STR_LIT_51 = new StringValue("2010");
+ public static final StringValue __STR_LIT_52 = new StringValue("2070");
+ public static final StringValue __STR_LIT_53 = new StringValue("2330");
+ public static final StringValue __STR_LIT_54 = new StringValue("2460");
+ public static final StringValue __STR_LIT_55 = new StringValue("2661");
+ public static final StringValue __STR_LIT_56 = new StringValue("3650");
+ public static final StringValue __STR_LIT_57 = new StringValue("3740");
+ public static final StringValue __STR_LIT_58 = new StringValue("3730");
+ public static final StringValue __STR_LIT_59 = new StringValue("3760");
+ public static final StringValue __STR_LIT_60 = new StringValue("5572");
+ public static final StringValue __STR_LIT_61 = new StringValue("5574");
+ public static final StringValue __STR_LIT_62 = new StringValue("5580");
+ public static final StringValue __STR_LIT_63 = new StringValue("5600");
+ public static final StringValue __STR_LIT_64 = new StringValue("5870");
+ public static final StringValue __STR_LIT_65 = new StringValue("6209");
+ public static final StringValue __STR_LIT_66 = new StringValue("6250");
+ public static final StringValue __STR_LIT_67 = new StringValue("6310");
+ public static final StringValue __STR_LIT_68 = new StringValue("6420");
+ public static final StringValue __STR_LIT_69 = new StringValue("6450");
+ public static final StringValue __STR_LIT_70 = new StringValue("6500");
+ public static final StringValue __STR_LIT_71 = new StringValue("6880");
+ public static final StringValue __STR_LIT_72 = new StringValue("6920");
+ public static final StringValue __STR_LIT_73 = new StringValue("6940");
+ public static final StringValue __STR_LIT_74 = new StringValue("7000");
+ public static final StringValue __STR_LIT_75 = new StringValue("7640");
+ public static final StringValue __STR_LIT_76 = new StringValue("7660");
+ public static final StringValue __STR_LIT_77 = new StringValue("7800");
+ public static final StringValue __STR_LIT_78 = new StringValue("8042");
+ public static final StringValue __STR_LIT_79 = new StringValue("8043");
+ public static final StringValue __STR_LIT_80 = new StringValue("8121");
+ public static final StringValue __STR_LIT_81 = new StringValue("8122");
+ public static final StringValue __STR_LIT_82 = new StringValue("2470");
+ public static final StringValue __STR_LIT_83 = new StringValue("5290");
+ public static final StringValue __STR_LIT_84 = new StringValue("20092");
+ public static final StringValue __STR_LIT_85 = new StringValue("5335");
+ public static final StringValue __STR_LIT_86 = new StringValue("7650");
+ public static final StringValue __STR_LIT_87 = new StringValue("0070");
+ public static final StringValue __STR_LIT_88 = new StringValue("0090");
+ public static final StringValue __STR_LIT_89 = new StringValue("0091");
+ public static final StringValue __STR_LIT_90 = new StringValue("0092");
+ public static final StringValue __STR_LIT_91 = new StringValue("0122");
+ public static final StringValue __STR_LIT_92 = new StringValue("0123");
+ public static final StringValue __STR_LIT_93 = new StringValue("0124");
+ public static final StringValue __STR_LIT_94 = new StringValue("0220");
+ public static final StringValue __STR_LIT_95 = new StringValue("0250");
+ public static final StringValue __STR_LIT_96 = new StringValue("0280");
+ public static final StringValue __STR_LIT_97 = new StringValue("0290");
+ public static final StringValue __STR_LIT_98 = new StringValue("0303");
+ public static final StringValue __STR_LIT_99 = new StringValue("0320");
+ public static final StringValue __STR_LIT_100 = new StringValue("0340");
+ public static final StringValue __STR_LIT_101 = new StringValue("0381");
+ public static final StringValue __STR_LIT_102 = new StringValue("0382");
+ public static final StringValue __STR_LIT_103 = new StringValue("0400");
+ public static final StringValue __STR_LIT_104 = new StringValue("0410");
+ public static final StringValue __STR_LIT_105 = new StringValue("0420");
+ public static final StringValue __STR_LIT_106 = new StringValue("0430");
+ public static final StringValue __STR_LIT_107 = new StringValue("0440");
+ public static final StringValue __STR_LIT_108 = new StringValue("0450");
+ public static final StringValue __STR_LIT_109 = new StringValue("0460");
+ public static final StringValue __STR_LIT_110 = new StringValue("0470");
+ public static final StringValue __STR_LIT_111 = new StringValue("0480");
+ public static final StringValue __STR_LIT_112 = new StringValue("0531");
+ public static final StringValue __STR_LIT_113 = new StringValue("0532");
+ public static final StringValue __STR_LIT_114 = new StringValue("0550");
+ public static final StringValue __STR_LIT_115 = new StringValue("0561");
+ public static final StringValue __STR_LIT_116 = new StringValue("0570");
+ public static final StringValue __STR_LIT_117 = new StringValue("0600");
+ public static final StringValue __STR_LIT_118 = new StringValue("0990");
+ public static final StringValue __STR_LIT_119 = new StringValue("0992");
+ public static final StringValue __STR_LIT_120 = new StringValue("1070");
+ public static final StringValue __STR_LIT_121 = new StringValue("1229");
+ public static final StringValue __STR_LIT_122 = new StringValue("1310");
+ public static final StringValue __STR_LIT_123 = new StringValue("1387");
+ public static final StringValue __STR_LIT_124 = new StringValue("1388");
+ public static final StringValue __STR_LIT_125 = new StringValue("1631");
+ public static final StringValue __STR_LIT_126 = new StringValue("1632");
+ public static final StringValue __STR_LIT_127 = new StringValue("1720");
+ public static final StringValue __STR_LIT_128 = new StringValue("2090");
+ public static final StringValue __STR_LIT_129 = new StringValue("2110");
+ public static final StringValue __STR_LIT_130 = new StringValue("2120");
+ public static final StringValue __STR_LIT_131 = new StringValue("2140");
+ public static final StringValue __STR_LIT_132 = new StringValue("2160");
+ public static final StringValue __STR_LIT_133 = new StringValue("2250");
+ public static final StringValue __STR_LIT_134 = new StringValue("2260");
+ public static final StringValue __STR_LIT_135 = new StringValue("2310");
+ public static final StringValue __STR_LIT_136 = new StringValue("2340");
+ public static final StringValue __STR_LIT_137 = new StringValue("2400");
+ public static final StringValue __STR_LIT_138 = new StringValue("2480");
+ public static final StringValue __STR_LIT_139 = new StringValue("2562");
+ public static final StringValue __STR_LIT_140 = new StringValue("2563");
+ public static final StringValue __STR_LIT_141 = new StringValue("2662");
+ public static final StringValue __STR_LIT_142 = new StringValue("2680");
+ public static final StringValue __STR_LIT_143 = new StringValue("2751");
+ public static final StringValue __STR_LIT_144 = new StringValue("2780");
+ public static final StringValue __STR_LIT_145 = new StringValue("2820");
+ public static final StringValue __STR_LIT_146 = new StringValue("2840");
+ public static final StringValue __STR_LIT_147 = new StringValue("2910");
+ public static final StringValue __STR_LIT_148 = new StringValue("2970");
+ public static final StringValue __STR_LIT_149 = new StringValue("3110");
+ public static final StringValue __STR_LIT_150 = new StringValue("3150");
+ public static final StringValue __STR_LIT_151 = new StringValue("3160");
+ public static final StringValue __STR_LIT_152 = new StringValue("3170");
+ public static final StringValue __STR_LIT_153 = new StringValue("3180");
+ public static final StringValue __STR_LIT_154 = new StringValue("3190");
+ public static final StringValue __STR_LIT_155 = new StringValue("3200");
+ public static final StringValue __STR_LIT_156 = new StringValue("3210");
+ public static final StringValue __STR_LIT_157 = new StringValue("3220");
+ public static final StringValue __STR_LIT_158 = new StringValue("3280");
+ public static final StringValue __STR_LIT_159 = new StringValue("3310");
+ public static final StringValue __STR_LIT_160 = new StringValue("3320");
+ public static final StringValue __STR_LIT_161 = new StringValue("3330");
+ public static final StringValue __STR_LIT_162 = new StringValue("3340");
+ public static final StringValue __STR_LIT_163 = new StringValue("3350");
+ public static final StringValue __STR_LIT_164 = new StringValue("3380");
+ public static final StringValue __STR_LIT_165 = new StringValue("3390");
+ public static final StringValue __STR_LIT_166 = new StringValue("3400");
+ public static final StringValue __STR_LIT_167 = new StringValue("3410");
+ public static final StringValue __STR_LIT_168 = new StringValue("3420");
+ public static final StringValue __STR_LIT_169 = new StringValue("3450");
+ public static final StringValue __STR_LIT_170 = new StringValue("3460");
+ public static final StringValue __STR_LIT_171 = new StringValue("3470");
+ public static final StringValue __STR_LIT_172 = new StringValue("3480");
+ public static final StringValue __STR_LIT_173 = new StringValue("3510");
+ public static final StringValue __STR_LIT_174 = new StringValue("3520");
+ public static final StringValue __STR_LIT_175 = new StringValue("3531");
+ public static final StringValue __STR_LIT_176 = new StringValue("3532");
+ public static final StringValue __STR_LIT_177 = new StringValue("3540");
+ public static final StringValue __STR_LIT_178 = new StringValue("3551");
+ public static final StringValue __STR_LIT_179 = new StringValue("3552");
+ public static final StringValue __STR_LIT_180 = new StringValue("3554");
+ public static final StringValue __STR_LIT_181 = new StringValue("3580");
+ public static final StringValue __STR_LIT_182 = new StringValue("3581");
+ public static final StringValue __STR_LIT_183 = new StringValue("3582");
+ public static final StringValue __STR_LIT_184 = new StringValue("3583");
+ public static final StringValue __STR_LIT_185 = new StringValue("3590");
+ public static final StringValue __STR_LIT_186 = new StringValue("3620");
+ public static final StringValue __STR_LIT_187 = new StringValue("3630");
+ public static final StringValue __STR_LIT_188 = new StringValue("3690");
+ public static final StringValue __STR_LIT_189 = new StringValue("3750");
+ public static final StringValue __STR_LIT_190 = new StringValue("3770");
+ public static final StringValue __STR_LIT_191 = new StringValue("3800");
+ public static final StringValue __STR_LIT_192 = new StringValue("3810");
+ public static final StringValue __STR_LIT_193 = new StringValue("3820");
+ public static final StringValue __STR_LIT_194 = new StringValue("3830");
+ public static final StringValue __STR_LIT_195 = new StringValue("3840");
+ public static final StringValue __STR_LIT_196 = new StringValue("3850");
+ public static final StringValue __STR_LIT_197 = new StringValue("3860");
+ public static final StringValue __STR_LIT_198 = new StringValue("3870");
+ public static final StringValue __STR_LIT_199 = new StringValue("3920");
+ public static final StringValue __STR_LIT_200 = new StringValue("5021");
+ public static final StringValue __STR_LIT_201 = new StringValue("5022");
+ public static final StringValue __STR_LIT_202 = new StringValue("5023");
+ public static final StringValue __STR_LIT_203 = new StringValue("5024");
+ public static final StringValue __STR_LIT_204 = new StringValue("5025");
+ public static final StringValue __STR_LIT_205 = new StringValue("5026");
+ public static final StringValue __STR_LIT_206 = new StringValue("5027");
+ public static final StringValue __STR_LIT_207 = new StringValue("5028");
+ public static final StringValue __STR_LIT_208 = new StringValue("5031");
+ public static final StringValue __STR_LIT_209 = new StringValue("5032");
+ public static final StringValue __STR_LIT_210 = new StringValue("5033");
+ public static final StringValue __STR_LIT_211 = new StringValue("5040");
+ public static final StringValue __STR_LIT_212 = new StringValue("5320");
+ public static final StringValue __STR_LIT_213 = new StringValue("5331");
+ public static final StringValue __STR_LIT_214 = new StringValue("5333");
+ public static final StringValue __STR_LIT_215 = new StringValue("5334");
+ public static final StringValue __STR_LIT_216 = new StringValue("5340");
+ public static final StringValue __STR_LIT_217 = new StringValue("5350");
+ public static final StringValue __STR_LIT_218 = new StringValue("5360");
+ public static final StringValue __STR_LIT_219 = new StringValue("5370");
+ public static final StringValue __STR_LIT_220 = new StringValue("5383");
+ public static final StringValue __STR_LIT_221 = new StringValue("5384");
+ public static final StringValue __STR_LIT_222 = new StringValue("5390");
+ public static final StringValue __STR_LIT_223 = new StringValue("5421");
+ public static final StringValue __STR_LIT_224 = new StringValue("5422");
+ public static final StringValue __STR_LIT_225 = new StringValue("5441");
+ public static final StringValue __STR_LIT_226 = new StringValue("5442");
+ public static final StringValue __STR_LIT_227 = new StringValue("5450");
+ public static final StringValue __STR_LIT_228 = new StringValue("5461");
+ public static final StringValue __STR_LIT_229 = new StringValue("5462");
+ public static final StringValue __STR_LIT_230 = new StringValue("5463");
+ public static final StringValue __STR_LIT_231 = new StringValue("5481");
+ public static final StringValue __STR_LIT_232 = new StringValue("5482");
+ public static final StringValue __STR_LIT_233 = new StringValue("5490");
+ public static final StringValue __STR_LIT_234 = new StringValue("5502");
+ public static final StringValue __STR_LIT_235 = new StringValue("5510");
+ public static final StringValue __STR_LIT_236 = new StringValue("5520");
+ public static final StringValue __STR_LIT_237 = new StringValue("5530");
+ public static final StringValue __STR_LIT_238 = new StringValue("5540");
+ public static final StringValue __STR_LIT_239 = new StringValue("5550");
+ public static final StringValue __STR_LIT_240 = new StringValue("5560");
+ public static final StringValue __STR_LIT_241 = new StringValue("5571");
+ public static final StringValue __STR_LIT_242 = new StringValue("5573");
+ public static final StringValue __STR_LIT_243 = new StringValue("5590");
+ public static final StringValue __STR_LIT_244 = new StringValue("5610");
+ public static final StringValue __STR_LIT_245 = new StringValue("5620");
+ public static final StringValue __STR_LIT_246 = new StringValue("5630");
+ public static final StringValue __STR_LIT_247 = new StringValue("5640");
+ public static final StringValue __STR_LIT_248 = new StringValue("5650");
+ public static final StringValue __STR_LIT_249 = new StringValue("5740");
+ public static final StringValue __STR_LIT_250 = new StringValue("5760");
+ public static final StringValue __STR_LIT_251 = new StringValue("5790");
+ public static final StringValue __STR_LIT_252 = new StringValue("5811");
+ public static final StringValue __STR_LIT_253 = new StringValue("5812");
+ public static final StringValue __STR_LIT_254 = new StringValue("5850");
+ public static final StringValue __STR_LIT_255 = new StringValue("5880");
+ public static final StringValue __STR_LIT_256 = new StringValue("5900");
+ public static final StringValue __STR_LIT_257 = new StringValue("5910");
+ public static final StringValue __STR_LIT_258 = new StringValue("5920");
+ public static final StringValue __STR_LIT_259 = new StringValue("5930");
+ public static final StringValue __STR_LIT_260 = new StringValue("5940");
+ public static final StringValue __STR_LIT_261 = new StringValue("5950");
+ public static final StringValue __STR_LIT_262 = new StringValue("5960");
+ public static final StringValue __STR_LIT_263 = new StringValue("5970");
+ public static final StringValue __STR_LIT_264 = new StringValue("6010");
+ public static final StringValue __STR_LIT_265 = new StringValue("6020");
+ public static final StringValue __STR_LIT_266 = new StringValue("6040");
+ public static final StringValue __STR_LIT_267 = new StringValue("6050");
+ public static final StringValue __STR_LIT_268 = new StringValue("6060");
+ public static final StringValue __STR_LIT_269 = new StringValue("6072");
+ public static final StringValue __STR_LIT_270 = new StringValue("6073");
+ public static final StringValue __STR_LIT_271 = new StringValue("6078");
+ public static final StringValue __STR_LIT_272 = new StringValue("6079");
+ public static final StringValue __STR_LIT_273 = new StringValue("6080");
+ public static final StringValue __STR_LIT_274 = new StringValue("6090");
+ public static final StringValue __STR_LIT_275 = new StringValue("6100");
+ public static final StringValue __STR_LIT_276 = new StringValue("6110");
+ public static final StringValue __STR_LIT_277 = new StringValue("6120");
+ public static final StringValue __STR_LIT_278 = new StringValue("6130");
+ public static final StringValue __STR_LIT_279 = new StringValue("6140");
+ public static final StringValue __STR_LIT_280 = new StringValue("6150");
+ public static final StringValue __STR_LIT_281 = new StringValue("6160");
+ public static final StringValue __STR_LIT_282 = new StringValue("6170");
+ public static final StringValue __STR_LIT_283 = new StringValue("6201");
+ public static final StringValue __STR_LIT_284 = new StringValue("6242");
+ public static final StringValue __STR_LIT_285 = new StringValue("6260");
+ public static final StringValue __STR_LIT_286 = new StringValue("6300");
+ public static final StringValue __STR_LIT_287 = new StringValue("6341");
+ public static final StringValue __STR_LIT_288 = new StringValue("6350");
+ public static final StringValue __STR_LIT_289 = new StringValue("6440");
+ public static final StringValue __STR_LIT_290 = new StringValue("6460");
+ public static final StringValue __STR_LIT_291 = new StringValue("6470");
+ public static final StringValue __STR_LIT_292 = new StringValue("6480");
+ public static final StringValue __STR_LIT_293 = new StringValue("6490");
+ public static final StringValue __STR_LIT_294 = new StringValue("6520");
+ public static final StringValue __STR_LIT_295 = new StringValue("6561");
+ public static final StringValue __STR_LIT_296 = new StringValue("6562");
+ public static final StringValue __STR_LIT_297 = new StringValue("6570");
+ public static final StringValue __STR_LIT_298 = new StringValue("6580");
+ public static final StringValue __STR_LIT_299 = new StringValue("6651");
+ public static final StringValue __STR_LIT_300 = new StringValue("6652");
+ public static final StringValue __STR_LIT_301 = new StringValue("6871");
+ public static final StringValue __STR_LIT_302 = new StringValue("6872");
+ public static final StringValue __STR_LIT_303 = new StringValue("6930");
+ public static final StringValue __STR_LIT_304 = new StringValue("6950");
+ public static final StringValue __STR_LIT_305 = new StringValue("6960");
+ public static final StringValue __STR_LIT_306 = new StringValue("6980");
+ public static final StringValue __STR_LIT_307 = new StringValue("6990");
+ public static final StringValue __STR_LIT_308 = new StringValue("7030");
+ public static final StringValue __STR_LIT_309 = new StringValue("7040");
+ public static final StringValue __STR_LIT_310 = new StringValue("7080");
+ public static final StringValue __STR_LIT_311 = new StringValue("7100");
+ public static final StringValue __STR_LIT_312 = new StringValue("7130");
+ public static final StringValue __STR_LIT_313 = new StringValue("7150");
+ public static final StringValue __STR_LIT_314 = new StringValue("7160");
+ public static final StringValue __STR_LIT_315 = new StringValue("7170");
+ public static final StringValue __STR_LIT_316 = new StringValue("7191");
+ public static final StringValue __STR_LIT_317 = new StringValue("7192");
+ public static final StringValue __STR_LIT_318 = new StringValue("7221");
+ public static final StringValue __STR_LIT_319 = new StringValue("7222");
+ public static final StringValue __STR_LIT_320 = new StringValue("7230");
+ public static final StringValue __STR_LIT_321 = new StringValue("7340");
+ public static final StringValue __STR_LIT_322 = new StringValue("7353");
+ public static final StringValue __STR_LIT_323 = new StringValue("7360");
+ public static final StringValue __STR_LIT_324 = new StringValue("7371");
+ public static final StringValue __STR_LIT_325 = new StringValue("7373");
+ public static final StringValue __STR_LIT_326 = new StringValue("7380");
+ public static final StringValue __STR_LIT_327 = new StringValue("7390");
+ public static final StringValue __STR_LIT_328 = new StringValue("7400");
+ public static final StringValue __STR_LIT_329 = new StringValue("7410");
+ public static final StringValue __STR_LIT_330 = new StringValue("7441");
+ public static final StringValue __STR_LIT_331 = new StringValue("7442");
+ public static final StringValue __STR_LIT_332 = new StringValue("7470");
+ public static final StringValue __STR_LIT_333 = new StringValue("7480");
+ public static final StringValue __STR_LIT_334 = new StringValue("7490");
+ public static final StringValue __STR_LIT_335 = new StringValue("7500");
+ public static final StringValue __STR_LIT_336 = new StringValue("7510");
+ public static final StringValue __STR_LIT_337 = new StringValue("7530");
+ public static final StringValue __STR_LIT_338 = new StringValue("7711");
+ public static final StringValue __STR_LIT_339 = new StringValue("7712");
+ public static final StringValue __STR_LIT_340 = new StringValue("7713");
+ public static final StringValue __STR_LIT_341 = new StringValue("7714");
+ public static final StringValue __STR_LIT_342 = new StringValue("7720");
+ public static final StringValue __STR_LIT_343 = new StringValue("7740");
+ public static final StringValue __STR_LIT_344 = new StringValue("7770");
+ public static final StringValue __STR_LIT_345 = new StringValue("7861");
+ public static final StringValue __STR_LIT_346 = new StringValue("7862");
+ public static final StringValue __STR_LIT_347 = new StringValue("7863");
+ public static final StringValue __STR_LIT_348 = new StringValue("8041");
+ public static final StringValue __STR_LIT_349 = new StringValue("8044");
+ public static final StringValue __STR_LIT_350 = new StringValue("8050");
+ public static final StringValue __STR_LIT_351 = new StringValue("8070");
+ public static final StringValue __STR_LIT_352 = new StringValue("6550");
+ public static final StringValue __STR_LIT_353 = new StringValue("7760");
+ public static final StringValue __STR_LIT_354 = new StringValue("5750");
+ public static final StringValue __STR_LIT_355 = new StringValue("7870");
+ public static final StringValue __STR_LIT_356 = new StringValue("0810");
+ public static final StringValue __STR_LIT_357 = new StringValue("620A");
+ public static final StringValue __STR_LIT_358 = new StringValue("0991");
+ public static final StringValue __STR_LIT_359 = new StringValue("0993");
+ public static final StringValue __STR_LIT_360 = new StringValue("5301");
+ public static final StringValue __STR_LIT_361 = new StringValue("5302");
+ public static final StringValue __STR_LIT_362 = new StringValue("5303");
+ public static final StringValue __STR_LIT_363 = new StringValue("5304");
+ public static final StringValue __STR_LIT_364 = new StringValue("5305");
+ public static final StringValue __STR_LIT_365 = new StringValue("5332");
+ public static final StringValue __STR_LIT_366 = new StringValue("0080");
+ public static final StringValue __STR_LIT_367 = new StringValue("5863");
+ public static final StringValue __STR_LIT_368 = new StringValue("5253");
+ public static final StringValue __STR_LIT_369 = new StringValue("5254");
+ public static final StringValue __STR_LIT_370 = new StringValue("0200");
+ public static final StringValue __STR_LIT_371 = new StringValue("3500");
+ public static final StringValue __STR_LIT_372 = new StringValue("7840");
+ public static final StringValue __STR_LIT_373 = new StringValue("0260");
+ public static final StringValue __STR_LIT_374 = new StringValue("0301");
+ public static final StringValue __STR_LIT_375 = new StringValue("0302");
+ public static final StringValue __STR_LIT_376 = new StringValue("0310");
+ public static final StringValue __STR_LIT_377 = new StringValue("0380");
+ public static final StringValue __STR_LIT_378 = new StringValue("0370");
+ public static final StringValue __STR_LIT_379 = new StringValue("5130");
+ public static final StringValue __STR_LIT_380 = new StringValue("5151");
+ public static final StringValue __STR_LIT_381 = new StringValue("5140");
+ public static final StringValue __STR_LIT_382 = new StringValue("0360");
+ public static final StringValue __STR_LIT_383 = new StringValue("0530");
+ public static final StringValue __STR_LIT_384 = new StringValue("0960");
+ public static final StringValue __STR_LIT_385 = new StringValue("0551");
+ public static final StringValue __STR_LIT_386 = new StringValue("0560");
+ public static final StringValue __STR_LIT_387 = new StringValue("0490");
+ public static final StringValue __STR_LIT_388 = new StringValue("0014");
+ public static final StringValue __STR_LIT_389 = new StringValue("1390");
+ public static final StringValue __STR_LIT_390 = new StringValue("0209");
+ public static final StringValue __STR_LIT_391 = new StringValue("1630");
+ public static final StringValue __STR_LIT_392 = new StringValue("1020");
+ public static final StringValue __STR_LIT_393 = new StringValue("0620");
+ public static final StringValue __STR_LIT_394 = new StringValue("1350");
+ public static final StringValue __STR_LIT_395 = new StringValue("0500");
+ public static final StringValue __STR_LIT_396 = new StringValue("0540");
+ public static final StringValue __STR_LIT_397 = new StringValue("2271");
+ public static final StringValue __STR_LIT_398 = new StringValue("2272");
+ public static final StringValue __STR_LIT_399 = new StringValue("2574");
+ public static final StringValue __STR_LIT_400 = new StringValue("1120");
+ public static final StringValue __STR_LIT_401 = new StringValue("2660");
+ public static final StringValue __STR_LIT_402 = new StringValue("2740");
+ public static final StringValue __STR_LIT_403 = new StringValue("2790");
+ public static final StringValue __STR_LIT_404 = new StringValue("0013");
+ public static final StringValue __STR_LIT_405 = new StringValue("1590");
+ public static final StringValue __STR_LIT_406 = new StringValue("1000");
+ public static final StringValue __STR_LIT_407 = new StringValue("1430");
+ public static final StringValue __STR_LIT_408 = new StringValue("1030");
+ public static final StringValue __STR_LIT_409 = new StringValue("1450");
+ public static final StringValue __STR_LIT_410 = new StringValue("0980");
+ public static final StringValue __STR_LIT_411 = new StringValue("0520");
+ public static final StringValue __STR_LIT_412 = new StringValue("1050");
+ public static final StringValue __STR_LIT_413 = new StringValue("1090");
+ public static final StringValue __STR_LIT_414 = new StringValue("1110");
+ public static final StringValue __STR_LIT_415 = new StringValue("1100");
+ public static final StringValue __STR_LIT_416 = new StringValue("0140");
+ public static final StringValue __STR_LIT_417 = new StringValue("1130");
+ public static final StringValue __STR_LIT_418 = new StringValue("1140");
+ public static final StringValue __STR_LIT_419 = new StringValue("0121");
+ public static final StringValue __STR_LIT_420 = new StringValue("0130");
+ public static final StringValue __STR_LIT_421 = new StringValue("0270");
+ public static final StringValue __STR_LIT_422 = new StringValue("1291");
+ public static final StringValue __STR_LIT_423 = new StringValue("1292");
+ public static final StringValue __STR_LIT_424 = new StringValue("1293");
+ public static final StringValue __STR_LIT_425 = new StringValue("3712");
+ public static final StringValue __STR_LIT_426 = new StringValue("3670");
+ public static final StringValue __STR_LIT_427 = new StringValue("0510");
+ public static final StringValue __STR_LIT_428 = new StringValue("1340");
+ public static final StringValue __STR_LIT_429 = new StringValue("1330");
+ public static final StringValue __STR_LIT_430 = new StringValue("1360");
+ public static final StringValue __STR_LIT_431 = new StringValue("5020");
+ public static final StringValue __STR_LIT_432 = new StringValue("5080");
+ public static final StringValue __STR_LIT_433 = new StringValue("5030");
+ public static final StringValue __STR_LIT_434 = new StringValue("2590");
+ public static final StringValue __STR_LIT_435 = new StringValue("5312");
+ public static final StringValue __STR_LIT_436 = new StringValue("5382");
+ public static final StringValue __STR_LIT_437 = new StringValue("5391");
+ public static final StringValue __STR_LIT_438 = new StringValue("5501");
+ public static final StringValue __STR_LIT_439 = new StringValue("5386");
+ public static final StringValue __STR_LIT_440 = new StringValue("5381");
+ public static final StringValue __STR_LIT_441 = new StringValue("0750");
+ public static final StringValue __STR_LIT_442 = new StringValue("0740");
+ public static final StringValue __STR_LIT_443 = new StringValue("2610");
+ public static final StringValue __STR_LIT_444 = new StringValue("5680");
+ public static final StringValue __STR_LIT_445 = new StringValue("5732");
+ public static final StringValue __STR_LIT_446 = new StringValue("5701");
+ public static final StringValue __STR_LIT_447 = new StringValue("5252");
+ public static final StringValue __STR_LIT_448 = new StringValue("5251");
+ public static final StringValue __STR_LIT_449 = new StringValue("5842");
+ public static final StringValue __STR_LIT_450 = new StringValue("5861");
+ public static final StringValue __STR_LIT_451 = new StringValue("5891");
+ public static final StringValue __STR_LIT_452 = new StringValue("6000");
+ public static final StringValue __STR_LIT_453 = new StringValue("6031");
+ public static final StringValue __STR_LIT_454 = new StringValue("6033");
+ public static final StringValue __STR_LIT_455 = new StringValue("6034");
+ public static final StringValue __STR_LIT_456 = new StringValue("6071");
+ public static final StringValue __STR_LIT_457 = new StringValue("607A");
+ public static final StringValue __STR_LIT_458 = new StringValue("6074");
+ public static final StringValue __STR_LIT_459 = new StringValue("6075");
+ public static final StringValue __STR_LIT_460 = new StringValue("6076");
+ public static final StringValue __STR_LIT_461 = new StringValue("6077");
+ public static final StringValue __STR_LIT_462 = new StringValue("6208");
+ public static final StringValue __STR_LIT_463 = new StringValue("6244");
+ public static final StringValue __STR_LIT_464 = new StringValue("6212");
+ public static final StringValue __STR_LIT_465 = new StringValue("1540");
+ public static final StringValue __STR_LIT_466 = new StringValue("6345");
+ public static final StringValue __STR_LIT_467 = new StringValue("6203");
+ public static final StringValue __STR_LIT_468 = new StringValue("6205");
+ public static final StringValue __STR_LIT_469 = new StringValue("6207");
+ public static final StringValue __STR_LIT_470 = new StringValue("5831");
+ public static final StringValue __STR_LIT_471 = new StringValue("5832");
+ public static final StringValue __STR_LIT_472 = new StringValue("6521");
+ public static final StringValue __STR_LIT_473 = new StringValue("6670");
+ public static final StringValue __STR_LIT_474 = new StringValue("6583");
+ public static final StringValue __STR_LIT_475 = new StringValue("6581");
+ public static final StringValue __STR_LIT_476 = new StringValue("6650");
+ public static final StringValue __STR_LIT_477 = new StringValue("6522");
+ public static final StringValue __STR_LIT_478 = new StringValue("6870");
+ public static final StringValue __STR_LIT_479 = new StringValue("6780");
+ public static final StringValue __STR_LIT_480 = new StringValue("7190");
+ public static final StringValue __STR_LIT_481 = new StringValue("6731");
+ public static final StringValue __STR_LIT_482 = new StringValue("6770");
+ public static final StringValue __STR_LIT_483 = new StringValue("6910");
+ public static final StringValue __STR_LIT_484 = new StringValue("6810");
+ public static final StringValue __STR_LIT_485 = new StringValue("6860");
+ public static final StringValue __STR_LIT_486 = new StringValue("7070");
+ public static final StringValue __STR_LIT_487 = new StringValue("620B");
+ public static final StringValue __STR_LIT_488 = new StringValue("7220");
+ public static final StringValue __STR_LIT_489 = new StringValue("7532");
+ public static final StringValue __STR_LIT_490 = new StringValue("7312");
+ public static final StringValue __STR_LIT_491 = new StringValue("7590");
+ public static final StringValue __STR_LIT_492 = new StringValue("7352");
+ public static final StringValue __STR_LIT_493 = new StringValue("7370");
+ public static final StringValue __STR_LIT_494 = new StringValue("7381");
+ public static final StringValue __STR_LIT_495 = new StringValue("7382");
+ public static final StringValue __STR_LIT_496 = new StringValue("7440");
+ public static final StringValue __STR_LIT_497 = new StringValue("7570");
+ public static final StringValue __STR_LIT_498 = new StringValue("7461");
+ public static final StringValue __STR_LIT_499 = new StringValue("7465");
+ public static final StringValue __STR_LIT_500 = new StringValue("7464");
+ public static final StringValue __STR_LIT_501 = new StringValue("7462");
+ public static final StringValue __STR_LIT_502 = new StringValue("7466");
+ public static final StringValue __STR_LIT_503 = new StringValue("7531");
+ public static final StringValue __STR_LIT_504 = new StringValue("7710");
+ public static final StringValue __STR_LIT_505 = new StringValue("7690");
+ public static final StringValue __STR_LIT_506 = new StringValue("7721");
+ public static final StringValue __STR_LIT_507 = new StringValue("6202");
+ public static final StringValue __STR_LIT_508 = new StringValue("7860");
+ public static final StringValue __STR_LIT_509 = new StringValue("8060");
+ public static final StringValue __STR_LIT_510 = new StringValue("8022");
+ public static final StringValue __STR_LIT_511 = new StringValue("8012");
+ public static final StringValue __STR_LIT_512 = new StringValue("8071");
+ public static final StringValue __STR_LIT_513 = new StringValue("7810");
+ public static final StringValue __STR_LIT_514 = new StringValue("0811");
+ public static final StringValue __STR_LIT_515 = new StringValue("0060");
+ public static final StringValue __STR_LIT_516 = new StringValue("20091");
+ public static final StringValue __STR_LIT_517 = new StringValue("7723");
+ public static final StringValue __STR_LIT_518 = new StringValue("5751");
+ public static final StringValue __STR_LIT_519 = new StringValue("5315");
+ public static final StringValue __STR_LIT_520 = new StringValue("4982");
+ public static final StringValue __STR_LIT_521 = new StringValue("4991");
+ public static final StringValue __STR_LIT_522 = new StringValue("4981");
+ public static final StringValue __STR_LIT_523 = new StringValue("4983");
+ public static final StringValue __STR_LIT_524 = new StringValue("4992");
+ public static final StringValue __STR_LIT_525 = new StringValue("5330");
+ public static final StringValue __STR_LIT_526 = new StringValue("20122");
+ public static final StringValue __STR_LIT_527 = new StringValue("1311");
+ public static final StringValue __STR_LIT_528 = new StringValue("06");
+ public static final StringValue __STR_LIT_529 = new StringValue("16");
+ public static final StringValue __STR_LIT_530 = new StringValue("11");
+ public static final StringValue __STR_LIT_531 = new StringValue("100");
+ public static final StringValue __STR_LIT_532 = new StringValue("200");
+ public static final StringValue __STR_LIT_533 = new StringValue("300");
+ public static final StringValue __STR_LIT_534 = new StringValue("400");
+ public static final StringValue __STR_LIT_535 = new StringValue("500");
+ public static final StringValue __STR_LIT_536 = new StringValue("600");
+ public static final StringValue __STR_LIT_537 = new StringValue("7");
+ public static final StringValue __STR_LIT_538 = new StringValue("700");
+ public static final StringValue __STR_LIT_539 = new StringValue("8");
+ public static final StringValue __STR_LIT_540 = new StringValue("800");
+ public static final StringValue __STR_LIT_541 = new StringValue("9");
+ public static final StringValue __STR_LIT_542 = new StringValue("900");
+ public static final StringValue __STR_LIT_543 = new StringValue("290");
+ public static final StringValue __STR_LIT_544 = new StringValue("03");
+ public static final StringValue __STR_LIT_545 = new StringValue("04");
+ public static final StringValue __STR_LIT_546 = new StringValue("96");
+ public static final StringValue __STR_LIT_547 = new StringValue("10");
+ public static final StringValue __STR_LIT_548 = new StringValue("135");
+ public static final NumberValue __NUM_LIT_11 = new NumberValue(1400.0);
+ public static final NumberValue __NUM_LIT_12 = new NumberValue(1401.0);
+ public static final NumberValue __NUM_LIT_13 = new NumberValue(1800.0);
+ public static final NumberValue __NUM_LIT_14 = new NumberValue(1150.0);
+ public static final NumberValue __NUM_LIT_15 = new NumberValue(1151.0);
+ public static final NumberValue __NUM_LIT_16 = new NumberValue(1399.0);
+ public static final NumberValue __NUM_LIT_17 = new NumberValue(900.0);
+ public static final NumberValue __NUM_LIT_18 = new NumberValue(901.0);
+ public static final NumberValue __NUM_LIT_19 = new NumberValue(1149.0);
+ public static final NumberValue __NUM_LIT_20 = new NumberValue(650.0);
+ public static final NumberValue __NUM_LIT_21 = new NumberValue(651.0);
+ public static final NumberValue __NUM_LIT_22 = new NumberValue(899.0);
+ public static final NumberValue __NUM_LIT_23 = new NumberValue(400.0);
+ public static final NumberValue __NUM_LIT_24 = new NumberValue(401.0);
+ public static final NumberValue __NUM_LIT_25 = new NumberValue(649.0);
+ public static final NumberValue __NUM_LIT_26 = new NumberValue(399.0);
+ public static final StringValue __STR_LIT_549 = new StringValue("31");
+ public static final StringValue __STR_LIT_550 = new StringValue("51");
+ public static final StringValue __STR_LIT_551 = new StringValue("76");
+ public static final NumberValue __NUM_LIT_27 = new NumberValue(6.0E7);
+ public static final NumberValue __NUM_LIT_28 = new NumberValue(6.0000001E7);
+ public static final NumberValue __NUM_LIT_29 = new NumberValue(7.9999999E7);
+ public static final NumberValue __NUM_LIT_30 = new NumberValue(99.0);
+ public static final NumberValue __NUM_LIT_31 = new NumberValue(101.0);
+ public static final NumberValue __NUM_LIT_32 = new NumberValue(102.0);
+ public static final NumberValue __NUM_LIT_33 = new NumberValue(199.0);
+ public static final NumberValue __NUM_LIT_34 = new NumberValue(201.0);
+ public static final NumberValue __NUM_LIT_35 = new NumberValue(202.0);
+ public static final NumberValue __NUM_LIT_36 = new NumberValue(299.0);
+ public static final NumberValue __NUM_LIT_37 = new NumberValue(301.0);
+ public static final NumberValue __NUM_LIT_38 = new NumberValue(302.0);
+ public static final NumberValue __NUM_LIT_39 = new NumberValue(402.0);
+ public static final NumberValue __NUM_LIT_40 = new NumberValue(450.0);
+ public static final NumberValue __NUM_LIT_41 = new NumberValue(652.0);
+ public static final NumberValue __NUM_LIT_42 = new NumberValue(699.0);
+ public static final NumberValue __NUM_LIT_43 = new NumberValue(701.0);
+ public static final NumberValue __NUM_LIT_44 = new NumberValue(702.0);
+ public static final NumberValue __NUM_LIT_45 = new NumberValue(750.0);
+ public static final NumberValue __NUM_LIT_46 = new NumberValue(0.0);
+ public static final NumberValue __NUM_LIT_47 = new NumberValue(50.0);
+ public static final NumberValue __NUM_LIT_48 = new NumberValue(51.0);
+ public static final NumberValue __NUM_LIT_49 = new NumberValue(52.0);
+ public static final NumberValue __NUM_LIT_50 = new NumberValue(150.0);
+ public static final NumberValue __NUM_LIT_51 = new NumberValue(151.0);
+ public static final NumberValue __NUM_LIT_52 = new NumberValue(152.0);
+ public static final NumberValue __NUM_LIT_53 = new NumberValue(250.0);
+ public static final NumberValue __NUM_LIT_54 = new NumberValue(251.0);
+ public static final NumberValue __NUM_LIT_55 = new NumberValue(252.0);
+ public static final NumberValue __NUM_LIT_56 = new NumberValue(350.0);
+ public static final NumberValue __NUM_LIT_57 = new NumberValue(351.0);
+ public static final NumberValue __NUM_LIT_58 = new NumberValue(352.0);
+ public static final StringValue __STR_LIT_552 = new StringValue("98");
+ public static final StringValue __STR_LIT_553 = new StringValue("999");
+ public static final StringValue __STR_LIT_554 = new StringValue("95");
+ public static final StringValue __STR_LIT_555 = new StringValue("196");
+ public static final StringValue __STR_LIT_556 = new StringValue("195");
+ public static final StringValue __STR_LIT_557 = new StringValue("295");
+ public static final StringValue __STR_LIT_558 = new StringValue("395");
+ public static final StringValue __STR_LIT_559 = new StringValue("495");
+ public static final StringValue __STR_LIT_560 = new StringValue("595");
+ public static final StringValue __STR_LIT_561 = new StringValue("695");
+ public static final StringValue __STR_LIT_562 = new StringValue("795");
+ public static final StringValue __STR_LIT_563 = new StringValue("895");
+ public static final StringValue __STR_LIT_564 = new StringValue("995");
+ public static final StringValue __STR_LIT_565 = new StringValue("0150");
+ public static final StringValue __STR_LIT_566 = new StringValue("5070");
+ public static final StringValue __STR_LIT_567 = new StringValue("5180");
+ public static final StringValue __STR_LIT_568 = new StringValue("5220");
+ public static final StringValue __STR_LIT_569 = new StringValue("6390");
+ public static final StringValue __STR_LIT_570 = new StringValue("7020");
+ public static final StringValue __STR_LIT_571 = new StringValue("7180");
+ public static final NumberValue __NUM_LIT_59 = new NumberValue(8.0);
+ public static final NumberValue __NUM_LIT_60 = new NumberValue(10.0);
+ public static final NumberValue __NUM_LIT_61 = new NumberValue(98.0);
+ public static final NumberValue __NUM_LIT_62 = new NumberValue(9.0);
+ public static final NumberValue __NUM_LIT_63 = new NumberValue(11.0);
+ public static final StringValue __STR_LIT_572 = new StringValue("0081");
+ public static final StringValue __STR_LIT_573 = new StringValue("0089");
+ public static final StringValue __STR_LIT_574 = new StringValue("0261");
+ public static final StringValue __STR_LIT_575 = new StringValue("0269");
+ public static final StringValue __STR_LIT_576 = new StringValue("0271");
+ public static final StringValue __STR_LIT_577 = new StringValue("0279");
+ public static final StringValue __STR_LIT_578 = new StringValue("0309");
+ public static final StringValue __STR_LIT_579 = new StringValue("0311");
+ public static final StringValue __STR_LIT_580 = new StringValue("0319");
+ public static final StringValue __STR_LIT_581 = new StringValue("0361");
+ public static final StringValue __STR_LIT_582 = new StringValue("0369");
+ public static final StringValue __STR_LIT_583 = new StringValue("0371");
+ public static final StringValue __STR_LIT_584 = new StringValue("0379");
+ public static final StringValue __STR_LIT_585 = new StringValue("0491");
+ public static final StringValue __STR_LIT_586 = new StringValue("0499");
+ public static final StringValue __STR_LIT_587 = new StringValue("0640");
+ public static final StringValue __STR_LIT_588 = new StringValue("0650");
+ public static final StringValue __STR_LIT_589 = new StringValue("0950");
+ public static final StringValue __STR_LIT_590 = new StringValue("1001");
+ public static final StringValue __STR_LIT_591 = new StringValue("1011");
+ public static final StringValue __STR_LIT_592 = new StringValue("1021");
+ public static final StringValue __STR_LIT_593 = new StringValue("1029");
+ public static final StringValue __STR_LIT_594 = new StringValue("1031");
+ public static final StringValue __STR_LIT_595 = new StringValue("1039");
+ public static final StringValue __STR_LIT_596 = new StringValue("1081");
+ public static final StringValue __STR_LIT_597 = new StringValue("1089");
+ public static final StringValue __STR_LIT_598 = new StringValue("1091");
+ public static final StringValue __STR_LIT_599 = new StringValue("1099");
+ public static final StringValue __STR_LIT_600 = new StringValue("1101");
+ public static final StringValue __STR_LIT_601 = new StringValue("1109");
+ public static final StringValue __STR_LIT_602 = new StringValue("1111");
+ public static final StringValue __STR_LIT_603 = new StringValue("1119");
+ public static final StringValue __STR_LIT_604 = new StringValue("1121");
+ public static final StringValue __STR_LIT_605 = new StringValue("1129");
+ public static final StringValue __STR_LIT_606 = new StringValue("1161");
+ public static final StringValue __STR_LIT_607 = new StringValue("1169");
+ public static final StringValue __STR_LIT_608 = new StringValue("1241");
+ public static final StringValue __STR_LIT_609 = new StringValue("1249");
+ public static final StringValue __STR_LIT_610 = new StringValue("1251");
+ public static final StringValue __STR_LIT_611 = new StringValue("1258");
+ public static final StringValue __STR_LIT_612 = new StringValue("1259");
+ public static final StringValue __STR_LIT_613 = new StringValue("1271");
+ public static final StringValue __STR_LIT_614 = new StringValue("1279");
+ public static final StringValue __STR_LIT_615 = new StringValue("1319");
+ public static final StringValue __STR_LIT_616 = new StringValue("1321");
+ public static final StringValue __STR_LIT_617 = new StringValue("1329");
+ public static final StringValue __STR_LIT_618 = new StringValue("1331");
+ public static final StringValue __STR_LIT_619 = new StringValue("1339");
+ public static final StringValue __STR_LIT_620 = new StringValue("1341");
+ public static final StringValue __STR_LIT_621 = new StringValue("1349");
+ public static final StringValue __STR_LIT_622 = new StringValue("1361");
+ public static final StringValue __STR_LIT_623 = new StringValue("1362");
+ public static final StringValue __STR_LIT_624 = new StringValue("1369");
+ public static final StringValue __STR_LIT_625 = new StringValue("1378");
+ public static final StringValue __STR_LIT_626 = new StringValue("1379");
+ public static final StringValue __STR_LIT_627 = new StringValue("1481");
+ public static final StringValue __STR_LIT_628 = new StringValue("1489");
+ public static final StringValue __STR_LIT_629 = new StringValue("1491");
+ public static final StringValue __STR_LIT_630 = new StringValue("1499");
+ public static final StringValue __STR_LIT_631 = new StringValue("1639");
+ public static final StringValue __STR_LIT_632 = new StringValue("1731");
+ public static final StringValue __STR_LIT_633 = new StringValue("1739");
+ public static final StringValue __STR_LIT_634 = new StringValue("1821");
+ public static final StringValue __STR_LIT_635 = new StringValue("1829");
+ public static final StringValue __STR_LIT_636 = new StringValue("5150");
+ public static final StringValue __STR_LIT_637 = new StringValue("5160");
+ public static final StringValue __STR_LIT_638 = new StringValue("6245");
+ public static final StringValue __STR_LIT_639 = new StringValue("7467");
+ public static final StringValue __STR_LIT_640 = new StringValue("6380");
+ public static final StringValue __STR_LIT_641 = new StringValue("8100");
+ public static final NumberValue __NUM_LIT_64 = new NumberValue(1912.0);
+ public static final NumberValue __NUM_LIT_65 = new NumberValue(1913.0);
+ public static final NumberValue __NUM_LIT_66 = new NumberValue(2020.0);
+ public static final NumberValue __NUM_LIT_67 = new NumberValue(1923.0);
+ public static final NumberValue __NUM_LIT_68 = new NumberValue(1924.0);
+ public static final NumberValue __NUM_LIT_69 = new NumberValue(1930.0);
+ public static final NumberValue __NUM_LIT_70 = new NumberValue(1931.0);
+ public static final StringValue __STR_LIT_642 = new StringValue("0801");
+ public static final StringValue __STR_LIT_643 = new StringValue("0802");
+ public static final StringValue __STR_LIT_644 = new StringValue("0803");
+ public static final StringValue __STR_LIT_645 = new StringValue("0804");
+ public static final StringValue __STR_LIT_646 = new StringValue("0805");
+ public static final StringValue __STR_LIT_647 = new StringValue("0806");
+ public static final StringValue __STR_LIT_648 = new StringValue("0807");
+ public static final StringValue __STR_LIT_649 = new StringValue("0808");
+ public static final StringValue __STR_LIT_650 = new StringValue("0809");
+ public static final StringValue __STR_LIT_651 = new StringValue("0812");
+ public static final StringValue __STR_LIT_652 = new StringValue("0813");
+ public static final StringValue __STR_LIT_653 = new StringValue("0814");
+ public static final StringValue __STR_LIT_654 = new StringValue("0815");
+ public static final StringValue __STR_LIT_655 = new StringValue("0816");
+ public static final StringValue __STR_LIT_656 = new StringValue("0901");
+ public static final StringValue __STR_LIT_657 = new StringValue("0902");
+ public static final StringValue __STR_LIT_658 = new StringValue("0903");
+ public static final StringValue __STR_LIT_659 = new StringValue("0904");
+ public static final StringValue __STR_LIT_660 = new StringValue("0905");
+ public static final StringValue __STR_LIT_661 = new StringValue("0906");
+ public static final StringValue __STR_LIT_662 = new StringValue("0907");
+ public static final StringValue __STR_LIT_663 = new StringValue("0908");
+ public static final StringValue __STR_LIT_664 = new StringValue("0909");
+ public static final StringValue __STR_LIT_665 = new StringValue("0910");
+ public static final StringValue __STR_LIT_666 = new StringValue("0911");
+ public static final StringValue __STR_LIT_667 = new StringValue("0912");
+ public static final StringValue __STR_LIT_668 = new StringValue("0913");
+ public static final StringValue __STR_LIT_669 = new StringValue("0914");
+ public static final StringValue __STR_LIT_670 = new StringValue("0915");
+ public static final StringValue __STR_LIT_671 = new StringValue("0916");
+ public static final StringValue __STR_LIT_672 = new StringValue("240");
+ public static final StringValue __STR_LIT_673 = new StringValue("0020");
+ public static final StringValue __STR_LIT_674 = new StringValue("0180");
+ public static final StringValue __STR_LIT_675 = new StringValue("0190");
+ public static final StringValue __STR_LIT_676 = new StringValue("0390");
+ public static final StringValue __STR_LIT_677 = new StringValue("0590");
+ public static final StringValue __STR_LIT_678 = new StringValue("0630");
+ public static final StringValue __STR_LIT_679 = new StringValue("0780");
+ public static final StringValue __STR_LIT_680 = new StringValue("0860");
+ public static final StringValue __STR_LIT_681 = new StringValue("1210");
+ public static final StringValue __STR_LIT_682 = new StringValue("1380");
+ public static final StringValue __STR_LIT_683 = new StringValue("1410");
+ public static final StringValue __STR_LIT_684 = new StringValue("1500");
+ public static final StringValue __STR_LIT_685 = new StringValue("1510");
+ public static final StringValue __STR_LIT_686 = new StringValue("1820");
+ public static final StringValue __STR_LIT_687 = new StringValue("1921");
+ public static final StringValue __STR_LIT_688 = new StringValue("2350");
+ public static final StringValue __STR_LIT_689 = new StringValue("2520");
+ public static final StringValue __STR_LIT_690 = new StringValue("2600");
+ public static final StringValue __STR_LIT_691 = new StringValue("2800");
+ public static final StringValue __STR_LIT_692 = new StringValue("3030");
+ public static final StringValue __STR_LIT_693 = new StringValue("5100");
+ public static final StringValue __STR_LIT_694 = new StringValue("5110");
+ public static final StringValue __STR_LIT_695 = new StringValue("5120");
+ public static final StringValue __STR_LIT_696 = new StringValue("5152");
+ public static final StringValue __STR_LIT_697 = new StringValue("5161");
+ public static final StringValue __STR_LIT_698 = new StringValue("5162");
+ public static final StringValue __STR_LIT_699 = new StringValue("5163");
+ public static final StringValue __STR_LIT_700 = new StringValue("5200");
+ public static final StringValue __STR_LIT_701 = new StringValue("5260");
+ public static final StringValue __STR_LIT_702 = new StringValue("5313");
+ public static final StringValue __STR_LIT_703 = new StringValue("5314");
+ public static final StringValue __STR_LIT_704 = new StringValue("5400");
+ public static final StringValue __STR_LIT_705 = new StringValue("5660");
+ public static final StringValue __STR_LIT_706 = new StringValue("5720");
+ public static final StringValue __STR_LIT_707 = new StringValue("5770");
+ public static final StringValue __STR_LIT_708 = new StringValue("5820");
+ public static final StringValue __STR_LIT_709 = new StringValue("6211");
+ public static final StringValue __STR_LIT_710 = new StringValue("6232");
+ public static final StringValue __STR_LIT_711 = new StringValue("6290");
+ public static final StringValue __STR_LIT_712 = new StringValue("6283");
+ public static final StringValue __STR_LIT_713 = new StringValue("6344");
+ public static final StringValue __STR_LIT_714 = new StringValue("6370");
+ public static final StringValue __STR_LIT_715 = new StringValue("6381");
+ public static final StringValue __STR_LIT_716 = new StringValue("6402");
+ public static final StringValue __STR_LIT_717 = new StringValue("6432");
+ public static final StringValue __STR_LIT_718 = new StringValue("6510");
+ public static final StringValue __STR_LIT_719 = new StringValue("6523");
+ public static final StringValue __STR_LIT_720 = new StringValue("6531");
+ public static final StringValue __STR_LIT_721 = new StringValue("6533");
+ public static final StringValue __STR_LIT_722 = new StringValue("6660");
+ public static final StringValue __STR_LIT_723 = new StringValue("6830");
+ public static final StringValue __STR_LIT_724 = new StringValue("7700");
+ public static final StringValue __STR_LIT_725 = new StringValue("7722");
+ public static final StringValue __STR_LIT_726 = new StringValue("7780");
+ public static final StringValue __STR_LIT_727 = new StringValue("7790");
+ public static final StringValue __STR_LIT_728 = new StringValue("7910");
+ public static final StringValue __STR_LIT_729 = new StringValue("7931");
+ public static final StringValue __STR_LIT_730 = new StringValue("7932");
+ public static final StringValue __STR_LIT_731 = new StringValue("7940");
+ public static final StringValue __STR_LIT_732 = new StringValue("7950");
+ public static final StringValue __STR_LIT_733 = new StringValue("7960");
+ public static final StringValue __STR_LIT_734 = new StringValue("8000");
+ public static final StringValue __STR_LIT_735 = new StringValue("8011");
+ public static final StringValue __STR_LIT_736 = new StringValue("8021");
+ public static final StringValue __STR_LIT_737 = new StringValue("8031");
+ public static final StringValue __STR_LIT_738 = new StringValue("8032");
+ public static final StringValue __STR_LIT_739 = new StringValue("8033");
+ public static final StringValue __STR_LIT_740 = new StringValue("8080");
+ public static final StringValue __STR_LIT_741 = new StringValue("8101");
+ public static final StringValue __STR_LIT_742 = new StringValue("8102");
+ public static final StringValue __STR_LIT_743 = new StringValue("8103");
+ public static final StringValue __STR_LIT_744 = new StringValue("8104");
+ public static final StringValue __STR_LIT_745 = new StringValue("8105");
+ public static final StringValue __STR_LIT_746 = new StringValue("8106");
+ public static final StringValue __STR_LIT_747 = new StringValue("8107");
+ public static final StringValue __STR_LIT_748 = new StringValue("8108");
+ public static final StringValue __STR_LIT_749 = new StringValue("8109");
+ public static final StringValue __STR_LIT_750 = new StringValue("810A");
+ public static final StringValue __STR_LIT_751 = new StringValue("810B");
+ public static final StringValue __STR_LIT_752 = new StringValue("8130");
+ public static final StringValue __STR_LIT_753 = new StringValue("188");
+ public static final StringValue __STR_LIT_754 = new StringValue("189");
+ public static final StringValue __STR_LIT_755 = new StringValue("190");
+ public static final StringValue __STR_LIT_756 = new StringValue("130");
+ public static final StringValue __STR_LIT_757 = new StringValue("162");
+ public static final StringValue __STR_LIT_758 = new StringValue("166");
+ public static final StringValue __STR_LIT_759 = new StringValue("1M1");
+ public static final StringValue __STR_LIT_760 = new StringValue("1M2");
+ public static final StringValue __STR_LIT_761 = new StringValue("1M3");
+ public static final StringValue __STR_LIT_762 = new StringValue("1M4");
+ public static final StringValue __STR_LIT_763 = new StringValue("1M5");
+ public static final StringValue __STR_LIT_764 = new StringValue("1M6");
+ public static final NumberValue __NUM_LIT_71 = new NumberValue(100.0);
+ public static final NumberValue __NUM_LIT_72 = new NumberValue(198.0);
+ public static final NumberValue __NUM_LIT_73 = new NumberValue(898.0);
+ public static final StringValue __STR_LIT_765 = new StringValue("115");
+ public static final StringValue __STR_LIT_766 = new StringValue("116");
+ public static final StringValue __STR_LIT_767 = new StringValue("119");
+ public static final StringValue __STR_LIT_768 = new StringValue("131");
+ public static final StringValue __STR_LIT_769 = new StringValue("132");
+ public static final StringValue __STR_LIT_770 = new StringValue("133");
+ public static final StringValue __STR_LIT_771 = new StringValue("134");
+ public static final StringValue __STR_LIT_772 = new StringValue("136");
+ public static final StringValue __STR_LIT_773 = new StringValue("137");
+ public static final StringValue __STR_LIT_774 = new StringValue("138");
+ public static final StringValue __STR_LIT_775 = new StringValue("139");
+ public static final StringValue __STR_LIT_776 = new StringValue("146");
+ public static final StringValue __STR_LIT_777 = new StringValue("147");
+ public static final StringValue __STR_LIT_778 = new StringValue("148");
+ public static final StringValue __STR_LIT_779 = new StringValue("198");
+ public static final StringValue __STR_LIT_780 = new StringValue("149");
+ public static final StringValue __STR_LIT_781 = new StringValue("150");
+ public static final StringValue __STR_LIT_782 = new StringValue("152");
+ public static final StringValue __STR_LIT_783 = new StringValue("155");
+ public static final StringValue __STR_LIT_784 = new StringValue("157");
+ public static final StringValue __STR_LIT_785 = new StringValue("158");
+ public static final StringValue __STR_LIT_786 = new StringValue("160");
+ public static final StringValue __STR_LIT_787 = new StringValue("161");
+ public static final StringValue __STR_LIT_788 = new StringValue("163");
+ public static final StringValue __STR_LIT_789 = new StringValue("164");
+ public static final StringValue __STR_LIT_790 = new StringValue("165");
+ public static final StringValue __STR_LIT_791 = new StringValue("167");
+ public static final StringValue __STR_LIT_792 = new StringValue("169");
+ public static final StringValue __STR_LIT_793 = new StringValue("178");
+ public static final StringValue __STR_LIT_794 = new StringValue("199");
+ public static final NumberValue __NUM_LIT_74 = new NumberValue(15.0);
+ public static final NumberValue __NUM_LIT_75 = new NumberValue(16.0);
+ public static final NumberValue __NUM_LIT_76 = new NumberValue(19.0);
+ public static final NumberValue __NUM_LIT_77 = new NumberValue(20.0);
+ public static final NumberValue __NUM_LIT_78 = new NumberValue(55.0);
+ public static final NumberValue __NUM_LIT_79 = new NumberValue(57.0);
+ public static final NumberValue __NUM_LIT_80 = new NumberValue(58.0);
+ public static final NumberValue __NUM_LIT_81 = new NumberValue(60.0);
+ public static final NumberValue __NUM_LIT_82 = new NumberValue(61.0);
+ public static final NumberValue __NUM_LIT_83 = new NumberValue(67.0);
+ public static final StringValue __STR_LIT_795 = new StringValue("080");
+ public static final StringValue __STR_LIT_796 = new StringValue("296");
+ public static final StringValue __STR_LIT_797 = new StringValue("396");
+ public static final StringValue __STR_LIT_798 = new StringValue("496");
+ public static final StringValue __STR_LIT_799 = new StringValue("596");
+ public static final StringValue __STR_LIT_800 = new StringValue("696");
+ public static final StringValue __STR_LIT_801 = new StringValue("796");
+ public static final StringValue __STR_LIT_802 = new StringValue("896");
+ public static final StringValue __STR_LIT_803 = new StringValue("996");
+ public static final StringValue __STR_LIT_804 = new StringValue("91");
+ public static final StringValue __STR_LIT_805 = new StringValue("92");
+ public static final StringValue __STR_LIT_806 = new StringValue("799");
+ public static final StringValue __STR_LIT_807 = new StringValue("2490");
+ public static final StringValue __STR_LIT_808 = new StringValue("35");
+ public static final StringValue __STR_LIT_809 = new StringValue("46");
+ public static final StringValue __STR_LIT_810 = new StringValue("187");
+ public static final NumberValue __NUM_LIT_84 = new NumberValue(18.0);
+ public static final StringValue __STR_LIT_811 = new StringValue("2007");
+ public static final StringValue __STR_LIT_812 = new StringValue("2008");
+ public static final StringValue __STR_LIT_813 = new StringValue("7250");
+ public static final StringValue __STR_LIT_814 = new StringValue("021");
+ public static final StringValue __STR_LIT_815 = new StringValue("184");
+ public static final NumberValue __NUM_LIT_85 = new NumberValue(35.0);
+ public static final NumberValue __NUM_LIT_86 = new NumberValue(298.0);
+ public static final NumberValue __NUM_LIT_87 = new NumberValue(801.0);
+ public static final NumberValue __NUM_LIT_88 = new NumberValue(802.0);
+ public static final StringValue __STR_LIT_816 = new StringValue("156");
+ public static final StringValue __STR_LIT_817 = new StringValue("256");
+ public static final StringValue __STR_LIT_818 = new StringValue("856");
+ public static final StringValue __STR_LIT_819 = new StringValue("269");
+ public static final StringValue __STR_LIT_820 = new StringValue("369");
+ public static final StringValue __STR_LIT_821 = new StringValue("469");
+ public static final StringValue __STR_LIT_822 = new StringValue("669");
+ public static final StringValue __STR_LIT_823 = new StringValue("869");
+ public static final StringValue __STR_LIT_824 = new StringValue("278");
+ public static final StringValue __STR_LIT_825 = new StringValue("878");
+ public static final StringValue __STR_LIT_826 = new StringValue("185");
+ public static final StringValue __STR_LIT_827 = new StringValue("285");
+ public static final StringValue __STR_LIT_828 = new StringValue("485");
+ public static final StringValue __STR_LIT_829 = new StringValue("685");
+ public static final StringValue __STR_LIT_830 = new StringValue("885");
+ public static final StringValue __STR_LIT_831 = new StringValue("288");
+ public static final StringValue __STR_LIT_832 = new StringValue("388");
+ public static final StringValue __STR_LIT_833 = new StringValue("488");
+ public static final StringValue __STR_LIT_834 = new StringValue("688");
+ public static final StringValue __STR_LIT_835 = new StringValue("888");
+ public static final StringValue __STR_LIT_836 = new StringValue("299");
+ public static final StringValue __STR_LIT_837 = new StringValue("499");
+ public static final StringValue __STR_LIT_838 = new StringValue("899");
+ public static final StringValue __STR_LIT_839 = new StringValue("249");
+ public static final StringValue __STR_LIT_840 = new StringValue("449");
+ public static final StringValue __STR_LIT_841 = new StringValue("849");
+ public static final StringValue __STR_LIT_842 = new StringValue("250");
+ public static final StringValue __STR_LIT_843 = new StringValue("450");
+ public static final StringValue __STR_LIT_844 = new StringValue("850");
+ public static final StringValue __STR_LIT_845 = new StringValue("252");
+ public static final StringValue __STR_LIT_846 = new StringValue("452");
+ public static final StringValue __STR_LIT_847 = new StringValue("852");
+ public static final StringValue __STR_LIT_848 = new StringValue("255");
+ public static final StringValue __STR_LIT_849 = new StringValue("455");
+ public static final StringValue __STR_LIT_850 = new StringValue("855");
+ public static final StringValue __STR_LIT_851 = new StringValue("257");
+ public static final StringValue __STR_LIT_852 = new StringValue("457");
+ public static final StringValue __STR_LIT_853 = new StringValue("857");
+ public static final StringValue __STR_LIT_854 = new StringValue("258");
+ public static final StringValue __STR_LIT_855 = new StringValue("458");
+ public static final StringValue __STR_LIT_856 = new StringValue("858");
+ public static final StringValue __STR_LIT_857 = new StringValue("260");
+ public static final StringValue __STR_LIT_858 = new StringValue("460");
+ public static final StringValue __STR_LIT_859 = new StringValue("860");
+ public static final StringValue __STR_LIT_860 = new StringValue("261");
+ public static final StringValue __STR_LIT_861 = new StringValue("461");
+ public static final StringValue __STR_LIT_862 = new StringValue("861");
+ public static final StringValue __STR_LIT_863 = new StringValue("262");
+ public static final StringValue __STR_LIT_864 = new StringValue("462");
+ public static final StringValue __STR_LIT_865 = new StringValue("862");
+ public static final StringValue __STR_LIT_866 = new StringValue("264");
+ public static final StringValue __STR_LIT_867 = new StringValue("464");
+ public static final StringValue __STR_LIT_868 = new StringValue("864");
+ public static final StringValue __STR_LIT_869 = new StringValue("263");
+ public static final StringValue __STR_LIT_870 = new StringValue("463");
+ public static final StringValue __STR_LIT_871 = new StringValue("863");
+ public static final StringValue __STR_LIT_872 = new StringValue("265");
+ public static final StringValue __STR_LIT_873 = new StringValue("465");
+ public static final StringValue __STR_LIT_874 = new StringValue("865");
+ public static final StringValue __STR_LIT_875 = new StringValue("266");
+ public static final StringValue __STR_LIT_876 = new StringValue("466");
+ public static final StringValue __STR_LIT_877 = new StringValue("866");
+ public static final StringValue __STR_LIT_878 = new StringValue("267");
+ public static final StringValue __STR_LIT_879 = new StringValue("467");
+ public static final StringValue __STR_LIT_880 = new StringValue("867");
+ public static final StringValue __STR_LIT_881 = new StringValue("230");
+ public static final StringValue __STR_LIT_882 = new StringValue("330");
+ public static final StringValue __STR_LIT_883 = new StringValue("430");
+ public static final StringValue __STR_LIT_884 = new StringValue("630");
+ public static final StringValue __STR_LIT_885 = new StringValue("830");
+ public static final StringValue __STR_LIT_886 = new StringValue("186");
+ public static final StringValue __STR_LIT_887 = new StringValue("286");
+ public static final StringValue __STR_LIT_888 = new StringValue("886");
+ public static final StringValue __STR_LIT_889 = new StringValue("289");
+ public static final StringValue __STR_LIT_890 = new StringValue("389");
+ public static final StringValue __STR_LIT_891 = new StringValue("889");
+ public static final StringValue __STR_LIT_892 = new StringValue("287");
+ public static final StringValue __STR_LIT_893 = new StringValue("487");
+ public static final StringValue __STR_LIT_894 = new StringValue("687");
+ public static final StringValue __STR_LIT_895 = new StringValue("887");
+ public static final StringValue __STR_LIT_896 = new StringValue("390");
+ public static final StringValue __STR_LIT_897 = new StringValue("490");
+ public static final StringValue __STR_LIT_898 = new StringValue("690");
+ public static final StringValue __STR_LIT_899 = new StringValue("890");
+ public static final StringValue __STR_LIT_900 = new StringValue("769");
+ public static final StringValue __STR_LIT_901 = new StringValue("778");
+ public static final StringValue __STR_LIT_902 = new StringValue("788");
+ public static final StringValue __STR_LIT_903 = new StringValue("749");
+ public static final StringValue __STR_LIT_904 = new StringValue("750");
+ public static final StringValue __STR_LIT_905 = new StringValue("752");
+ public static final StringValue __STR_LIT_906 = new StringValue("755");
+ public static final StringValue __STR_LIT_907 = new StringValue("757");
+ public static final StringValue __STR_LIT_908 = new StringValue("758");
+ public static final StringValue __STR_LIT_909 = new StringValue("760");
+ public static final StringValue __STR_LIT_910 = new StringValue("761");
+ public static final StringValue __STR_LIT_911 = new StringValue("762");
+ public static final StringValue __STR_LIT_912 = new StringValue("764");
+
+ public TB_T_Studenten_Pruefungen themenbereich;
+ public MaterialTB_Hochschulfachbereich __material_Hochschulfachbereich_Materialbeschreibung;
+ public MaterialTB_Hochschulstandort __material_Hochschulstandort_Materialbeschreibung;
+ public MaterialTB_Staat __material_Staat_Materialbeschreibung;
+ public MaterialTB_Bundesland __material_Bundesland_Materialbeschreibung;
+ public MaterialTB_EinschreibungArt __material_EinschreibungArt_Materialbeschreibung;
+ public MaterialTB_Abschluss3steller __material_Abschluss3steller_Materialbeschreibung;
+ public MaterialTB_Abschluss3steller_Land __material_Abschluss3steller_Land_Materialbeschreibung;
+ public MaterialTB_Studienfach_Land __material_Studienfach_Land_Materialbeschreibung;
+ public MaterialTB_Studienfach __material_Studienfach_Materialbeschreibung;
+ public MaterialTB_StudiumArt __material_StudiumArt_Materialbeschreibung;
+ public MaterialTB_VollTeilzeit __material_VollTeilzeit_Materialbeschreibung;
+ public MaterialTB_HZBArt __material_HZBArt_Materialbeschreibung;
+ public MaterialTB_Kreise __material_Kreise_Materialbeschreibung;
+ public MaterialTB_StudienfachMerkmalsKombination __material_StudienfachMerkmalsKombination_Materialbeschreibung;
+
+ public Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN()
+ {
+ plausiDescriptor().setName("ERHEBUNG_STUDENTEN_PRUEFUNGEN");
+
+ plausiDescriptor().addFlow(new PlausiDescriptor.FlowInfo("Ablauf_Studenten_Pruefungen", new Class[] {}));
+ plausiDescriptor().setStandardFlow(plausiDescriptor().flow("Ablauf_Studenten_Pruefungen"));
+
+ Classification classi;
+
+
+ java.util.Hashtable __mappings_ht;
+
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("EF61", "EF61");
+ __mappings_ht.put("EF36", "EF36");
+ __mappings_ht.put("EF62", "EF62");
+ __mappings_ht.put("EF51", "EF51");
+ __mappings_ht.put("EF80", "EF80");
+ __mappings_ht.put("EF82", "EF82");
+ __mappings_ht.put("EF126", "EF126");
+ __mappings_ht.put("EF63", "EF63");
+ __mappings_ht.put("EF144", "EF144");
+ __mappings_ht.put("EF22", "EF22");
+ __mappings_ht.put("EF2", "EF2");
+ __mappings_ht.put("EF108", "EF108");
+ __mappings_ht.put("EF25", "EF25");
+ __mappings_ht.put("EF14", "EF14");
+ __mappings_ht.put("EF30", "EF30");
+ __mappings_ht.put("EF117", "EF117");
+ __mappings_ht.put("EF114", "EF114");
+ __mappings_ht.put("EF74", "EF74");
+ __mappings_ht.put("EF46", "EF46");
+ __mappings_ht.put("EF148", "EF148");
+ __mappings_ht.put("EF103", "EF103");
+ __mappings_ht.put("EF140", "EF140");
+ __mappings_ht.put("EF26", "EF26");
+ __mappings_ht.put("EF8U2", "EF8U2");
+ __mappings_ht.put("EF10U2", "EF10U2");
+ __mappings_ht.put("EF79", "EF79");
+ __mappings_ht.put("EF64", "EF64");
+ __mappings_ht.put("EF115", "EF115");
+ __mappings_ht.put("EF120", "EF120");
+ __mappings_ht.put("EF34", "EF34");
+ __mappings_ht.put("EF112", "EF112");
+ __mappings_ht.put("EF31", "EF31");
+ __mappings_ht.put("EF135", "EF135");
+ __mappings_ht.put("EF72", "EF72");
+ __mappings_ht.put("EF65U1", "EF65U1");
+ __mappings_ht.put("EF48", "EF48");
+ __mappings_ht.put("EF32", "EF32");
+ __mappings_ht.put("EF133", "EF133");
+ __mappings_ht.put("EF47", "EF47");
+ __mappings_ht.put("EF147", "EF147");
+ __mappings_ht.put("EF137", "EF137");
+ __mappings_ht.put("EF65U2", "EF65U2");
+ __mappings_ht.put("EF107", "EF107");
+ __mappings_ht.put("EF116", "EF116");
+ __mappings_ht.put("EF85", "EF85");
+ __mappings_ht.put("EF142", "EF142");
+ __mappings_ht.put("EF55", "EF55");
+ __mappings_ht.put("EF86", "EF86");
+ __mappings_ht.put("EF3", "EF3");
+ __mappings_ht.put("EF88", "EF88");
+ __mappings_ht.put("EF98", "EF98");
+ __mappings_ht.put("EF50", "EF50");
+ __mappings_ht.put("EF59", "EF59");
+ __mappings_ht.put("EF19", "EF19");
+ __mappings_ht.put("EF40", "EF40");
+ __mappings_ht.put("EF68", "EF68");
+ __mappings_ht.put("EF93", "EF93");
+ __mappings_ht.put("EF87", "EF87");
+ __mappings_ht.put("EF151", "EF151");
+ __mappings_ht.put("EF118", "EF118");
+ __mappings_ht.put("EF143", "EF143");
+ __mappings_ht.put("EF124", "EF124");
+ __mappings_ht.put("EF5", "EF5");
+ __mappings_ht.put("EF78", "EF78");
+ __mappings_ht.put("EF18", "EF18");
+ __mappings_ht.put("EF57", "EF57");
+ __mappings_ht.put("EF11U2", "EF11U2");
+ __mappings_ht.put("EF119", "EF119");
+ __mappings_ht.put("EF89", "EF89");
+ __mappings_ht.put("EF81", "EF81");
+ __mappings_ht.put("EF52", "EF52");
+ __mappings_ht.put("EF33", "EF33");
+ __mappings_ht.put("EF39", "EF39");
+ __mappings_ht.put("EF60", "EF60");
+ __mappings_ht.put("EF17", "EF17");
+ __mappings_ht.put("EF104", "EF104");
+ __mappings_ht.put("EF69", "EF69");
+ __mappings_ht.put("EF132", "EF132");
+ __mappings_ht.put("EF75", "EF75");
+ __mappings_ht.put("EF21", "EF21");
+ __mappings_ht.put("EF43", "EF43");
+ __mappings_ht.put("EF146", "EF146");
+ __mappings_ht.put("EF91", "EF91");
+ __mappings_ht.put("EF95", "EF95");
+ __mappings_ht.put("EF105", "EF105");
+ __mappings_ht.put("EF141", "EF141");
+ __mappings_ht.put("EF125", "EF125");
+ __mappings_ht.put("EF121", "EF121");
+ __mappings_ht.put("EF113", "EF113");
+ __mappings_ht.put("EF13", "EF13");
+ __mappings_ht.put("EF56", "EF56");
+ __mappings_ht.put("EF123", "EF123");
+ __mappings_ht.put("EF149", "EF149");
+ __mappings_ht.put("EF16", "EF16");
+ __mappings_ht.put("EF11U1", "EF11U1");
+ __mappings_ht.put("EF42", "EF42");
+ __mappings_ht.put("EF102", "EF102");
+ __mappings_ht.put("EF71", "EF71");
+ __mappings_ht.put("EF101", "EF101");
+ __mappings_ht.put("EF70", "EF70");
+ __mappings_ht.put("EF90", "EF90");
+ __mappings_ht.put("EF128", "EF128");
+ __mappings_ht.put("EF96", "EF96");
+ __mappings_ht.put("EF73", "EF73");
+ __mappings_ht.put("EF1", "EF1");
+ __mappings_ht.put("EF139", "EF139");
+ __mappings_ht.put("EF9", "EF9");
+ __mappings_ht.put("EF6", "EF6");
+ __mappings_ht.put("EF37", "EF37");
+ __mappings_ht.put("EF122", "EF122");
+ __mappings_ht.put("EF150", "EF150");
+ __mappings_ht.put("EF110", "EF110");
+ __mappings_ht.put("EF8U1", "EF8U1");
+ __mappings_ht.put("EF129", "EF129");
+ __mappings_ht.put("EF111U1", "EF111U1");
+ __mappings_ht.put("EF7", "EF7");
+ __mappings_ht.put("EF99", "EF99");
+ __mappings_ht.put("EF41", "EF41");
+ __mappings_ht.put("EF92", "EF92");
+ __mappings_ht.put("EF106", "EF106");
+ __mappings_ht.put("EF23", "EF23");
+ __mappings_ht.put("EF35", "EF35");
+ __mappings_ht.put("EF100", "EF100");
+ __mappings_ht.put("EF97", "EF97");
+ __mappings_ht.put("EF77", "EF77");
+ __mappings_ht.put("EF49", "EF49");
+ __mappings_ht.put("EF38", "EF38");
+ __mappings_ht.put("EF152", "EF152");
+ __mappings_ht.put("EF111U2", "EF111U2");
+ __mappings_ht.put("EF15", "EF15");
+ __mappings_ht.put("EF84", "EF84");
+ __mappings_ht.put("EF12", "EF12");
+ __mappings_ht.put("EF134", "EF134");
+ __mappings_ht.put("EF136", "EF136");
+ __mappings_ht.put("EF28", "EF28");
+ __mappings_ht.put("EF66", "EF66");
+ __mappings_ht.put("EF27", "EF27");
+ __mappings_ht.put("EF67", "EF67");
+ __mappings_ht.put("EF58", "EF58");
+ __mappings_ht.put("EF53", "EF53");
+ __mappings_ht.put("EF94", "EF94");
+ __mappings_ht.put("EF131", "EF131");
+ __mappings_ht.put("EF109", "EF109");
+ __mappings_ht.put("EF24", "EF24");
+ __mappings_ht.put("EF76", "EF76");
+ __mappings_ht.put("EF83", "EF83");
+ __mappings_ht.put("EF20", "EF20");
+ __mappings_ht.put("EF145", "EF145");
+ __mappings_ht.put("EF10U1", "EF10U1");
+ __mappings_ht.put("EF54", "EF54");
+ __mappings_ht.put("EF4", "EF4");
+ __mappings_ht.put("EF138", "EF138");
+ __mappings_ht.put("EF45", "EF45");
+ __mappings_ht.put("EF29", "EF29");
+ __mappings_ht.put("EF127", "EF127");
+ __mappings_ht.put("EF130", "EF130");
+ __mappings_ht.put("EF44", "EF44");
+ setPlausiMappings(__mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("gueltigAbSemester", "EF5");
+ __mappings_ht.put("gueltigAbJahr", "EF4");
+ __mappings_ht.put("hochschulStandort", "EF11");
+ __mappings_ht.put("gueltigBisSemester", "EF7");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("gueltigBisJahr", "EF6");
+ __mappings_ht.put("name", "EF3");
+ __mappings_ht.put("habilitationsRecht", "EF8");
+ __mappings_ht.put("sortKey", "EF2");
+ __mappings_ht.put("foerderung", "EF10");
+ __mappings_ht.put("hochschulTraeger", "EF9");
+ setMappingsForMaterial("Hochschulfachbereich_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("gueltigBisJahr", "EF6");
+ __mappings_ht.put("sortKey", "EF2");
+ __mappings_ht.put("hochschule", "EF9");
+ __mappings_ht.put("gueltigAbSemester", "EF5");
+ __mappings_ht.put("bundesland", "EF8");
+ __mappings_ht.put("name", "EF3");
+ __mappings_ht.put("gueltigBisSemester", "EF7");
+ __mappings_ht.put("gueltigAbJahr", "EF4");
+ __mappings_ht.put("gemeindeSchluessel", "EF10");
+ __mappings_ht.put("key", "EF1");
+ setMappingsForMaterial("Hochschulstandort_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("name", "EF5");
+ __mappings_ht.put("key", "EF3");
+ __mappings_ht.put("gueltigAbJahr", "EF6");
+ __mappings_ht.put("mitgliedschaftEU", "EF8");
+ __mappings_ht.put("gueltigBisJahr", "EF1");
+ __mappings_ht.put("kontinent", "EF9");
+ __mappings_ht.put("sortKey", "EF4");
+ __mappings_ht.put("gueltigAbSemester", "EF7");
+ __mappings_ht.put("gueltigBisSemester", "EF2");
+ setMappingsForMaterial("Staat_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("", "");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ setMappingsForMaterial("Bundesland_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ setMappingsForMaterial("EinschreibungArt_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("sig2steller", "EF8");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ setMappingsForMaterial("Abschluss3steller_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("sig2steller", "EF8");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("land", "EF10");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("keyBund", "EF9");
+ setMappingsForMaterial("Abschluss3steller_Land_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("land", "EF11");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("keyBund", "EF10");
+ __mappings_ht.put("isced", "EF9");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("stb", "EF8");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ setMappingsForMaterial("Studienfach_Land_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("stb", "EF8");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("isced", "EF9");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ setMappingsForMaterial("Studienfach_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ __mappings_ht.put("name", "EF2");
+ setMappingsForMaterial("StudiumArt_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ __mappings_ht.put("name", "EF2");
+ setMappingsForMaterial("VollTeilzeit_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("hochschulreifeArt", "EF8");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ setMappingsForMaterial("HZBArt_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("", "");
+ __mappings_ht.put("gueltigAbJahr", "EF3");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("sortKey", "EF7");
+ __mappings_ht.put("gueltigAbSemester", "EF4");
+ __mappings_ht.put("gueltigBisSemester", "EF6");
+ __mappings_ht.put("name", "EF2");
+ __mappings_ht.put("gueltigBisJahr", "EF5");
+ setMappingsForMaterial("Kreise_Materialbeschreibung", __mappings_ht);
+ __mappings_ht = new java.util.Hashtable();
+ __mappings_ht.put("land", "EF10");
+ __mappings_ht.put("abschluss3steller", "EF7");
+ __mappings_ht.put("gueltigAbJahr", "EF2");
+ __mappings_ht.put("gueltigAbSemester", "EF3");
+ __mappings_ht.put("key", "EF1");
+ __mappings_ht.put("studienfach", "EF6");
+ __mappings_ht.put("sortKey", "EF8");
+ __mappings_ht.put("vollteildual", "EF11");
+ __mappings_ht.put("gueltigBisJahr", "EF4");
+ __mappings_ht.put("gueltigBisSemester", "EF5");
+ __mappings_ht.put("regelstudienzeit", "EF9");
+ __mappings_ht.put("", "");
+ setMappingsForMaterial("StudienfachMerkmalsKombination_Materialbeschreibung", __mappings_ht);
+
+ __material_Hochschulfachbereich_Materialbeschreibung = new MaterialTB_Hochschulfachbereich(null, new FeldDeskriptor(mappingsForMaterial("Hochschulfachbereich_Materialbeschreibung"), "Hochschulfachbereich", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Hochschulfachbereich_Materialbeschreibung", "Hochschulfachbereich_DSB", false);
+ __material_Hochschulstandort_Materialbeschreibung = new MaterialTB_Hochschulstandort(null, new FeldDeskriptor(mappingsForMaterial("Hochschulstandort_Materialbeschreibung"), "Hochschulstandort", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Hochschulstandort_Materialbeschreibung", "Hochschulstandort_DSB", false);
+ __material_Staat_Materialbeschreibung = new MaterialTB_Staat(null, new FeldDeskriptor(mappingsForMaterial("Staat_Materialbeschreibung"), "Staat", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Staat_Materialbeschreibung", "Staat_DSB", false);
+ __material_Bundesland_Materialbeschreibung = new MaterialTB_Bundesland(null, new FeldDeskriptor(mappingsForMaterial("Bundesland_Materialbeschreibung"), "Bundesland", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Bundesland_Materialbeschreibung", "Bundesland_DSB", false);
+ __material_EinschreibungArt_Materialbeschreibung = new MaterialTB_EinschreibungArt(null, new FeldDeskriptor(mappingsForMaterial("EinschreibungArt_Materialbeschreibung"), "EinschreibungArt", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "EinschreibungArt_Materialbeschreibung", "EinschreibungArt_DSB", false);
+ __material_Abschluss3steller_Materialbeschreibung = new MaterialTB_Abschluss3steller(null, new FeldDeskriptor(mappingsForMaterial("Abschluss3steller_Materialbeschreibung"), "Abschluss3steller", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Abschluss3steller_Materialbeschreibung", "Abschluss3steller_DSB", false);
+ __material_Abschluss3steller_Land_Materialbeschreibung = new MaterialTB_Abschluss3steller_Land(null, new FeldDeskriptor(mappingsForMaterial("Abschluss3steller_Land_Materialbeschreibung"), "Abschluss3steller_Land", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Abschluss3steller_Land_Materialbeschreibung", "Abschluss3steller_Land_DSB", false);
+ __material_Studienfach_Land_Materialbeschreibung = new MaterialTB_Studienfach_Land(null, new FeldDeskriptor(mappingsForMaterial("Studienfach_Land_Materialbeschreibung"), "Studienfach_Land", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Studienfach_Land_Materialbeschreibung", "Studienfach_Land_DSB", false);
+ __material_Studienfach_Materialbeschreibung = new MaterialTB_Studienfach(null, new FeldDeskriptor(mappingsForMaterial("Studienfach_Materialbeschreibung"), "Studienfach", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Studienfach_Materialbeschreibung", "Studienfach_DSB", false);
+ __material_StudiumArt_Materialbeschreibung = new MaterialTB_StudiumArt(null, new FeldDeskriptor(mappingsForMaterial("StudiumArt_Materialbeschreibung"), "StudiumArt", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "StudiumArt_Materialbeschreibung", "StudiumArt_DSB", false);
+ __material_VollTeilzeit_Materialbeschreibung = new MaterialTB_VollTeilzeit(null, new FeldDeskriptor(mappingsForMaterial("VollTeilzeit_Materialbeschreibung"), "VollTeilzeit", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "VollTeilzeit_Materialbeschreibung", "VollTeilzeit_DSB", false);
+ __material_HZBArt_Materialbeschreibung = new MaterialTB_HZBArt(null, new FeldDeskriptor(mappingsForMaterial("HZBArt_Materialbeschreibung"), "HZBArt", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "HZBArt_Materialbeschreibung", "HZBArt_DSB", false);
+ __material_Kreise_Materialbeschreibung = new MaterialTB_Kreise(null, new FeldDeskriptor(mappingsForMaterial("Kreise_Materialbeschreibung"), "Kreise", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "Kreise_Materialbeschreibung", "Kreise_DSB", false);
+ __material_StudienfachMerkmalsKombination_Materialbeschreibung = new MaterialTB_StudienfachMerkmalsKombination(null, new FeldDeskriptor(mappingsForMaterial("StudienfachMerkmalsKombination_Materialbeschreibung"), "StudienfachMerkmalsKombination", null, RuntimeSettings.RT_TYPE_CUSTOM), null, "StudienfachMerkmalsKombination_Materialbeschreibung", "StudienfachMerkmalsKombination_DSB", false);
+ themenbereich = new TB_T_Studenten_Pruefungen(null, new FeldDeskriptor(plausiMappings(), "__root_tb__", null, RuntimeSettings.RT_TYPE_CUSTOM), null);
+ }
+
+ public void init(PlausiRuntimeContext context)
+ {
+ }
+
+ protected void doAblauf(PlausiDescriptor.FlowInfo ablaufInfo, PlausiRuntimeContext context, Object[] initWerte)
+ {
+ if (ablaufInfo.name.equals("Ablauf_Studenten_Pruefungen"))
+ {
+ themenbereich.prg_Ablauf_Studenten_Pruefungen(context);
+ }
+ }
+
+ protected PlausiFehler createPlausiFehler(String key)
+ {
+ if ("LAND_000".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_000");
+ fehler.setFehlertextKurz("Kontrolle für landesinterne Prüfungen");
+ fehler.setFehlertextLang("Diese Kontrolle beinhaltet verschiedene landesinterne Prüfungen für verschiedene Länder für die es bisher keine bundeseinheitlichen Kontrollen gab. TEIL 1 Sachsen-Anhalt: Beim Feld Hörerstatus (EF12) ist Studienkollegiat (Signatur 3) eingegeben. Dies ist für Sachsen-Anhalt nicht zulässig da Studienkollegiate gesondert gemeldet werden. TEIL 2 Bayern: An der Ludwig-Maximilian-Universität (Sig. 1320) dürfen die landesinternen Fächer e98, e99, f00 und f01 nicht als 1. Studienfach angegeben werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("LAND_000K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_000K");
+ fehler.setFehlertextKurz("Kontrolle für landesinterne Prüfungen KANNFEHLER");
+ fehler.setFehlertextLang("Diese Kontrolle beinhaltet verschiedene landesinterne Prüfungen für verschiedene Länder für die es bisher keine bundeseinheitlichen Kontrollen gab. TEIL 1 Bayern: Beim Feld Hochschulzugangsberechtigung (EF110) ist \"Beruflich Qualifizierte\" (Signierschlüssell 34, 53, 71) eingegeben und bei Berufsausbildung mit Abschluss (EF112) oder bei Praktikum/Volontariat (EF113) wurde nicht \"1\" angegeben.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("LAND_001".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_001");
+ fehler.setFehlertextKurz("Eingabefelder die vollständig mit Leerzeichen oder NULL gefüllt sind, werden auf LEER gesetzt.");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein - Westfalen. Alle Eingabefelder die von den liefernden Hochschulen vollständig mit Leerzeichen oder NULL gefüllt wurden, werden auf LEER gesetzt. ( Einsetzung gilt für nachfolgende Eingabefelder: Angabe 4. Studienfach in EF38, EF53, EF63, EF73, EF81, EF95, EF104, EF130, EF146 und Angabe Anzahl der Fachsemester für das entsprechende Fach in EF33, EF35, EF37, EF39, EF48, EF50, EF52, EF54)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_002".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_002");
+ fehler.setFehlertextKurz("Bei Exmatrikulation im 1. Stg werden die Angaben ab Art des Studiums gelöscht");
+ fehler.setFehlertextLang("Bei Exmatrikulation im 1. Studiengang werden die Angaben ab Art des Studiums gelöscht. Angaben zur Voll-/Teilteit/Duales Studium und Anzahl der Fachsemester werden nicht gelöscht. Umsetzung gilt nur für Nordrhein Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_003".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_003");
+ fehler.setFehlertextKurz("Bei Exmatrikulation im 2. Stg werden die Angaben ab Art des Studiums gelöscht");
+ fehler.setFehlertextLang("Bei Exmatrikulation im 2. Studiengang werden die Angaben ab Art des Studiums gelöscht. Angaben zur Voll-/Teilteit/Duales Studium und Anzahl der Fachsemester werden nicht gelöscht. Umsetzung gilt nur für Nordrhein Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_004".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_004");
+ fehler.setFehlertextKurz("Umsetzung der Studienfächer");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen. Umsetzung der Studienfächer wenn innerhalb des 1. Studienganges das 1. Studienfach LEER und Angaben zum 2. bis 4. Studienfach vorhanden sind. Es ist wichtig das diese Kontrolle im PL Ablauf vor den Umsetzungen für alle Bundesländer erfolgt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_005".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_005");
+ fehler.setFehlertextKurz("Umsetzung der Studienfächer");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen. Umsetzung der Studienfächer wenn innerhalb des 2. Studienganges das 1. Studienfach LEER und Angaben zum 2. bis 4. Studienfach vorhanden sind. Es ist wichtig das diese Kontrolle im PL Ablauf vor den Umsetzungen für alle Bundesländer erfolgt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_006".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_006");
+ fehler.setFehlertextKurz("Umsetzung der Studienfächer");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen. Umsetzung der Studienfächer wenn innerhalb des 1. Studienganges das 2. Studienfach LEER und Angaben zum 3. bis 4. Studienfach vorhanden sind. Es ist wichtig das diese Kontrolle im PL Ablauf vor den Umsetzungen für alle Bundesländer erfolgt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_007".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_007");
+ fehler.setFehlertextKurz("Umsetzung der Studienfächer");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen. Umsetzung der Studienfächer wenn innerhalb des 2. Studienganges das 2. Studienfach LEER und Angaben zum 3. bis 4. Studienfach vorhanden sind. Es ist wichtig das diese Kontrolle im PL Ablauf vor den Umsetzungen für alle Bundesländer erfolgt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_008".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_008");
+ fehler.setFehlertextKurz("Umsetzung der Studienfächer");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen. Umsetzung der Studienfächer wenn innerhalb des 1. Studienganges das 3. Studienfach LEER und Angaben zum 4. Studienfach vorhanden sind. Es ist wichtig das diese Kontrolle im PL Ablauf vor den Umsetzungen für alle Bundesländer erfolgt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_009".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_009");
+ fehler.setFehlertextKurz("Umsetzung der Studienfächer");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen. Umsetzung der Studienfächer wenn innerhalb des 2. Studienganges das 3. Studienfach LEER und Angaben zum 4. Studienfach vorhanden sind. Es ist wichtig das diese Kontrolle im PL Ablauf vor den Umsetzungen für alle Bundesländer erfolgt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_010".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_010");
+ fehler.setFehlertextKurz("Falsche Signatur beim 4. Studienfach");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein - Westfalen. Signatur beim 4. Studienfach (EF38, EF53, EF63, EF73, EF81, EF95, EF104, EF130 oder EF146) stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) überein oder die Kombination Hochschule Abschlussprüfung und 4. Studienfach stimmt nicht mit den zulässigen Kombinationen aus Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("LAND_012".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_012");
+ fehler.setFehlertextKurz("Verschiebung des 4. Studienfachs bei der 1. Prüfung");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen.\nWenn das 3. Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (1. Prüfung) leer und das 4. Fach belegt ist, wird das 4. Fach als 3. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_013".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_013");
+ fehler.setFehlertextKurz("Verschiebung des 3. und 4. Studienfachs bei der 1. Prüfung");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen.\nWenn das 2. Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (1. Prüfung) leer und das 3. und 4. Fach belegt ist, wird das 3. und 4. Fach als 2. und 3. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_014".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_014");
+ fehler.setFehlertextKurz("Verschiebung des 2., 3. und 4. Studienfachs bei der 1. Prüfung");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen.\nWenn das 1. Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (1. Prüfung) leer und das 2., 3. und 4. Fach belegt ist, wird das 2., 3. und 4. Fach als 1., 2. und 3. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_015".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_015");
+ fehler.setFehlertextKurz("Verschiebung des 4. Studienfachs bei der2. Prüfung");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen.\nWenn das 3. Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (2. Prüfung) leer und das 4. Fach belegt ist, wird das 4. Fach als 3. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_016".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_016");
+ fehler.setFehlertextKurz("Verschiebung des 3. und 4. Studienfachs bei der 2. Prüfung");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen.\nWenn das 2. Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (2. Prüfung) leer und das 3. und 4. Fach belegt ist, wird das 3. und 4. Fach als 2. und 3. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("LAND_017".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("LAND_017");
+ fehler.setFehlertextKurz("Verschiebung des 2., 3. und 4. Studienfachs bei der 2. Prüfung");
+ fehler.setFehlertextLang("Kontrolle von Eingabefeldern, die im Liefermaterial für zusätzliche Angaben in den einzelnen Ländern freigehalten werden. Diese Kontrolle gilt nur für Nordrhein-Westfalen.\nWenn das 1. Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (2. Prüfung) leer und das 2., 3. und 4. Fach belegt ist, wird das 2., 3. und 4. Fach als 1., 2. und 3. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_003".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_003");
+ fehler.setFehlertextKurz("Leere Eingabefelder die mit Leerzeichen gefüllt wurden, werden auf LEER gesetzt.");
+ fehler.setFehlertextLang("Alle leeren Eingabefelder die von den liefernden Hochschulen mit Leerzeichen gefüllt wurden, werden auf LEER gesetzt. (Ausnahme sind die Eingabefelder FREI FÜR STALÄ)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_006".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_006");
+ fehler.setFehlertextKurz("Leere Eingabefelder die von den liefernden Hochschulen mit 0 gefüllt wurden, werden auf LEER gesetzt.");
+ fehler.setFehlertextLang("Alle leeren Eingabefelder die von den liefernden Hochschulen mit 0 gefüllt wurden, werden auf LEER gesetzt. (Ausnahme sind die EF in denen 0 eine zulässige Signatur ist und Eingabefelder FREI FÜR STALÄ)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_009".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_009");
+ fehler.setFehlertextKurz("Fehlende Angaben beim Land und Kreis des Erwerbs der HZB");
+ fehler.setFehlertextLang("Wenn Angaben beim Heimatwohnsitz vorhanden und keine Angaben beim Land und Kreis des Erwerbs der HZB werden die Angaben des Heimatwohnsitzes übernommen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_012".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_012");
+ fehler.setFehlertextKurz("Bei Prüfungsdatensatz werden vorhandene Angaben in EF18, EF97, EF106 und EF109 gelöscht.");
+ fehler.setFehlertextLang("Wenn im Prüfungssatz (ohne Studententeil) Angaben beim Jahr der Ersteinschreibung und/oder Jahr einer 1. oder weiteren bereits abgelegten Abschlußprüfung und/oder Jahr der HZB enthalten sind, werden diese auf \"LEER\" gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_015".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_015");
+ fehler.setFehlertextKurz("Einsetzung Land des Erwerbs der HZB (Nur bei Ausländer)");
+ fehler.setFehlertextLang("Ausländer und keine Angaben im Heimatwohnsitz sowie im Land und Staat des Erwerbs der HZB, wird 99 für Ausland und die Staatsangehörigkeit für Land des Erwerbs der HZB übernommen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_018".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_018");
+ fehler.setFehlertextKurz("Einsetzung Hochschule der Ersteinschreibung");
+ fehler.setFehlertextLang("Wenn bei Erstimmatrikulierten die Hochchule der Ersteinschreibung fehlt, wird die Hochschule des Berichtssemesters übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_021".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_021");
+ fehler.setFehlertextKurz("Einsetzung Semester der Ersteinschreibung");
+ fehler.setFehlertextLang("Wenn bei Erstimmatrikulierten das Semester der Ersteinschreibung fehlt, wird das Berichtssemester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_024".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_024");
+ fehler.setFehlertextKurz("Einsetzung Jahr der Ersteinschreibung");
+ fehler.setFehlertextLang("Wenn bei Erstimmatrikulierten das Jahr der Ersteinschreibung fehlt, wird das Berichtsjahrr übernommen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_027".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_027");
+ fehler.setFehlertextKurz("Semesterangaben werden auf NULL gesetzt.");
+ fehler.setFehlertextLang("Wenn die Anzahl der Urlaubssemester gleich der Anzahl der Hochschulsemester ist (bis einschließlich 7 Semester), werden alle Semesterangaben (mit Ausnahme der Hochschul- und Urlaubssemester) auf 0 gesetzt. Diese Umsetzung gilt nicht für die Länder Schleswig - Holstein, Hamburg, Rheinland - Pfalz, Baden - Württemberg, Brandenburg, Mecklenburg - Vorpommern und Sachsen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_030".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_030");
+ fehler.setFehlertextKurz("Wenn die Hochschule der Ersteinschreibung aufgelöst wurde, wird Signierschlüssel 9000 eingesetzt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_033".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_033");
+ fehler.setFehlertextKurz("Neuen Signierschlüssel für Hochschule der Ersteinschreibung einsetzen");
+ fehler.setFehlertextLang("Wenn die Hochschule der Ersteinschreibung in eine andere Hochschule eingegliedert wurde, wird der Signierschlüssel der neuen Hochschule eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_036".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_036");
+ fehler.setFehlertextKurz("Fehlende Angabe bei Voll-, Teilzeitstudium im 2.Studiengang");
+ fehler.setFehlertextLang("Wenn das 1. Studienfach des 2. Studienganges besetzt ist und die Angabe Voll-/Teilzeitstudium fehlt, wird diese fehlende Angabe aus dem 1. Studiengang übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_039".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_039");
+ fehler.setFehlertextKurz("Einsetzung Art der Einschreibung im 2. Studiengang");
+ fehler.setFehlertextLang("Wenn das 1. Studienfach des 2. Studienganges besetzt ist und keine Angabe bei Art der Einschreibung, wird die Art der Einschreibung des 1. Studienganges in die des 2. Studienganges übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_042".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_042");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zur Beurlaubung im 2. Studiengang");
+ fehler.setFehlertextLang("Wenn bei Beurlaubung im 1. Studiengang das 1. Studienfach des 2. Studienganges besetzt ist , dann werden die Angaben zur Beurlaubung des 1. Studienganges in die entsprechenden Angaben des 2. Studienganges übernommen.Diese Umsetzungen wird nur in den Nordrhein-Westfalen und Bayern vorgenommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_045".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_045");
+ fehler.setFehlertextKurz("Einsetzung der Art des Studiums im 2. Studiengang");
+ fehler.setFehlertextLang("Wenn das 1. Studienfach des 2. Studienganges besetzt ist und die Art des Studiums fehlt, wird die Art des Studiums des 1. Studienganges übernommen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_048".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_048");
+ fehler.setFehlertextKurz("Wenn das 1. Fach des 1.Studienganges leer ist wird das 2. und 3. Fach verschoben");
+ fehler.setFehlertextLang("Wenn das 1.Fach des 1. Studienganges leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_051".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_051");
+ fehler.setFehlertextKurz("Wenn das 2. Fach des 1.Studienganges leer ist wird das 3. Fach verschoben");
+ fehler.setFehlertextLang("Wenn das 2. Fach des 1. Studienganges leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_054".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_054");
+ fehler.setFehlertextKurz("Wenn das 1. Fach des 1.Studienganges leer ist wird das 2. Fach verschoben");
+ fehler.setFehlertextLang("Wenn das 1.Fach des 1. Studienganges leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_057".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_057");
+ fehler.setFehlertextKurz("Wenn das 1. Fach des 2.Studienganges leer ist wird das 2. und 3. Fach verschoben");
+ fehler.setFehlertextLang("Wenn das 1.Fach des 2. Studienganges leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_060".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_060");
+ fehler.setFehlertextKurz("Wenn das 2. Fach des 2.Studienganges leer ist wird das 3. Fach verschoben");
+ fehler.setFehlertextLang("Wenn das 2.Fach des 2. Studienganges leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_063".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_063");
+ fehler.setFehlertextKurz("Wenn das 1. Fach des 2.Studienganges leer ist wird das 2. Fach verschoben");
+ fehler.setFehlertextLang("Wenn das 1.Fach des 2. Studienganges leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_066".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_066");
+ fehler.setFehlertextKurz("Angaben aus 2. Studiengang werden in 1. Studiengang übernommen");
+ fehler.setFehlertextLang("Wenn Angaben im 2. Studiengang vorhanden und alle Angaben zum 1. Studiengang fehlen werden die Angaben des 2. Studienganges in den 1.Studiengang übernommen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_069".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_069");
+ fehler.setFehlertextKurz("Berechnung der Fachsemester 1. Studiengang.");
+ fehler.setFehlertextLang("Wenn bei einer Exmatrikulation im 1. Studiengang die Anzahl der Fachsemester fehlt, wird die Anzahl der Hochschulsemester minus Urlaubssemester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_072".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_072");
+ fehler.setFehlertextKurz("Berechnung der Fachsemester 2. Studiengang.");
+ fehler.setFehlertextLang("Wenn bei einer Exmatrikulation im 2. Studiengang die Anzahl der Fachsemester fehlt, wird die Anzahl der Hochschulsemester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_075".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_075");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Einschreibung an einer anderen Hochschule");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei Einschreibung an einer anderen Hochschule leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_078".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_078");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Einschreibung an einer anderen Hochschule");
+ fehler.setFehlertextLang("Wenn das 2.Fach bei Einschreibung an einer anderen Hochschule leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_081".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_081");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Einschreibung an einer anderen Hochschule");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei Einschreibung an einer anderen Hochschule leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_084".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_084");
+ fehler.setFehlertextKurz("Löschung der Angaben zur Einschreibung an einer anderen Hochschule");
+ fehler.setFehlertextLang("Wenn die Hochschule einer weiteren Einschreibung im Berichtssemester sich im Ausland befindet, werden alle Angaben gelöscht. (Diese Kontrolle gilt nicht für Rheinland-Pfalz,Berlin und Brandenburg)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_087".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_087");
+ fehler.setFehlertextKurz("Einsetzung Signatur 1 = jetzige Hochschule in die Kennziffer der Hochschule");
+ fehler.setFehlertextLang("Wenn die Hochschule des Berichtssemesters gleich der Hochschule im vorhergehenden Semester ist, wird die Signatur 1 = jetzige Hochschule in die Kennziffer der Hochschule im unmittelbar vorhergehenden Semster gesetzt");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_090".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_090");
+ fehler.setFehlertextKurz("Einsetzung Signatur 2 = andere Hochschule in Deutschland in die Kennziffer der Hochschule");
+ fehler.setFehlertextLang("Wenn die Hochschule des Berichtssemesters ungleich der Hochschule im vorhergehenden Semester ist, wird die Signatur 2 = andere Hochschule in Deutschland in die Kennziffer der Hochschule im unmittelbar vorhergehenden Semster gesetzt");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_093".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_093");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Studium im vorhergehenden Semester (1. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei Studium im vorhergehenden Semester (1. Stg) leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_096".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_096");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Studium im vorhergehenden Semester (1. Stg)");
+ fehler.setFehlertextLang("Wenn das 2.Fach bei Studium im vorhergehenden Semester (1. Stg) leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_099".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_099");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Studium im vorhergehenden Semester (1. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei Studium im vorhergehenden Semester (1. Stg) leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_102".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_102");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Studium im vorhergehenden Semester (2. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei Studium im vorhergehenden Semester (2. Stg) leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("Ehemalige Umsetzung F6");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_105".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_105");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Studium im vorhergehenden Semester (2. Stg)");
+ fehler.setFehlertextLang("Wenn das 2.Fach bei Studium im vorhergehenden Semester (2. Stg) leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_108".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_108");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei Studium im vorhergehenden Semester (2. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei Studium im vorhergehenden Semrster (2. Stg) leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_111".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_111");
+ fehler.setFehlertextKurz("Angaben aus 2. Studiengang werden in 1. Studiengang übernommen");
+ fehler.setFehlertextLang("Wenn Angaben im 2. Studiengang bei Studium im vorhergehenden Semester vorhanden und alle Angaben zum 1. Studiengang fehlen werden die Angaben des 2. Studeinganges in den 1.Studiengang übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_114".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_114");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei gleicher Hochschule");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester der 1. Studiengang des Berichtssemesters gleich dem 1. Studiengang im vorhergehenden Semester an derselben Hochschule ist, werden die Angaben des Berichtssemesters in die Angaben zum vorhergehenden Semester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_115".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_115");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei anderer Hochschule");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester der 1. Studiengang des Berichtssemesters gleich dem 1. Studiengang im vorhergehenden Semester an einer anderen Hochschule ist, werden die Angaben des Berichtssemesters in die Angaben zum vorhergehenden Semester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_116".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_116");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei gleicher Hochschule");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester der 2. Studiengang des Berichtssemesters gleich dem 2. Studiengang im vorhergehenden Semester an derselben Hochschule ist, werden die Angaben des Berichtssemesters in die Angaben zum vorhergehenden Semester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_117".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_117");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei anderer Hochschule");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester der 2. Studiengang des Berichtssemesters gleich dem 2. Studiengang im vorhergehenden Semester an einer anderen Hochschule ist, werden die Angaben des Berichtssemesters in die Angaben zum vorhergehenden Semester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_118".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_118");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei gleicher Hochschule");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester der 1. und 2. Studiengang des Berichtssemesters gleich dem 1. und 2. Studiengang im vorhergehenden Semester an derselben Hochschule ist, werden die Angaben des Berichtssemesters in die Angaben zum vorhergehenden Semester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_119".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_119");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei anderer Hochschule");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester der 1. und 2. Studiengang des Berichtssemesters gleich dem 1. und 2. Studiengang im vorhergehenden Semester an einer anderen Hochschule ist, werden die Angaben des Berichtssemesters in die Angaben zum vorhergehenden Semester übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_120".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_120");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei Mehrfacheinschreibung");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester im Vorsemester eine Einschreibung an der jetzigen und einer anderen Hochschule vorlag und wenn lt. Angabe beide Studiengänge des Berichtssemesters gleich sind wie im vorhergehenden Semester, werden die Angaben des 1. Stg. an der Berichtshochschule in den 1. Stg. des Vorsemesters und der 2. Stg. an der weiteren Hochschule in den 2. Stg. des Vorsemesters übernommen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_121".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_121");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei Mehrfacheinschreibung");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester im Vorsemester eine Einschreibung an der jetzigen und einer anderen Hochschule vorlag, jedoch im Berichtssemester keine Angabe der Hochschule bei Einschreibung an einer anderen Hochschule vorliegen und wenn lt. Angabe beide Studiengänge des Berichtssemesters gleich sind wie im vorhergehenden Semester, werden die Angaben des 1. Stg. an der Berichtshochschule in den 1. Stg. des Vorsemesters und der 2. Stg. an der weiteren Hochschule in den 2. Stg. des Vorsemesters übernommen und bei der Hochschule des \". Stg wird 9000 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_122".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_122");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei Mehrfacheinschreibung");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester im Vorsemester eine Einschreibung an der jetzigen und einer anderen Hochschule vorlag, jedoch im Berichtssemester keine Angabe der Hochschule und Abschluss bzw. Studienfach bei Einschreibung an einer anderen Hochschule vorliegen und wenn lt. Angabe beide Studiengänge des Berichtssemesters gleich sind wie im vorhergehenden Semester, werden die Angaben des 1. und 2. Studiengang der Berichtshochschule übernommen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_123".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_123");
+ fehler.setFehlertextKurz("Einsetzung der Angaben zum vorhergehenden Semester bei Mehrfacheinschreibung");
+ fehler.setFehlertextLang("Wenn laut Kennziffern zum Studium im unmittelbar vorhergehenden Semester im Vorsemester eine Einschreibung an der jetzigen und einer anderen Hochschule vorlag, jedoch im Berichtssemester keine Angabe für Abschluss bzw. Studienfach bei Einschreibung an einer anderen Hochschule vorliegen und wenn lt. Angabe beide Studiengänge des Berichtssemesters gleich sind wie im vorhergehenden Semester, werden die Angaben des 1. und 2. Studiengang der Berichtshochschule übernommen und bei Hochschule des 2. Stg die Hochschule der anderen Einschreibung im Berichtssemester");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_124".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_124");
+ fehler.setFehlertextKurz("Wenn die Hochschule im vorhergehenden Semester (1. Stg) aufgelöst wurde, wird Signierschlüssel 9000 eingesetzt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_127".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_127");
+ fehler.setFehlertextKurz("Wenn die Hochschule im vorhergehenden Semester (2. Stg) aufgelöst wurde, wird Signierschlüssel 9000 eingesetzt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_129".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_129");
+ fehler.setFehlertextKurz("Neuer Signierschlüssel bei Hochschule im vorhergehenden Semester (1. Studiengang)");
+ fehler.setFehlertextLang("Wenn die Hochschule im vorhergehenden Semester (1. Studiengang) in eine andere Hochschule eingegliedert wurde, wird der Signierschlüssel der neuen Hochschule eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_132".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_132");
+ fehler.setFehlertextKurz("Neuer Signierschlüssel bei Hochschule im vorhergehenden Semester (2. Studiengang)");
+ fehler.setFehlertextLang("Wenn die Hochschule im vorhergehenden Semester (2. Studiengang) in eine andere Hochschule eingegliedert wurde, wird der Signierschlüssel der neuen Hochschule eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_135".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_135");
+ fehler.setFehlertextKurz("Wenn das 1. Auslandsstudium leer und das 2. Auslandsstudium belegt ist, wird das 2. als 1. gesetzt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_138".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_138");
+ fehler.setFehlertextKurz("LEER bei Gesamtnote einsetzen");
+ fehler.setFehlertextLang("Wenn bei bereits vor dem Berichtssemester abgelegte Abschlußprüfungen an Hochschulen in der Gesamtnote die 1. Stelle mit LEER und die 2. und 3. Stelle mit 00 besetzt sind, dann wird LEER eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_141".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_141");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei vor dem Berichtssemester abgelegte Prüfung (1. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei vor dem Berichtssemester abgelegte Prüfung (1. Stg) leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_144".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_144");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei vor dem Berichtssemester abgelegte Prüfung (1. Stg)");
+ fehler.setFehlertextLang("Wenn das 2.Fach bei vor dem Berichtssemester abgelegte Prüfung (1. Stg) leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_147".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_147");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei vor dem Berichtssemester abgelegte Prüfung (1. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei vor dem Berichtssemester abgelegte Prüfung (1. Stg) leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_150".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_150");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei vor dem Berichtssemester abgelegte Prüfung (2. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei vor dem Berichtssemester abgelegte Prüfung (2. Stg) leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_153".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_153");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei vor dem Berichtssemester abgelegte Prüfung (2. Stg)");
+ fehler.setFehlertextLang("Wenn das 2.Fach bei vor dem Berichtssemester abgelegte Prüfung (2. Stg) leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_154".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_154");
+ fehler.setFehlertextKurz("Gesamtnote wird gelöscht");
+ fehler.setFehlertextLang("Wenn die Angabe der Prüfungsnote im EF99, EF108, EF135 oder EF135 nicht 3-stellig ist wird der Inhalt des Feldes gelöscht");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_156".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_156");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei vor dem Berichtssemester abgelegte Prüfung (2. Stg)");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei vor dem Berichtssemester abgelegte Prüfung (2. Stg) leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_159".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_159");
+ fehler.setFehlertextKurz("Unvollständige Angaben");
+ fehler.setFehlertextLang("Wenn Unvollständige Angaben in der letzten und/oder vorletzten Prüfung bei einer bereits vor dem Berichtssemester abgelegten Abschlußprüfungen an Hochschulen werden alle Angaben gelöscht.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_160".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_160");
+ fehler.setFehlertextKurz("Fehlende Angaben in der letzten Prüfung bei einer bereits vor dem Berichtssemester abgelegten Abschlussprüfung");
+ fehler.setFehlertextLang("Fehlen die Angaben der letzten bereits vor dem Berichtssemester abgelegten Abschlussprüfung und sind Angaben zu vorletzten Prüfung vorhanden werden diese Angaben umgesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_161".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_161");
+ fehler.setFehlertextKurz("Unvollständige Angaben zum Studienfach");
+ fehler.setFehlertextLang("Wenn unvollständige Angaben zum 1. Studienfach in der letzten und/oder vorletzten Prüfung bei einer bereits vor dem Berichtssemester abgelegten Abschlußprüfungen an Hochschulen wird Signatur 290 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_162".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_162");
+ fehler.setFehlertextKurz("Fehlende Gesamtnote bei der letzten Prüfung");
+ fehler.setFehlertextLang("Wenn bei der letzten Prüfung einer bereits vor dem Berichtssemester abgelegten Abschlußprüfungen an Hochschulen die Gesamtnote fehlt und das Prüfungsergebnis angegeben ist, wird 800 bzw. 900 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_165".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_165");
+ fehler.setFehlertextKurz("Fehlende Gesamtnote bei der vorletzten Prüfung");
+ fehler.setFehlertextLang("Wenn bei der vorletzten Prüfung einer bereits vor dem Berichtssemester abgelegten Abschlußprüfungen an Hochschulen die Gesamtnote fehlt und das Prüfungsergebnis angegeben ist, wird 800 bzw. 900 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_168".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_168");
+ fehler.setFehlertextKurz("LEER bei Gesamtnote einsetzen");
+ fehler.setFehlertextLang("Wenn bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung(en) in der Gesamtnote die 1. Stelle mit LEER und die 2. und 3. Stelle mit 00 besetzt sind, dann wird LEER eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_169".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_169");
+ fehler.setFehlertextKurz("Fehlende Gesamtnote bei 1. Prüfung einsetzen");
+ fehler.setFehlertextLang("Wenn bei seit der letzten Semestermeldung insgesamt abgeschlossenen 1. Prüfung die Gesamtnote fehlt und das Prüfungsergebnis angegeben ist, wird 800 bzw. 900 eingesetzt. Kontrolle gilt nicht für Brandenburg und Mecklenburg-Vorpommern");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_170".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_170");
+ fehler.setFehlertextKurz("Fehlende Gesamtnote bei 2. Prüfung einsetzen");
+ fehler.setFehlertextLang("Wenn bei seit der letzten Semestermeldung insgesamt abgeschlossenen 2. Prüfung die Gesamtnote fehlt und das Prüfungsergebnis angegeben ist, wird 800 bzw. 900 eingesetzt. Kontrolle gilt nicht für Brandenburg und Mecklenburg-Vorpommern");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_171".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_171");
+ fehler.setFehlertextKurz("Löschen der letzten bereits vor dem Berichtssemester abgelegten Prüfung.");
+ fehler.setFehlertextLang("Ist im Wintersemester der angestrebte Abschluss (mit Ausnahme Abschlussprüfung im Ausland) und das 1. Studienfach des 1. bzw. 2. Studienganges gleich dem 1. bzw. 2. Studiengang einer bereits im vorhergehenden Sommersemester abgelegten Prüfung werden die Angaben bei der letzten bereits vor dem Berichtssemester abgelegten Prüfung gelöscht. Diese Korrektor gilt nicht für die Länder Niedersachsen, Bremen, Nordrhein-Westfalen und Hessen. In Bayern gilt diese Kontrolle auch im Sommersemester.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_172".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_172");
+ fehler.setFehlertextKurz("Löschen der vorletzten bereits vor dem Berichtssemester abgelegten Prüfung.");
+ fehler.setFehlertextLang("Ist im Wintersemester der angestrebte Abschluss (mit Ausnahme Abschlussprüfung im Ausland) und das 1. Studienfach des 1. bzw. 2. Studienganges gleich dem 1. bzw. 2. Studiengang einer bereits im vorhergehenden Sommersemester abgelegten Prüfung werden die Angaben bei der vorletzten bereits vor dem Berichtssemester abgelegten Prüfung gelöscht. Diese Korrektor gilt nicht für die Länder Niedersachsen, Bremen, Nordrhein-Westfalen und Hessen. In Bayern gilt diese Kontrolle auch im Sommersemester.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_174".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_174");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei der 1. Prüfung");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (1. Prüfung) leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_177".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_177");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei der 1. Prüfung");
+ fehler.setFehlertextLang("Wenn das 2.Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (1. Prüfung) leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_180".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_180");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei der 1. Prüfung");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (1. Prüfung) leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_183".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_183");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei der 2. Prüfung");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (2. Prüfung) leer und das 2. und 3. Fach belegt ist, wird das 2. und 3. Fach als 1. und 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_186".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_186");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei der 2. Prüfung");
+ fehler.setFehlertextLang("Wenn das 2.Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (2. Prüfung) leer und das 3. Fach belegt ist, wird das 3. Fach als 2. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_189".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_189");
+ fehler.setFehlertextKurz("Verschiebung der Studienfächer bei der 2. Prüfung");
+ fehler.setFehlertextLang("Wenn das 1.Fach bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung (2. Prüfung) leer und das 2. Fach belegt ist, wird das 2. Fach als 1. Fach gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_192".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_192");
+ fehler.setFehlertextKurz("Keine Angaben zur 1. Prüfung, jedoch Angaben zur 2. Prüfung vorhanden");
+ fehler.setFehlertextLang("Bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung(en) sind keine Angaben zur 1. Prüfung, jedoch Angaben zur 2. Prüfung vorhanden.Übernahme der Angaben der 2. Prüfung in die 1. Prüfung.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_201".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_201");
+ fehler.setFehlertextKurz("Umrechnung der Punkte in die Gesamtnote bei Rechtswissenschaft");
+ fehler.setFehlertextLang("Bei abgeschlossenen Prüfungen im Studienfach \"Rechtswissenschaft\" werden die angegebenen Punkte in die entsprechende Gesamtnote umgesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_204".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_204");
+ fehler.setFehlertextKurz("Der 1. Stg. des Berichtssemesters wird in den 1. Stg. des vorhergehenden Semesters übernommen");
+ fehler.setFehlertextLang("Wenn bei einer Exmatrikulation im 1. Studiengang des Berichtssemesters die Angaben zum Studium im vorhergehenden Semester fehlen, wird - sofern vorhanden - der 1. Stg. des Berichtssemesters in den 1. Stg. des vorhergehenden Semesters übernommen");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_207".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_207");
+ fehler.setFehlertextKurz("Einsetzung Kennziffer und Hochschule im vorhergehenden Semester");
+ fehler.setFehlertextLang("Bei einer Exmatrikulation im 1. Studiengang des Berichtssemesters werden beim Studium im vorhergehenden Semester Kennziffer und Hochschule eingesetzt");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_210".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_210");
+ fehler.setFehlertextKurz("Bei Exmatrikulation im 1. Stg werden die Angaben ab Art des Studiums gelöscht");
+ fehler.setFehlertextLang("Bei Exmatrikulation im 1. Studiengang werden die Angaben ab Art des Studiums gelöscht. Angaben zur Anzahl der Fachsemester werden nicht gelöscht. Umsetzung gilt nicht für Nordrhein Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_213".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_213");
+ fehler.setFehlertextKurz("Bei Exmatrikulation im 2. Stg werden die Angaben ab Art des Studiums gelöscht");
+ fehler.setFehlertextLang("Bei Exmatrikulation im 2. Studiengang werden die Angaben ab Art des Studiums gelöscht. Angaben zur Anzahl der Fachsemester werden nicht gelöscht. Umsetzung gilt nicht für Nordrhein Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_216".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_216");
+ fehler.setFehlertextKurz("Bereinigung der Hochschul- und Fachsemesterangaben");
+ fehler.setFehlertextLang("Bei Exmatrikulation im 1. Studiengang des Berichtssemesters wird die Anzahl der zu hohen Hochschul- und Fachsemester maschinell bereinigt (Angabe Hochschulsemester gleich Fachsemester). Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf nummerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("Ist das Ergebnis der Berechnung ein einstelliger Wert (0 bis 9) muss dieser Wert noch in einen zweistelligen Wert mit einer Führenden NULL umgesetzt werden.");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_217".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_217");
+ fehler.setFehlertextKurz("Bereinigung der Hochschul- und Fachsemesterangaben");
+ fehler.setFehlertextLang("Bei Exmatrikulation im 1. Studiengang des Berichtssemesters wird die Anzahl der zu hohen Hochschul- und Fachsemester maschinell bereinigt (Angabe Hochschulsemester ungleich Fachsemester). Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("Ist das Ergebnis der Berechnung ein einstelliger Wert (0 bis 9) muss dieser Wert noch in einen zweistelligen Wert mit einer Führenden NULL umgesetzt werden.");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_219".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_219");
+ fehler.setFehlertextKurz("Ausländer mit Erwerb der HZB im Ausland und falsche oder fehlende Angaben zur Art der HZB");
+ fehler.setFehlertextLang("Einsetzung der Signatur '79' bei Art der HZB. Nur bei Fach- und Verwaltungsfachhochschulen. Bei wissenschaftlichen Hochschulen Kontrolle MA_220.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_220".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_220");
+ fehler.setFehlertextKurz("Ausländer mit Erwerb der HZB im Ausland und falsche oder fehlende Angaben zur Art der HZB");
+ fehler.setFehlertextLang("Einsetzung der Signatur '39' bei Art der HZB. Nur bei wissenschaftlichen Hochschulen. Bei Fach- und Verwaltungsfachhochschulen Kontrolle MA_219.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_222".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_222");
+ fehler.setFehlertextKurz("Leere Eingabefelder mit denen später in der PL gerechnet wird werden mit 0 gefüllt");
+ fehler.setFehlertextLang("Leere Eingabefelder mit denen später in der PL gerechnet wird werden mit 00 gefüllt. Dies betrifft die Eingabefelder EF19 , EF20, EF21, EF22, EF25, EF30, EF45, EF83 und EF86");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_225".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_225");
+ fehler.setFehlertextKurz("Leere Eingabefelder mit denen später in der PL gerechnet wird werden mit 0 gefüllt (Prüfungsangaben)");
+ fehler.setFehlertextLang("Leere Eingabefelder mit denen später in der PL gerechnet wird werden mit ’ gefüllt. Dies betrifft die Eingabefelder EF121 , EF122, EF123, EF124, EF125, EF137, EF138, EF139, EF140 und EF141");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_228".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_228");
+ fehler.setFehlertextKurz("Rundung der Prüfungsnote in EF99");
+ fehler.setFehlertextLang("Rundung der Prüfungsnote im Eingabefeld 99 (Gesamtnote der vor dem Berichtssemester abgelegten letzten Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_229".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_229");
+ fehler.setFehlertextKurz("Einsetzung '00' in die 2. und 3. Satzstelle des EF99");
+ fehler.setFehlertextLang("Ist die 2. oder 3. Satzstelle nicht numerisch wird '00' in die 2. und 3. Satzstelle eingesetzt. Ist die erste Stelle nicht numerisch wird der Inhalt auf LEER gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_231".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_231");
+ fehler.setFehlertextKurz("Rundung der Prüfungsnote in EF108");
+ fehler.setFehlertextLang("Rundung der Prüfungsnote im Eingabefeld 108 (Gesamtnote der vor dem Berichtssemester abgelegten vorletzten Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_232".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_232");
+ fehler.setFehlertextKurz("Einsetzung '00' in die 2. und 3. Satzstelle des EF108");
+ fehler.setFehlertextLang("Ist die 2. oder 3. Satzstelle nicht numerisch wird '00' in die 2. und 3. Satzstelle eingesetzt. Ist die erste Stelle nicht numerisch wird der Inhalt auf LEER gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_234".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_234");
+ fehler.setFehlertextKurz("Rundung der Prüfungsnote in EF135");
+ fehler.setFehlertextLang("Rundung der Prüfungsnote im Eingabefeld 135 (Gesamtnote der seit der letzten Semestermeldung abgeschlossenen 1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_235".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_235");
+ fehler.setFehlertextKurz("Einsetzung '00' in die 2. und 3. Satzstelle des EF135");
+ fehler.setFehlertextLang("Ist die 2. oder 3. Satzstelle nicht numerisch wird '00' in die 2. und 3. Satzstelle eingesetzt. Ist die erste Stelle nicht numerisch wird der Inhalt auf LEER gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_237".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_237");
+ fehler.setFehlertextKurz("Rundung der Prüfungsnote in EF151");
+ fehler.setFehlertextLang("Rundung der Prüfungsnote im Eingabefeld 151 (Gesamtnote der seit der letzten Semestermeldung abgeschlossenen 2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_238".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_238");
+ fehler.setFehlertextKurz("Einsetzung '00' in die 2. und 3. Satzstelle des EF151");
+ fehler.setFehlertextLang("Ist die 2. oder 3. Satzstelle nicht numerisch wird '00' in die 2. und 3. Satzstelle eingesetzt. Ist die erste Stelle nicht numerisch wird der Inhalt auf LEER gesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_240".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_240");
+ fehler.setFehlertextKurz("Einsetzung bei Grund der Beurlaubung/ Exmatrikulation");
+ fehler.setFehlertextLang("Wenn bei einer Studentin als Grund der Beurlaubung/ Exmatrikulation Wehr- oder Zivildiens\" angegeben ist, wird Sonstige Gründe eingesetzt");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_243".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_243");
+ fehler.setFehlertextKurz("Einsetzung bei Grund der Beurlaubung");
+ fehler.setFehlertextLang("Wenn bei einem Studenten als Grund der Beurlaubung Schwangerschaft angegeben ist, wird Sonstige Gründe eingesetzt");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_246".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_246");
+ fehler.setFehlertextKurz("Fehlende Angabe bei Land des Semesterwohnsitzes (EF10U1)");
+ fehler.setFehlertextLang("Bei fehlender Angabe bei Land des Semesterwohnsitzes (EF10U1) wird 98 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_248".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_248");
+ fehler.setFehlertextKurz("Fehlende Angabe bei Kreis des Semesterwohnsitzes (EF10U2)");
+ fehler.setFehlertextLang("Bei fehlender Angabe bei Kreis des Semesterwohnsitzes (EF10U2) wird 999 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_250".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_250");
+ fehler.setFehlertextKurz("Fehlende Angabe bei Land des Heimatwohnsitzes (EF11U1)");
+ fehler.setFehlertextLang("Bei fehlender Angabe bei Land desHeimatwohnsitzes (EF11U1) wird 98 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_252".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_252");
+ fehler.setFehlertextKurz("Fehlende Angabe bei Kreis des Heimatwohnsitzes (EF11U2)");
+ fehler.setFehlertextLang("Bei fehlender Angabe bei Kreis des Heimatwohnsitzes (EF11U2) wird 999 eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_254".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_254");
+ fehler.setFehlertextKurz("FalscheAngabe Hörerstatus (EF12)");
+ fehler.setFehlertextLang("Bei fehlender bzw. falscher Angabe zum Hörerstatus wird '1' Hauthörer eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_256".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_256");
+ fehler.setFehlertextKurz("Falsche oder fehlende Angabe bei Vollzeit, Teilzeit, Duales Studium (EF29) im 1.Studiengang");
+ fehler.setFehlertextLang("Bei falscher oder fehlender Angabe bei Vollzeit, Teilzeit, Duales Studium (EF29) im 1.Studiengang wird 1 Vollzeitstudium eingesetzt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_262".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_262");
+ fehler.setFehlertextKurz("Bei Studienkollegiaten mit angestrebtem Abschluß ungleich 95 (Sonstiger Abschluss) wird 95 eingesetzt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_264".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_264");
+ fehler.setFehlertextKurz("Einsetzung des Semesters und Jahres und Hochschule der Einschreibung");
+ fehler.setFehlertextLang("Wenn Erstimmatrikuliert und fehlende Angaben bei Semester oder Jahr oder Hochschule der Ersteinschreibung, dann erfolgt die Übernahme aus dem Berichtszeitraum");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_266".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_266");
+ fehler.setFehlertextKurz("An Fernuniversität und Fernfachhochschule ist nur Fernstudium zugelassen");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("MA_268".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("MA_268");
+ fehler.setFehlertextKurz("Angaben zum Semester und Jahr der Ersteinschreibung werden eingesetzt.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(3);
+ return fehler;
+ }
+ if ("SIG_001".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_001");
+ fehler.setFehlertextKurz("Signierschlüssel der Hochschule ist nicht zulässig");
+ fehler.setFehlertextLang("Bei der aktuellen Hochschule (EF4), der Hochschule der Ersteinschreibung (EF16), der Hochschule einer anderen Einschreibung (EF56) oder bei der Hochschule im vorhergehenden Semster (EF66 bzw. EF74) steht ein Signierschlüssel der nur bei der Personal und Stellenstatistik zulässig ist.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_003".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_003");
+ fehler.setFehlertextKurz("Geschlecht (EF7) ungleich 1 oder 2");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_006".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_006");
+ fehler.setFehlertextKurz("Angabe Geburtsmonat (EF8U1) ungleich 01 bis 12");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Ehemalige Signierkontrolle 1E");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_009".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_009");
+ fehler.setFehlertextKurz("Angabe Geburtsjahr (EF8U2) ungleich 1912 bis 2020");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_012".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_012");
+ fehler.setFehlertextKurz("Signatur Staatsangehörigkeit (EF9) stimmt nicht mit den Einträgen in Schlüsseltabelle STAAT überein");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_015".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_015");
+ fehler.setFehlertextKurz("Falsche Signatur bei Hochschule (EF4)");
+ fehler.setFehlertextLang("Bei Datensätzen mit Studententeil ist die Kombination Berichtsland und Hochschulnummer laut Schlüsseltabelle HOCHSCHULFACHBEREICH in Kombination mit Schlüsseltabelle HOCHSCHULSTANDORT nicht zulässig ODER bei Datensätzen ohne Studententeil ist die Signatur Hochschule laut Schlüsseltabelle HOCHSCHULFACHBEREICH nicht zulässig.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_021".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_021");
+ fehler.setFehlertextKurz("Falsche Signatur bei Land des Semesterwohnsitzes (EF10U1)");
+ fehler.setFehlertextLang("Land des Semesterwohnsitzes (EF10U1) stimmt nicht mit den Einträgen in Schlüsseltabelle BUNDESLAND überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_027".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_027");
+ fehler.setFehlertextKurz("Kreis des Semesterwohnsitzes (EF10U2) ungleich 000 bis 999");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_033".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_033");
+ fehler.setFehlertextKurz("Falsche Signatur bei Land des Heimatwohnsitzes (EF11U1)");
+ fehler.setFehlertextLang("Land des Heimatwohnsitzes (EF11U1) stimmt nicht mit den Einträgen in Schlüsseltabelle BUNDESLAND überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_039".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_039");
+ fehler.setFehlertextKurz("Kreis des Semesterwohnsitzes (EF11U2) ungleich 000 bis 999");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_045".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_045");
+ fehler.setFehlertextKurz("Falsche Signatur bei Hochschule der Ersteinschreibung (EF16)");
+ fehler.setFehlertextLang("Signatur bei Hochschule der Ersteinschreibung (EF16) stimmt nicht mit den Einträgen in Schlüsseltabelle HOCHSCHULFACHBEREICH überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_048".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_048");
+ fehler.setFehlertextKurz("Semester der Ersteinschreibung (EF17) ist ungleich LEER, 1 oder 2");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_051".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_051");
+ fehler.setFehlertextKurz("Jahr der Ersteinschreibung (EF18) ist ungleich LEER, 1923 bis Inhalt aus EF3 (Berichtsjahr)");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_054".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_054");
+ fehler.setFehlertextKurz("Angabe bei Hochschulsemester (EF19) ungleich 00 bis 99");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_058".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_058");
+ fehler.setFehlertextKurz("Angabe bei Urlaubssemester (EF20) ungleich 00 bis 99");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_060".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_060");
+ fehler.setFehlertextKurz("Anzahl der Praxissemester (EF21) ungleich 0 bis 9");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_063".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_063");
+ fehler.setFehlertextKurz("Anzahl der Semester in der DDR (EF22) ungleich 0 bis 9");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_066".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_066");
+ fehler.setFehlertextKurz("Signatur Art des Studiums in der DDR (EF23) ungleich 1 oder 2");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_069".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_069");
+ fehler.setFehlertextKurz("Angabe Semester am Studienkolleg (EF24) ungleich LEER, 0 bis 9");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_072".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_072");
+ fehler.setFehlertextKurz("Anzahl der Unterbrechungssemester (EF25) ungleich 00 bis 99");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_075".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_075");
+ fehler.setFehlertextKurz("Falsche Signatur bei Art der Einschreibung (EF26) im 1. Studiengang");
+ fehler.setFehlertextLang("Die Signatur der Art der Einschreibung (EF26) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln in der Schlüsseltabelle EINSCHREIBUNGART überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_078".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_078");
+ fehler.setFehlertextKurz("Signatur bei Grund der Beurlaubung/Exmatrikulation (EF27) im 1. Studiengang ungleich LEER, 0 bis 9");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_081".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_081");
+ fehler.setFehlertextKurz("Art des Studiums (EF28) im 1. Studiengang unzulässig");
+ fehler.setFehlertextLang("Die Signatur der Art des Studiums (EF28) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln in der Schlüsseltabelle STUDIUMART überein.");
+ fehler.setFehlerKorrekturhinweis("Ehemalige Signierkontrolle 2T");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_087".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_087");
+ fehler.setFehlertextKurz("Angabe bei Fachsemester (EF30) im 1. Studiengang ungleich 00 bis 99");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_090".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_090");
+ fehler.setFehlertextKurz("Falsche Signatur bei angestrebter Abschlussprüfung (EF31) im 1. Studiengang (ohne Exmatrikulierte)");
+ fehler.setFehlertextLang("Signatur bei angestrebter Abschlussprüfung (EF31) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein (ohne Exmatrikulierte)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_093".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_093");
+ fehler.setFehlertextKurz("Falsche Signatur bei angestrebter Abschlussprüfung (EF31) im 1. Studiengang (Nur Exmatrikulierte)");
+ fehler.setFehlertextLang("Signatur bei angestrebter Abschlussprüfung (EF31) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein (Nur Exmatrikulierte)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_096".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_096");
+ fehler.setFehlertextKurz("Falsche Signatur beim 1. Studienfach (EF32) im 1. Studiengang (ohne Exmatrikulierte)");
+ fehler.setFehlertextLang("Signatur beim 1. Studienfach (EF32) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein (ohne Exmatrikulierte)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_099".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_099");
+ fehler.setFehlertextKurz("Falsche Signatur beim 1. Studienfach (EF32) im 1. Studiengang (nur Exmatrikulierte)");
+ fehler.setFehlertextLang("Signatur beim 1. Studienfach (EF32) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein (nur Exmatrikulierte)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_102".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_102");
+ fehler.setFehlertextKurz("Falsche Signatur beim 2. Studienfach (EF34) im 1. Studiengang");
+ fehler.setFehlertextLang("Signatur beim 2. Studienfach (EF34) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_105".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_105");
+ fehler.setFehlertextKurz("Falsche Signatur beim 3. Studienfach (EF36) im 1. Studiengang");
+ fehler.setFehlertextLang("Signatur beim 3. Studienfach (EF36) im 1. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_108".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_108");
+ fehler.setFehlertextKurz("Falsche Signatur bei Art der Einschreibung (EF41) im 2. Studiengang");
+ fehler.setFehlertextLang("Die Signatur der Art der Einschreibung (EF41) im 2. Studiengang stimmt nicht mit den zulässigen Schlüsseln in der Schlüsseltabelle EINSCHREIBUNGART überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_111".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_111");
+ fehler.setFehlertextKurz("Signatur bei Grund der Beurlaubung/Exmatrikulation (EF42) im 2. Studiengang ungleich LEER, 0 bis 9");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_114".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_114");
+ fehler.setFehlertextKurz("Art des Studiums (EF43) im 2. Studiengang unzulässig");
+ fehler.setFehlertextLang("Die Signatur der Art des Studiums (EF43) im 2. Studiengang stimmt nicht mit den zulässigen Schlüsseln in der Schlüsseltabelle STUDIUMARTART überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_117".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_117");
+ fehler.setFehlertextKurz("Falsche Angabe bei Vollzeit, Teilzeit, Duales Studium (EF44) im 2.Studiengang");
+ fehler.setFehlertextLang("Die Signatur bei Vollzeit, Teilzeit, Duales Studium (EF44) im 2.Studiengang stimmt nicht mit den zulässigen Schlüsseln in der Schlüsseltabelle VOLLTEILZEIT überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_120".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_120");
+ fehler.setFehlertextKurz("Angabe bei Fachsemester (EF45) im 2. Studiengang ungleich 00 bis 99");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_123".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_123");
+ fehler.setFehlertextKurz("Falsche Signatur bei angestrebter Abschlussprüfung (EF46) im 2. Studiengang (ohne Exmatrikulierte)");
+ fehler.setFehlertextLang("Signatur bei angestrebter Abschlussprüfung (EF46) im 2. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein (ohne Exmatrikulierte)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_126".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_126");
+ fehler.setFehlertextKurz("Falsche Signatur beim 1. Studienfach (EF47) im 2. Studiengang");
+ fehler.setFehlertextLang("Signatur beim 1. Studienfach (EF47) im 2. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_129".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_129");
+ fehler.setFehlertextKurz("Falsche Signatur beim 2. Studienfach (EF49) im 2. Studiengang");
+ fehler.setFehlertextLang("Signatur beim 2. Studienfach (EF49) im 2. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_132".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_132");
+ fehler.setFehlertextKurz("Falsche Signatur beim 3. Studienfach (EF51) im 2. Studiengang");
+ fehler.setFehlertextLang("Signatur beim 3. Studienfach (EF51) im 2. Studiengang stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_135".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_135");
+ fehler.setFehlertextKurz("Falsche Signatur bei Einschreibung an einer anderen Hochschule (EF56) im Berichtssemester");
+ fehler.setFehlertextLang("Die Signatur der Hochschule (EF56), bei einer Einschreibung an einer anderen Hochschule im Berichtssemster, stimmt nicht mit den zulässigen Schlüsseln aus der Schlüsseltabelle HOCHSCHULFACHBEREICH überein, ist ungleich LEER oder ist gleich 9000.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_138".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_138");
+ fehler.setFehlertextKurz("Falsche Signatur der angestrebten Abschlussprüfung (EF59)");
+ fehler.setFehlertextLang("Die Signatur der angestrebten Abschlussprüfung (EF59), bei einer Einschreibung an einer anderen Hochschule im Berichtssemster, stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_141".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_141");
+ fehler.setFehlertextKurz("Falsche Signatur beim 1. Studienfach (EF60)");
+ fehler.setFehlertextLang("Die Signatur beim 1. Studienfach (EF60), bei einer Einschreibung an einer anderen Hochschule im Berichtssemster, stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_144".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_144");
+ fehler.setFehlertextKurz("Falsche Signatur beim 2. Studienfach (EF61)");
+ fehler.setFehlertextLang("Die Signatur beim 2. Studienfach (EF61), bei einer Einschreibung an einer anderen Hochschule im Berichtssemster, stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_147".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_147");
+ fehler.setFehlertextKurz("Falsche Signatur beim 3. Studienfach (EF62)");
+ fehler.setFehlertextLang("Die Signatur beim 3. Studienfach (EF62), bei einer Einschreibung an einer anderen Hochschule im Berichtssemster, stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_150".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_150");
+ fehler.setFehlertextKurz("Falsche Signatur bei der Kennziffer für die jetzte oder andere Hochschule (EF64)");
+ fehler.setFehlertextLang("Die Signatur bei der Kennziffer für die jetzige oder andere Hochschule (EF64) beim Studium im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln 1 bis 4 überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_153".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_153");
+ fehler.setFehlertextKurz("Falsche Signatur bei Kennziffer des Studienganges (EF65U1)");
+ fehler.setFehlertextLang("Die Signatur bei Kennziffer des Studienganges (EF65U1) beim Studium im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln 1 bis 3 überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_156".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_156");
+ fehler.setFehlertextKurz("Falsche Signatur bei der Hochschule (EF66) im vorhergehenden Semester (1. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur bei der Hochschule (EF66) im vorhergehenden Semester, ist gleich 9990 oder stimmt nicht mit den zulässigen Schlüsseln aus der Schlüsseltabelle HOCHSCHULFACHBEREICH überein. (1. Studiengang).");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_159".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_159");
+ fehler.setFehlertextKurz("Falsche Signatur bei der angestrebten Abschlussprüfung (EF69)");
+ fehler.setFehlertextLang("Die Signatur bei der angestrebten Abschlussprüfung (EF69) im vorhergehenden Semester(1. Studiengang), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_162".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_162");
+ fehler.setFehlertextKurz("Falsche Signatur beim 1. Studienfach (EF70) im vorhergehenden Semester (1. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur beim 1. Studienfach (EF70) im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein\n.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_165".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_165");
+ fehler.setFehlertextKurz("Falsche Signatur beim 2. Studienfach (EF71) im vorhergehenden Semester (1. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur beim 2. Studienfach (EF71) im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_168".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_168");
+ fehler.setFehlertextKurz("Falsche Signatur beim 3. Studienfach (EF72) im vorhergehenden Semester (1. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur beim 3. Studienfach (EF72) im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_171".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_171");
+ fehler.setFehlertextKurz("Falsche Signatur bei der Hochschule (EF74) im vorhergehenden Semester (2. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur bei der Hochschule (EF74) im vorhergehenden Semester, ist gleich 9990 oder stimmt nicht mit den zulässigen Schlüsseln aus der Schlüsseltabelle HOCHSCHULFACHBEREICH überein. (2. Studiengang)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_174".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_174");
+ fehler.setFehlertextKurz("Falsche Signatur bei der angestrebten Abschlussprüfung (EF77) im vorhergehenden Semester (2. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur bei der angestrebten Abschlussprüfung (EF77) im vorhergehenden Semester(2.Studiengang), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_177".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_177");
+ fehler.setFehlertextKurz("Falsche Signatur beim 1. Studienfach (EF78) im vorhergehenden Semester (2. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur beim 1. Studienfach (EF78) im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_180".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_180");
+ fehler.setFehlertextKurz("Falsche Signatur beim 2. Studienfach (EF79) im vorhergehenden Semester (2. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur beim 2. Studienfach (EF79) im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_183".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_183");
+ fehler.setFehlertextKurz("Falsche Signatur beim 3. Studienfach (EF80) im vorhergehenden Semester (2. Studiengang)");
+ fehler.setFehlertextLang("Die Signatur beim 3. Studienfach (EF80) im vorhergehenden Semester, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_186".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_186");
+ fehler.setFehlertextKurz("Falsche Signatur beim Staat (EF82) bei früherem Studium im Ausland (1. Staat)");
+ fehler.setFehlertextLang("Die Signatur beim Staat (EF82) bei früherem Studium im Ausland, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus der Schlüsseltabelle STAAT überein. (1. Staat)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_189".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_189");
+ fehler.setFehlertextKurz("Falsche Signatur bei Anzahl der Monate (EF83) bei früherem Studium im Ausland (1. Staat)");
+ fehler.setFehlertextLang("Die Signatur bei Anzahl der Monate (EF83) bei früherem Studium im Ausland, stimmt nicht mit den zulässigen Schlüsseln 00 bis 99 überein. (1. Staat)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_192".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_192");
+ fehler.setFehlertextKurz("Falsche Signatur beim Staat (EF85) bei früherem Studium im Ausland (2. Staat)");
+ fehler.setFehlertextLang("Die Signatur beim Staat (EF85) bei früherem Studium im Ausland, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus der Schlüsseltabelle STAAT überein. (2. Staat)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_195".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_195");
+ fehler.setFehlertextKurz("Falsche Signatur bei Anzahl der Monate (EF86) bei früherem Studium im Ausland (2. Staat)");
+ fehler.setFehlertextLang("Die Signatur bei Anzahl der Monate (EF86) bei früherem Studium im Ausland, stimmt nicht mit den zulässigen Schlüsseln 00 bis 99 überein. (2. Staat)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_198".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_198");
+ fehler.setFehlertextKurz("Falsche Signatur der Abschlussprüfung (EF91) von vor dem Berichtssemester (letzte Prüfung)");
+ fehler.setFehlertextLang("Die Signatur der Abschlussprüfung (EF91), die vor dem Berichtssemester abgelegt wurden, ist kein Abschluss (Signatur Abschlussprüfung >= 900) oder stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_201".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_201");
+ fehler.setFehlertextKurz("Falsche Signatur des 1. Studienfaches (EF92)");
+ fehler.setFehlertextLang("Die Signatur des 1. Studienfaches (EF92), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_204".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_204");
+ fehler.setFehlertextKurz("Falsche Signatur des 2. Studienfaches (EF93)");
+ fehler.setFehlertextLang("Die Signatur des 2. Studienfaches (EF93), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_207".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_207");
+ fehler.setFehlertextKurz("Falsche Signatur des 3. Studienfaches (EF94)");
+ fehler.setFehlertextLang("Die Signatur des 3. Studienfaches (EF94), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_210".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_210");
+ fehler.setFehlertextKurz("Falsche Signatur bei Monat der Abschlussprüfung (EF96)");
+ fehler.setFehlertextLang("Die Signatur des Monats der Abschlussprüfung (EF96), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den Schlüsseln 01 bis 12 überein. (letzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_213".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_213");
+ fehler.setFehlertextKurz("Falsche Signatur Jahr der Abschlussprüfung (EF97)");
+ fehler.setFehlertextLang("Die Signatur des Jahres der Abschlussprüfung (EF97), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den Schlüsseln 1930 bis Berichtsjahr. (letzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_216".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_216");
+ fehler.setFehlertextKurz("Falsche Signatur Prüfungsergebnis (EF98)");
+ fehler.setFehlertextLang("Die Signatur des Prüfungsergebnisses (EF98), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER,1 ,2 (letzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_219".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_219");
+ fehler.setFehlertextKurz("Falsche Signatur Gesamtnote (EF99)");
+ fehler.setFehlertextLang("Die Signatur der Gesamtnote (EF99), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER, 000, 100, 200, 300, 400, 700, 800, 900 (letzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_222".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_222");
+ fehler.setFehlertextKurz("Falsche Signatur der Abschlussprüfung (EF100)");
+ fehler.setFehlertextLang("Die Signatur der Abschlussprüfung (EF100), die vor dem Berichtssemester abgelegt wurden, ist kein Abschluss (Signatur Abschlussprüfung >= 900) oder stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_225".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_225");
+ fehler.setFehlertextKurz("Falsche Signatur des 1. Studienfaches (EF101)");
+ fehler.setFehlertextLang("Die Signatur des 1. Studienfaches (EF101), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_228".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_228");
+ fehler.setFehlertextKurz("Falsche Signatur des 2. Studienfaches (EF102)");
+ fehler.setFehlertextLang("Die Signatur des 2. Studienfaches (EF102), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_231".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_231");
+ fehler.setFehlertextKurz("Falsche Signatur des 3. Studienfaches (EF103)");
+ fehler.setFehlertextLang("Die Signatur des 3. Studienfaches (EF103), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_234".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_234");
+ fehler.setFehlertextKurz("Falsche Signatur Monat der Abschlussprüfung (EF105)");
+ fehler.setFehlertextLang("Die Signatur des Monats der Abschlussprüfung (EF105), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER, 01 bis 12 (ggf. vorletzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_237".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_237");
+ fehler.setFehlertextKurz("Falsche Signatur Jahr der Abschlussprüfung (EF106)");
+ fehler.setFehlertextLang("Die Signatur des Jahres der Abschlussprüfung (EF106), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER und stimmt nicht mit den Schlüsseln 1930 bis Berichtsjahr überein. (ggf. vorletzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_240".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_240");
+ fehler.setFehlertextKurz("Falsche Signatur Prüfungsergebnis (EF107)");
+ fehler.setFehlertextLang("Die Signatur des Prüfungsergebnisses (EF107), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER, 1, 2 (ggf. vorletzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_243".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_243");
+ fehler.setFehlertextKurz("Falsche Signatur Gesamtnote (EF108)");
+ fehler.setFehlertextLang("Die Signatur der Gesamtnote (EF108), der Abschlussprüfungen die vor dem Berichtssemester abgelegt wurden, ist ungleich LEER, 000, 100, 200, 300, 400, 700, 800, 900 (ggf. vorletzte Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_246".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_246");
+ fehler.setFehlertextKurz("Falsche Signatur Jahr des Ewerbs der HZB (EF109)");
+ fehler.setFehlertextLang("Die Signatur des Jahres des Erwerbs der HZB (EF109), stimmt nicht mit den Schlüsseln 1923,1924 bis Berichtsjahr überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_249".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_249");
+ fehler.setFehlertextKurz("Falsche Signatur Art der HZB (EF110)");
+ fehler.setFehlertextLang("Die Signatur der Art der HZB (EF110), stimmt nicht mit den Schlüsseln aus der Schlüsseltabelle HZBART überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_255".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_255");
+ fehler.setFehlertextKurz("Falsche Signaturbei Land des Erwerbs der HZB (EF111U1)");
+ fehler.setFehlertextLang("Die Signatur Land des Erwerbs der HZB (EF111U1), stimmt nicht mit den Schlüsseln aus der Schlüsseltabelle BUNDESLAND überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_261".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_261");
+ fehler.setFehlertextKurz("Falsche Signatur Kreis bzw. Staat des Erwerbs der HZB (EF111U2)");
+ fehler.setFehlertextLang("Die Signatur Kreis bzw. Staat des Erwerbs der HZB (EF111U2), stimmt nicht mit den Schlüsseln 000,001..999 überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_264".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_264");
+ fehler.setFehlertextKurz("Falsche Signatur Berufsausbildung mit Abschluss (EF112)");
+ fehler.setFehlertextLang("Die Signatur Berufsausbildung mit Abschluss (EF112), ist ungleich LEER, 1");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_267".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_267");
+ fehler.setFehlertextKurz("Falsche Signatur Praktikum (EF113)");
+ fehler.setFehlertextLang("Die Signatur Praktikum (EF113), ist ungleich LEER, 1");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_270".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_270");
+ fehler.setFehlertextKurz("Falsche Signatur bzw. falsche Kombination beim Prüfungsamt (EF120) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur beim Prüfungsamt (EF120), ist auf der ersten Satzstelle (Art des Prüfungsamtes; EF120,1,1) ungleich LEER, 1 bis 5 ODER die erste Satzstelle (Art des Prüfungsamtes; EF120,1,1) ist gleich 3' und stimmt auf den Satzstellen zwei bis fünf (Nummer des Prüfungsamtes; EF120,2,4) nicht mit den Schlüsseln 0801,0802 bis 0816 überein ODER die erste Satzstelle (Art des Prüfungsamtes; EF120,1,1) ist gleich 5' und stimmt auf den Satzstellen zwei bis fünf (Nummer des Prüfungsamtes; EF120,2,4) nicht mit den Schlüsseln 0901,0902 bis 0916 überein. (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_273".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_273");
+ fehler.setFehlertextKurz("Falsche Signatur Nr. des Prüfungsamt (EF120,2,4) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur bei der Nummer des Prüfungsamtes (EF120,2,4), ist ungleich LEER und stimmt nicht mit den Schlüsseln 0801,0802..0816,0901,0902..0916 überein ODER die Nummer des Prüfungsamtes stimmt nicht mit dem key aus dem HOCHSCHULFACHBEREICH überein (bei Prüfungsamt an der Hochschule). (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_276".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_276");
+ fehler.setFehlertextKurz("Falsche Signatur bei lfd. Nummer des Prüfungsamt (EF120,6,2) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur bei der laufenden Nummer des Prüfungsamtes (EF120,6,2), ist ungleich LEER und stimmt nicht mit den Schlüsseln 01 bis 99 überein. (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_279".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_279");
+ fehler.setFehlertextKurz("Falsche Signatur Anzahl der Fachsemester (EF121) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Angabe bei der Anzahl der Fachsemester (EF121) ist ungleich 00 bis 99. (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_282".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_282");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester insgesamt (EF122) (1. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester insgesamt (EF122), ist ungleich 00, 01 bis 99 (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_285".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_285");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester aus einem anderen Studiengang (EF123) (1. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester aus einem anderen Studiengang (EF123) ist ungleich 0 bis 9. (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_288".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_288");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester;hier: Praxissemester (EF124) (1. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester;hier: Praxissemester (EF124) ist ungleich 0 bis 9. (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_291".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_291");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester aus einem Auslandsstudium (EF125) (1. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester aus einem Auslandsstudium (EF125) ist ungleich 0 bis 9. (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_294".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_294");
+ fehler.setFehlertextKurz("Falsche Signatur der Abschlussprüfung (EF126) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur der Abschlussprüfung (EF126), ist gleich kein Abschluss (Signatur Abschlussprüfung >= 900) oder stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_297".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_297");
+ fehler.setFehlertextKurz("Falsche Signatur 1. Studienfach (EF127) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des 1.Studienfach (EF127), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_300".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_300");
+ fehler.setFehlertextKurz("Falsche Punktzahl (EF152) bei Rechtswissenschaften (1. STF; EF127) (1. Prüfung)");
+ fehler.setFehlertextLang("Beim 1. Studienfach '135' (Rechtswissenschaften) ist das EF152 für die Punktzahl ungleich LEER, 0000 bis 1800 (1. Prüfung) (nicht für Bayern)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_303".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_303");
+ fehler.setFehlertextKurz("Falsche Punktzahl (EF152 bei Rechtswissenschaften (1. STF; EF127) (1. Prüfung)");
+ fehler.setFehlertextLang("Beim 1. Studienfach '135' (Rechtswissenschaften) und Abschlussprüfung (126,2,2) gleich '08' (Staatsexamen/1. Staatsprüfung), ist das EF152 für die Punktzahl ungleich LEER, 0000 bis 1800. (1. Prüfung) (nur für Bayern)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_306".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_306");
+ fehler.setFehlertextKurz("Falsche Signatur 2. Studienfach (EF128) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des 2. Studienfach (EF128), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein. (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_309".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_309");
+ fehler.setFehlertextKurz("Falsche Signatur 3. Studienfach (EF129) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des 3. Studienfach (EF129), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_312".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_312");
+ fehler.setFehlertextKurz("Monat der Abschlussprüfung (EF132) (1. Prüfung)");
+ fehler.setFehlertextLang("Angabe des Monats der Abschlussprüfung (EF132), ist ungleich LEER, 01 bis 12 (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_315".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_315");
+ fehler.setFehlertextKurz("Jahr der Abschlussprüfung (EF133) (1. Prüfung)");
+ fehler.setFehlertextLang("Angabe Jahre der Abschlussprüfung (EF133), ist ungleich LEER und nicht Zeitspanne von Berichtsjahr minus 1 bis Berichtsjahr + 1 (1. Prüfung). Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_318".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_318");
+ fehler.setFehlertextKurz("Falsche Signatur Prüfungsergebnis (EF134) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des Prüfungsergebnisses (EF134), ist ungleich LEER, 1, 2, 3 (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_321".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_321");
+ fehler.setFehlertextKurz("Falsche Signatur Prüfungsnote (EF135) (1. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur der Prüfungsnote (EF135), ist ungleich LEER, 000, 100, 200, 300, 400, 700, 800, 900 (1. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_324".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_324");
+ fehler.setFehlertextKurz("Falsche Signatur bzw. falsche Kombination beim Prüfungsamt (EF136) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur beim Prüfungsamt (EF136), ist auf der ersten Satzstelle (Art des Prüfungsamtes; EF136,1,1) ungleich LEER, 1 bis 5 ODER die erste Satzstelle (Art des Prüfungsamtes; EF136,1,1) ist gleich 3' und stimmt auf den Satzstellen zwei bis fünf (Nummer des Prüfungsamtes; EF136,2,4) nicht mit den Schlüsseln 0801,0802 bis 0816 überein ODER die erste Satzstelle (Art des Prüfungsamtes; EF136,1,1) ist gleich 5' und stimmt auf den Satzstellen zwei bis fünf (Nummer des Prüfungsamtes; EF136,2,4) nicht mit den Schlüsseln 0901,0902 bis 0916 überein. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_327".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_327");
+ fehler.setFehlertextKurz("Falsche Signatur Nr. des Prüfungsamt (EF136,2,4) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur bei der Nummer des Prüfungsamtes (EF136,2,4), ist ungleich LEER und stimmt nicht mit den Schlüsseln 0801,0802..0816,0901,0902..0916 überein ODER die Nummer des Prüfungsamtes stimmt nicht mit dem key aus dem HOCHSCHULFACHBEREICH überein (bei Prüfungsamt an der Hochschule). (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_330".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_330");
+ fehler.setFehlertextKurz("Falsche Signatur bei lfd. Nummer des Prüfungsamt (EF136,6,2) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur bei der laufenden Nummer des Prüfungsamtes (EF136,6,2), ist ungleich LEER und stimmt nicht mit den Schlüsseln 01 bis 99 überein. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_333".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_333");
+ fehler.setFehlertextKurz("Anzahl der Fachsemester (EF137) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Angabe bei der Anzahl der Fachsemester (EF137) ist ungleich 00 bis 99. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_336".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_336");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester insgesamt (EF138) (2. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester insgesamt (EF138), ist ungleich 00, 01 bis 99 (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_339".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_339");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester aus einem anderen Studiengang (EF139) (2. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester aus einem anderen Studiengang (EF139) ist ungleich 0 bis 9. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_342".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_342");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester;hier: Praxissemester (EF140) (2. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester;hier: Praxissemester (EF140) ist ungleich 0 bis 9. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_345".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_345");
+ fehler.setFehlertextKurz("Falsche Anzahl der angerechneten Fachsemester aus einem Auslandsstudium (EF141) (2. Prüfung)");
+ fehler.setFehlertextLang("Anzahl der angerechneten Fachsemester aus einem Auslandsstudium (EF141) ist ungleich 0 bis 9. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_348".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_348");
+ fehler.setFehlertextKurz("Falsche Signatur der Abschlussprüfung (EF142) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur der Abschlussprüfung (EF142), ist gleich kein Abschluss (Signatur Abschlussprüfung grösser gleich 900) oder stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle ABSCHLUSS3STELLER_LAND (Landesinterne Abschlussprüfungen) bzw. Schlüsseltabelle ABSCHLUSS3STELLER (Bundesschlüssel) überein (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_351".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_351");
+ fehler.setFehlertextKurz("Falsche Signatur 1. Studienfach (EF143) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des 1.Studienfach (EF143), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_354".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_354");
+ fehler.setFehlertextKurz("Falsche Signatur 2. Studienfach (EF144) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des 2. Studienfach (EF144), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein. (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_357".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_357");
+ fehler.setFehlertextKurz("Falsche Signatur 3. Studienfach (EF145) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des 3. Studienfach (EF145), ist ungleich LEER und stimmt nicht mit den zulässigen Schlüsseln aus Schlüsseltabelle STUDIENFACH_LAND (Landesinterne Studienfächer) bzw. Schlüsseltabelle STUDIENFACH (Bundesschlüssel) überein (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_360".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_360");
+ fehler.setFehlertextKurz("Monat der Abschlussprüfung (EF148) (2. Prüfung)");
+ fehler.setFehlertextLang("Angabe des Monats der Abschlussprüfung (EF148), ist ungleich LEER, 01 bis 12 (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_363".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_363");
+ fehler.setFehlertextKurz("Jahr der Abschlussprüfung (EF149) (2. Prüfung)");
+ fehler.setFehlertextLang("Angabe Jahre der Abschlussprüfung (EF149), ist ungleich LEER und nicht Zeitspanne von Berichtsjahr minus 1 bis Berichtsjahr + 1 (2. Prüfung). Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_366".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_366");
+ fehler.setFehlertextKurz("Falsche Signatur Prüfungsergebnis (EF150) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur des Prüfungsergebnisses (EF150), ist ungleich LEER, 1, 2, 3 (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("SIG_369".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("SIG_369");
+ fehler.setFehlertextKurz("Falsche Signatur Prüfungsnote (EF151) (2. Prüfung)");
+ fehler.setFehlertextLang("Die Signatur der Prüfungsnote (EF151), ist ungleich LEER, 000, 100, 200, 300, 400, 700, 800, 900 (2. Prüfung)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_003K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_003K");
+ fehler.setFehlertextKurz("Datensatz erfüllt nicht die Bedingung zur Übernahme im Sommersemester (Studienanfänger)");
+ fehler.setFehlertextLang("Datensatz wurde durch Korrektur so verändert das dieser nicht mehr den nachfolgenden Bedingungen entspricht. 1) Berichtsjahr (EF3) gleich Jahr der Ersteinschreibung (EF18) oder Anzahl der Hochschulsemester (EF19) = 01 oder Art der Einschreibung 1. Stg. (EF26) gleich Ersteinschreibung 1 , Exmatrikulation 5 oder frühere Exmatrikulation 6 oder Anzahl der Fachsemester 1. Stg. (EF30) = 01 oder Art der Einschreibung 2. Stg. (EF41) gleich Ersteinschreibung 1 oder Anzahl der Fachsemester 2. Stg. (EF45) = 01 . Kontrolle gilt nicht für Bayern, Nordrhein-Westfalen und Sachsen-Anhalt, da hier auch im Sommersemester Aufbereitung des Studentenbestandes.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_006M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_006M");
+ fehler.setFehlertextKurz("Falsche Kennziffer bei Semesterwohnsitz in Deutschland");
+ fehler.setFehlertextLang("Angabe des Kreises bei Semesterwohnsitz in Deutschland entspricht nicht den zulässigen Schlüsseln in Schlüsseltabelle KREISE.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_009M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_009M");
+ fehler.setFehlertextKurz("Falscher Länderschlüssel bei Semesterwohnsitz außerhalb Deutschlands");
+ fehler.setFehlertextLang("Angabe des Kreises (Staat) bei Semesterwohnsitz im Ausland entspricht nicht den zulässigen Schlüsseln in Schlüsseltabelle STAAT.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_012M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_012M");
+ fehler.setFehlertextKurz("Falsche Kreiskennziffer bei Heimatwohnsitz in Deutschland");
+ fehler.setFehlertextLang("Angabe des Kreises bei Heimatwohnsitz in Deutschland entspricht nicht den zulässigen Schlüsseln in Schlüsseltabelle KREISE.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_015M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_015M");
+ fehler.setFehlertextKurz("Falscher Länderschlüssel bei Heimatwohnsitz außerhalb Deutschlands");
+ fehler.setFehlertextLang("Angabe des Kreises (Staat) bei Heimatwohnsitz im Ausland entspricht nicht den zulässigen Schlüsseln in Schlüsseltabelle STAAT.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_018M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_018M");
+ fehler.setFehlertextKurz("Falsche Kreiskennziffer bei Kreis des Erwerbs der HZB in Deutschland");
+ fehler.setFehlertextLang("Angabe des Kreises bei Kreis des Erwerbs der HZB in Deutschland entspricht nicht den zulässigen Schlüsseln in Schlüsseltabelle KREISE.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_021M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_021M");
+ fehler.setFehlertextKurz("Falscher Länderschlüssel bei Erwerb der HZB außerhalb Deutschlands");
+ fehler.setFehlertextLang("Länderschlüssel bei Erwerb der HZB außerhalb Deutschlands entspricht nicht den zulässigen Schlüsseln in Schlüsseltabelle STAAT.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_024K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_024K");
+ fehler.setFehlertextKurz("Deutsche Studienkollegiaten");
+ fehler.setFehlertextLang("Hörerstatus Studienkollegiat und als Staatsangehörigkeit wurde Deutschland angegeben.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_027M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_027M");
+ fehler.setFehlertextKurz("Bei Studienkolleg stimmen die Angaben zum Hörerstatus und 1. Studienfach nicht überein");
+ fehler.setFehlertextLang("Bei Studienkolleg stimmen die Angaben zum Hörerstatus und 1. Studienfach nicht überein. Teil 3 und 4 dieser Kontrolle gilt nur für Nordrhein-Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_033M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_033M");
+ fehler.setFehlertextKurz("Studienkolleg wurde als Studienfach angegeben, obwohl laut Hörerstatus Haupt- bzw. Nebenhörer");
+ fehler.setFehlertextLang("Studienkolleg wurde als Studienfach angegeben, obwohl laut Hörerstatus Haupt- bzw. Nebenhörer. Teil 3 und 4 dieser Kontrolle gilt nur für Nordrhein-Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_036M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_036M");
+ fehler.setFehlertextKurz("Kombination der Merkmale zur Ersteinschreibung sind fehlerhaft");
+ fehler.setFehlertextLang("Bei Gleichheit von Berichtszeitraum der Ersteinschreibung mit dem Berichtssemester und Jahr ist der Student nicht im 1. Hochschulsemester oder der Student ist im 1. Hochschulsemester und die Hochschule der Ersteinschreibung stimmt nicht mit der Hochschule des Berichtssemesters überein oder der Student befindet sich im 1. Hochschulsemester und das Berichtssemester und Jahr ist ungleich dem Semester und Jahr der Ersteinschreibung.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_042M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_042M");
+ fehler.setFehlertextKurz("Erstimmatrikulierte sind nicht im 1. Hochschulsemester");
+ fehler.setFehlertextLang("Laut Art der Einschreibung sind Erstimmatrikulierte nicht im 1. Hochschulsemester oder Studierende im 1. Hochschulsemester sind laut Art der Einschreibung keine Erstimmatrikulierten");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_045M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_045M");
+ fehler.setFehlertextKurz("Keine Erstimmatrikulation jedoch entspricht Ersteinschreibung dem Berichtszeitraum");
+ fehler.setFehlertextLang("Laut Art der Einschreibung keine Ersteinschreibung, jedoch das Semester und Jahr der Ersteinschreibung ist gleich dem Berichtssemester und Berichtsjahr.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_048M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_048M");
+ fehler.setFehlertextKurz("Erst- und Neuimmatrikulierte bzw. Rückmelder haben Angaben zur Beurlaubung oder Exmatrikulation");
+ fehler.setFehlertextLang("Bei Erst- und Neuimmatrikulierten bzw. Rückmeldern sind Angaben für Beurlaubung oder Exmatrikulation vorhanden");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_051M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_051M");
+ fehler.setFehlertextKurz("Studierende, die länger als 7 Semester beurlaubt sind");
+ fehler.setFehlertextLang("Studierende, die beginnend mit der Ersteinschreibung länger als 7 Semester beurlaubt sind (Kontrolle gilt nicht für Baden Württemberg und Bayern)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_054M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_054M");
+ fehler.setFehlertextKurz("Bei Erst- und Neuimmatrikulierten bzw. Rückmeldern sind keine Fachsemester angegeben");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_057M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_057M");
+ fehler.setFehlertextKurz("Grund der Beurlaubung bzw. Exmatrikulation stimmen nicht überein");
+ fehler.setFehlertextLang("Beurlaubt bzw. Exmatrikuliert im 1. Studiengang und Angaben bei Grund der Beurlaubung bzw. Exmatrikulation stimmen nicht überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_060M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_060M");
+ fehler.setFehlertextKurz("Grund der Beurlaubung bzw. Exmatrikulation stimmen nicht überein");
+ fehler.setFehlertextLang("Beurlaubt bzw. Exmatrikuliert im 2. Studiengang und Angaben bei Grund der Beurlaubung bzw. Exmatrikulation stimmen nicht überein");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_063M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_063M");
+ fehler.setFehlertextKurz("Beurlaubte im/seit 1. Hochschulsemester und fehlerhafte Angaben");
+ fehler.setFehlertextLang("Bei Beurlaubten seit dem 1. Hochschulsemester stehen fehlerhafte Angaben bei der Art der Einschreibung oder bei Beurlaubten im 1. Hochschulsemester stehen fehlerhafte Angaben bei der Anzahl der Urlaubssemester");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_066M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_066M");
+ fehler.setFehlertextKurz("Bei Beurlaubten fehlt die Anzahl der Urlaubssemester");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_069K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_069K");
+ fehler.setFehlertextKurz("Exmatrikulation im 1. Studiengang");
+ fehler.setFehlertextLang("Exmatrikulation im 1. Studiengang und im 2. Studiengang wurde Erst-, Neueinschreibung, Rückmeldung oder Beurlaubung angegeben");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_072M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_072M");
+ fehler.setFehlertextKurz("Art der Einschreibung stimmt nicht mit den Angaben zum Studium im vorhergehenden Semester überein.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_075M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_075M");
+ fehler.setFehlertextKurz("Falscher Hochschulschlüssel bei Hochschule im vorhergehenden Semester");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_078M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_078M");
+ fehler.setFehlertextKurz("Fernstudium an Hochschulen, wo dies nicht möglich ist");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_084M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_084M");
+ fehler.setFehlertextKurz("Art des Studiums im Berichtssemester = Praxissemester und k.A. bei der Anzahl der Praxissemester");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_087K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_087K");
+ fehler.setFehlertextKurz("Anzahl der Unterbrechungssemester ist größer oder gleich der Anzahl der Hochschulsemester");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_090M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_090M");
+ fehler.setFehlertextKurz("Bei Haupt- bzw. Nebenhörern fehlen die Angaben bei Hochschul- und/oder Fachsemestern");
+ fehler.setFehlertextLang("Bei Haupt- bzw. Nebenhörern fehlen die Angaben bei Hochschul- und/oder Fachsemestern (Zweiter Teil der Kontrolle gilt nicht für Niedersachsen, Baden-Württemberg, Bayern und Berlin)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_093K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_093K");
+ fehler.setFehlertextKurz("Angaben einer bereits bestandenen Abschlussprüfung fehlen");
+ fehler.setFehlertextLang("Angaben einer bereits bestandenen Abschlussprüfung fehlen, obwohl ein Abschluss angestrebt wird, der eine andere Prüfung voraussetzt. Bei einem konsekutiven Masterstudium fehlt die bereits bestandene Abschlussprüfung. Teil 3 und 4 für alle Länder außer Nordrhein-Westfalen und Teil 5 und 6 nur für Nordrhein-Westfalen, Teil 7 und 8 nur für Bayern (Für Bayern wird Kontrolle nur durchgeführt bei mindestens 3 Fachsemester).");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_096M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_096M");
+ fehler.setFehlertextKurz("Es wird ein Erststudium angestrebt, obwohl bereits ein Studium bestanden wurde");
+ fehler.setFehlertextLang("Mit Ausnahme des konsekutiven Masterstudiums wird ein Erststudium angestrebt, obwohl bereits ein Studium bestanden wurde. Teil 3 und 4 dieser Prüfung gilt nur für Bayern, Teil 5 und 6 gilt für Niedersachsen,Berlin und Brandenburg (ab WS 2009 nur noch für Niedersachsen), Teil 7 und 8 für Nordrhein-Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_099K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_099K");
+ fehler.setFehlertextKurz("Eine bereits bestandene Lehramtsprüfung wird erneut angestrebt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_102M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_102M");
+ fehler.setFehlertextKurz("Gleiche Angaben im 1. und 2. Studiengang");
+ fehler.setFehlertextLang("Der angestrebte Abschluss und das 1. Studienfach des 1. Studienganges sind gleich dem angestrebten Abschluss und dem 1. Studienfach des 2. Studienganges. Diese Kontrolle wird in allen Ländern (ausser Rheinland-Pfalz) nicht für das Studienfach Instrumentalmusik durchgeführt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_105M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_105M");
+ fehler.setFehlertextKurz("Studiengang im Berichtssemester und bereits vor dem Berichtssemester abgelegten Prüfung sind gleich");
+ fehler.setFehlertextLang("Der angestrebte Abschluß (mit Ausnahme einer Abschlußprüfung im Ausland) und das 1. Studienfach des 1. bzw. 2. Studienganges sind gleich dem 1. bzw. 2. Studiengang einer bereits vor dem Berichtssemester abgelegten Prüfung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_108K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_108K");
+ fehler.setFehlertextKurz("Gleiche Fächer mehrmals innerhalb eines Studienganges oder Studienabschlusses");
+ fehler.setFehlertextLang("Innerhalb eines Studienganges bzw. eines Studienabschlusses kommen die gleichen Fächer mehrmals vor (mit Ausnahme von Magister- und Promotionsabschlüssen)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_114M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_114M");
+ fehler.setFehlertextKurz("Angaben zum Studium in der damaligen DDR unvollständig");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_117M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_117M");
+ fehler.setFehlertextKurz("Unvollständige Angaben im 1. Studiengang des Berichtssemesters");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_120M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_120M");
+ fehler.setFehlertextKurz("Unvollständige Angaben im 2. Studiengang des Berichtssemesters");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_123M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_123M");
+ fehler.setFehlertextKurz("Nebenhörer und keine Angabe bei der Hochschule der Zweiteinschreibung");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_126K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_126K");
+ fehler.setFehlertextKurz("Unvollständige Angaben bei Einschreibung an einer anderen Hochschule");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_129K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_129K");
+ fehler.setFehlertextKurz("Unvollständige Angaben bei Studium im vorhergehenden Semester");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_132K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_132K");
+ fehler.setFehlertextKurz("Unvollständige Angaben bei vor dem Berichtssemester abgelegte Abschlußprüfungen");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_138M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_138M");
+ fehler.setFehlertextKurz("Unvollständige Angaben bei vor dem Berichtssemester abgelegte Abschlußprüfungen");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_141M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_141M");
+ fehler.setFehlertextKurz("Nicht zugelassener 1. Studiengang im Berichtssemester");
+ fehler.setFehlertextLang("im 1. Studiengang des Berichtssemester stimmt die Kombination Berichtsland, Hochschule, Abschlussprüfung und Studienfach nicht mit den Einträgen in der Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein. Teil 2 der Kontrolle gilt nur für Bayern. Hier wird noch die Eingabe im Feld \"vollteildual\" überprüft.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_144M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_144M");
+ fehler.setFehlertextKurz("Nicht zugelassener 2. Studiengang im Berichtssemester");
+ fehler.setFehlertextLang("im 2. Studiengang des Berichtssemester stimmt die Kombination Berichtsland, Hochschule, Abschlussprüfung und Studienfach nicht mit den Einträgen in der Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein. Teil 2 der Kontrolle gilt nur für Bayern. Hier wird noch die Eingabe im Feld \"vollteildual\" überprüft.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_147M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_147M");
+ fehler.setFehlertextKurz("Nicht zugelassener Studiengang bei Einschreibung an anderer Hochschule");
+ fehler.setFehlertextLang("Bei Einschreibung an anderer Hochschule stimmt die Kombination Berichtsland, Hochschule, Abschlussprüfung und Studienfach nicht mit den Einträgen in der Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein. Diese Kontrolle wird nur durchgeführt wenn die Hochschule der weiteren Einschreibung im Berichtsland liegt.Kontrolle gilt nicht für Berlin, Bayern und Sachsen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_150K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_150K");
+ fehler.setFehlertextKurz("Nicht zugelassener 1. Studiengang im vorhergehenden Semester");
+ fehler.setFehlertextLang("Bei 1. Studiengang im vorhergehenden Semester stimmt die Kombination Berichtsland, Hochschule, Abschlussprüfung und Studienfach nicht mit den Einträgen in der Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein. Diese Kontrolle wird nur durchgeführt wenn die Hochschule im vorhergehenden Semester im Berichtsland liegt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_153K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_153K");
+ fehler.setFehlertextKurz("Nicht zugelassener 2. Studiengang im vorhergehenden Semester");
+ fehler.setFehlertextLang("Bei 2. Studiengang im vorhergehenden Semester stimmt die Kombination Berichtsland, Hochschule, Abschlussprüfung und Studienfach nicht mit den Einträgen in der Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein. Diese Kontrolle wird nur durchgeführt wenn die Hochschule im vorhergehenden Semester im Berichtsland liegt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_156M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_156M");
+ fehler.setFehlertextKurz("Nicht zugelassenes Studium im 1. Studienfach bei den seit der letzten Semestermeldung abgeschlossenen Prüfung(en)");
+ fehler.setFehlertextLang("Bei der 1. Prüfung bei der seit der letzten Semestermeldung abgeschlossenen Prüfung(en) stimmt die Kombination Berichtsland, Hochschule ( 2. bis 5. Stelle des Prüfungsamtes), Abschlussprüfung und Studienfach nicht mit den Einträgen in der Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein. Es werden auch die zulässigen Studiengänge der Prüfungsämter überprüft.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_159M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_159M");
+ fehler.setFehlertextKurz("Nicht zugelassenes Studium im 1. Studienfach bei den seit der letzten Semestermeldung abgeschlossenen Prüfung(en)");
+ fehler.setFehlertextLang("Bei der 2. Prüfung bei der seit der letzten Semestermeldung abgeschlossenen Prüfung(en) stimmt die Kombination Berichtsland, Hochschule ( 2. bis 5. Stelle des Prüfungsamtes), Abschlussprüfung und Studienfach nicht mit den Einträgen in der Schlüsseltabelle STUDIENFACHMERKMALSKOMBINATION überein. Es werden auch die zulässigen Studiengänge der Prüfungsämter überprüft.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_162K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_162K");
+ fehler.setFehlertextKurz("Bereits vor dem Berichtssemester abgelegte Prüfung gleich einer seit der letzten Semestermeldung abgeschlossenen Prüfung");
+ fehler.setFehlertextLang("Mit Ausnahme eines Freiversuchs ist eine bereits vor dem Berichtssemester abgelegte Prüfung gleich einer seit der letzten Semestermeldung abgeschlossenen Prüfung(en)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_165M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_165M");
+ fehler.setFehlertextKurz("Falsche Signatur bei Hochschule (EF4)");
+ fehler.setFehlertextLang("Bei Datensätzen ohne Studententeil ist die Kombination Berichtsland und zuletzt besuchte Hochschule laut Schlüsseltabelle HOCHSCHULFACHBEREICH in Kombination mit Schlüsseltabelle HOCHSCHULSTANDORT nicht zulässig. Ausnahme Hochschule 9000 (Sonstige deutsche Hochschule) und 9990 (Hochschule im Ausland)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_168K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_168K");
+ fehler.setFehlertextKurz("Studiengang im Berichtssemester gleich einer seit der letzten Semestermeldung abgeschlossenen Prüfung");
+ fehler.setFehlertextLang("Mit Ausnahme einer angestrebten Prüfungswiederholung zur Notenverbesserung ist ein Studiengang im Berichtssemester gleich einer seit der letzten Semestermeldung abgeschlossenen Prüfung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_171M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_171M");
+ fehler.setFehlertextKurz("Angerechnete Fachsemester grösser als Fachsemetser insgesamt");
+ fehler.setFehlertextLang("Die Anzahl der angerechneten Fachsemester für die 1. Prüfung ist größer als die Anzahl der Fachsemester insgesamt für diese Prüfung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_174K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_174K");
+ fehler.setFehlertextKurz("Angerechnete Fachsemester gleich Fachsemetser insgesamt");
+ fehler.setFehlertextLang("Die Anzahl der angerechneten Fachsemester für die 1. Prüfung ist gleich der Anzahl der Fachsemester insgesamt für diese Prüfung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_177M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_177M");
+ fehler.setFehlertextKurz("Angerechnete Fachsemester grösser als Fachsemetser insgesamt");
+ fehler.setFehlertextLang("Die Anzahl der angerechneten Fachsemester für die 2. Prüfung ist größer als die Anzahl der Fachsemester insgesamt für diese Prüfung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_180K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_180K");
+ fehler.setFehlertextKurz("Angerechnete Fachsemester gleich Fachsemetser insgesamt");
+ fehler.setFehlertextLang("Die Anzahl der angerechneten Fachsemester für die 2. Prüfung ist gleich der Anzahl der Fachsemester insgesamt für diese Prüfung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_183M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_183M");
+ fehler.setFehlertextKurz("Die Summe aus angerechnete Fachsemester und Auslandsstudium ist größer Fachsemester insgesamt");
+ fehler.setFehlertextLang("Die Anzahl der angerechneten Fachsemester aus einem anderen Studiengang an einer deutschen Hochschule und aus einem Auslandsstudium ist größer als die Anzahl der angerechneten Fachsemester insgesamt. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_186M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_186M");
+ fehler.setFehlertextKurz("Anzahl der Fachsemester aus berufspraktischer Tätigkeit ist größer Fachsemester insgesamt");
+ fehler.setFehlertextLang("Die Anzahl der angerechneten Fachsemester aus einer berufspraktischen Tätigkeit vor der Einschreibung im Studiengang der Prüfung ist größer als die Anzahl der angerechneten Fachsemester insgesamt");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_189K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_189K");
+ fehler.setFehlertextKurz("Der Student war bei Erwerb der Hochschulzugangsberechtigung zwischen 11 und 16 Jahre alt");
+ fehler.setFehlertextLang("Der Student war bei Erwerb der Hochschulzugangsberechtigung zwischen 11 und 16 Jahre alt. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_191M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_191M");
+ fehler.setFehlertextKurz("Bei Studienbeginn war der Student jünger als 11 Jahre");
+ fehler.setFehlertextLang("Bei Studienbeginn war der Student jünger als 11 Jahre. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_194K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_194K");
+ fehler.setFehlertextKurz("Bei Studienbeginn war der Student zwischen 11 - 16 Jahre alt");
+ fehler.setFehlertextLang("Bei Studienbeginn war der Student zwischen 11 - 16 Jahre alt . Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_197M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_197M");
+ fehler.setFehlertextKurz("Bei der Ersteinschreibung war der Student jünger als 11 Jahre.");
+ fehler.setFehlertextLang("Bei der Ersteinschreibung war der Student jünger als 11 Jahre. An der Palucca Schule Dresden war der Student bei der Ersteinschreibung jünger als 10 Jahre.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_200K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_200K");
+ fehler.setFehlertextKurz("Bei der Ersteinschreibung war der Student zwischen 11 und 16 Jahre alt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_203M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_203M");
+ fehler.setFehlertextKurz("Der Student war bei Erwerb der Hochschulzugangsberechtigung jünger als 11 Jahre");
+ fehler.setFehlertextLang("Der Student war bei Erwerb der Hochschulzugangsberechtigung jünger als 11 Jahre. An der Palucca Schule Dresden war der Student bei Erwerb der Hochschulzugangsberechtigung jünger als 10 Jahre.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_206K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_206K");
+ fehler.setFehlertextKurz("Hochschulsemester minus Urlaubssemester plus Auslandssemester ist kleiner Anzahl Fachsemester.");
+ fehler.setFehlertextLang("Hochschulsemester minus Urlaubssemester plus Auslandssemester ist kleiner Anzahl Fachsemester. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_209M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_209M");
+ fehler.setFehlertextKurz("Art der HZB Abschluß oder Zwischenprüfung an einer FH und weniger als 4 Hochschulsemester");
+ fehler.setFehlertextLang("Bei den Berechtigungen zum Hochschulstudium Abschluß oder Zwischenprüfung an einer FH sind weniger als 4 Hochschulsemester angegeben. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden. Teil 2 der Kontrolle gilt nur für Bayern.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_211K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_211K");
+ fehler.setFehlertextKurz("Das Jahr der HZB ist größer als das Berichtsjahr minus Hochschul- und minus Auslandssemester.");
+ fehler.setFehlertextLang("Das Jahr der HZB ist größer als das Berichtsjahr minus Hochschul- und minus Auslandssemester. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden (Kontrolle gilt nicht für Bayern).");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_214K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_214K");
+ fehler.setFehlertextKurz("Art der HZB Abschluß oder Zwischenprüfung an einer FH und keine bereits bestandene Prüfung.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_217M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_217M");
+ fehler.setFehlertextKurz("Jahr der Prüfung kleiner gleich Jahr der Ersteinschreibung");
+ fehler.setFehlertextLang("Bei einer bereits abgelegten Abschlußprüfung (ohne Früheres Studium im Ausland und dem Abschluss an einer Berufsakademie) ist das Jahr der Prüfung kleiner oder gleich dem Jahr der Ersteinschreibung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_220M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_220M");
+ fehler.setFehlertextKurz("Das Jahr der letzten Prüfung liegt vor dem Jahr der vorletzten Prüfung");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_223K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_223K");
+ fehler.setFehlertextKurz("Bereits bestandene Abschlußprüfung und weniger als 4 Hochschulsemester");
+ fehler.setFehlertextLang("Bei einer bereits bestandenen Abschlußprüfung ist die Anzahl der Hochschulsemester aus der Berechnung (Hochschulsemester - Urlaubssemester + Auslandssemester) kleiner 4. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_226K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_226K");
+ fehler.setFehlertextKurz("Bei einer bereits abgelegten Abschlußprüfung war der Student jünger als 18 Jahre.");
+ fehler.setFehlertextLang("Bei einer bereits abgelegten Abschlußprüfung war der Student jünger als 18 Jahre. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_229M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_229M");
+ fehler.setFehlertextKurz("Der Zeitpunkt der letzten vor dem Berichtssem. abgelegten Prüfung ist später als das Berichtssemester");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_231M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_231M");
+ fehler.setFehlertextKurz("Vor dem Berichtssemester abgelegte Prüfung ist gleich oder später als das Berichtssemester");
+ fehler.setFehlertextLang("Der Zeitpunkt der letzten vor dem Berichtssemester abgelegten Prüfung ist gleich oder später als das Berichtssemester");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_237M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_237M");
+ fehler.setFehlertextKurz("Vorletzte vor dem Berichtssemester abgelegte Prüfung ist gleichoder später als das Berichtssememester");
+ fehler.setFehlertextLang("Der Zeitpunkt der vorletzten vor dem Berichtssemester abgelegten Prüfung ist gleich oder später als das Berichtssemester");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_243M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_243M");
+ fehler.setFehlertextKurz("Der Zeitpunkt der 1. Prüfung ist später als der Berichtszeitraum.");
+ fehler.setFehlertextLang("Der Zeitpunkt der 1. Prüfung ist später als der Berichtszeitraum. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_251M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_251M");
+ fehler.setFehlertextKurz("Der Zeitpunkt der 2. Prüfung ist später als der Berichtszeitraum.");
+ fehler.setFehlertextLang("Der Zeitpunkt der 2. Prüfung ist später als der Berichtszeitraum. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_260M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_260M");
+ fehler.setFehlertextKurz("Die Daten des 1. und 2. Studiengangs sind identisch");
+ fehler.setFehlertextLang("Bei nicht Lehramt ist der angestrebte Abschluß und das 1. Studienfach des 1. Studienganges gleich den entsprechenden Angaben des 2. Studienganges ODER bei Lehramtsprüfungen ist die Hochschule, angestrebter Abschluß und 1. Studienfach des 1. Studienganges gleich den entsprechenden Angaben des 2. Studienganges.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_263M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_263M");
+ fehler.setFehlertextKurz("Gleiche Angaben bei der letzten und vorletzten Prüfung");
+ fehler.setFehlertextLang("Bei einer bereits vor dem Berichtssemester abgelegte Abschlußprüfung ist die Prüfungsart und 1. Studienfach der letzten Prüfung sind gleich den entsprechenden Angaben der vorletzten Prüfung. Ab SS 2008 werden bei gleichem Abschluss alle Studienfächer miteinander verglichen. Dies gilt nicht für die Länder Niedersachsen, Nordrhein-Westfalen und Sachsen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_266M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_266M");
+ fehler.setFehlertextKurz("Gleiche Angaben der der 1. und 2. Prüfung");
+ fehler.setFehlertextLang("Bei seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung ist die Prüfungsart und 1. Studienfach der 1. Prüfung sind gleich den entsprechenden Angaben der 2. Prüfung");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_269M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_269M");
+ fehler.setFehlertextKurz("Alle Eingabefelder ausser Ordnungsbegriff, Geschlecht Geburtsdatum und Staat sind leer");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_271M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_271M");
+ fehler.setFehlertextKurz("Unvollständige Angaben bei Seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung(en)");
+ fehler.setFehlertextLang("Unvollständige Angaben bei Seit der letzten Semestermeldung insgesamt abgeschlossene Prüfung(en). TEIL 2 und TEIL 3 der Kontrolle (Einbeziehung des Prüfungsamtes) gilt nur für Bayern, Sachsen und Nordrhein-Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_274M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_274M");
+ fehler.setFehlertextKurz("Prüfungsergebnis und Gesamtnote der letzten und/oder vorletzten Abschlußprüfung stimmen nicht überein");
+ fehler.setFehlertextLang("Prüfungsergebnis und Gesamtnote der bereits vor dem Berichtssemester abgelegten letzten und/oder vorletzten Abschlußprüfung stimmen nicht überein.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_277M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_277M");
+ fehler.setFehlertextKurz("Prüfungsergebnis und Gesamtnote der seit der letzten Semestermeldung abgeschlossenen Prüfung(en) stimmen nicht überein");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_283M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_283M");
+ fehler.setFehlertextKurz("Prüfungsergebnis und Jahr der Ersteinschreibung vorhanden und Angabe zum Semester fehlt");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_286M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_286M");
+ fehler.setFehlertextKurz("Die Anzahl der angegebenen Hochschulsemester ist größer als seit der Ersteinschreibung möglich.");
+ fehler.setFehlertextLang("Die Anzahl der angegebenen Hochschulsemester ist größer als seit der Ersteinschreibung möglich. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden. Diese Kontrolle wird nicht für die Bundeswehrhochschule München ( Signatur 0811 und 0812) und für einen bestimmten Studiengang der FH Nürnberg (Signatur 7250) durchgeführt.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_289K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_289K");
+ fehler.setFehlertextKurz("Die Anzahl der Fachsemester ist größer 35");
+ fehler.setFehlertextLang("Anzahl der Urlaubssemester, Unterbrechungssemester oder Fachsemester sind größer 35.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_292M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_292M");
+ fehler.setFehlertextKurz("Unplausible Angaben zwischen Art und Land des Erwerbs der HZB");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_295M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_295M");
+ fehler.setFehlertextKurz("Die Differenz zwischen Anzahl der Fachsemester und Anzahl der Hochschulsemester ist größer 10");
+ fehler.setFehlertextLang("Die Differenz zwischen Anzahl der Fachsemester und Anzahl der Hochschulsemester ist größer 10. Somit müsstem mehr als 10 anrechenbare Fachsemester voliegen). Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_296M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_296M");
+ fehler.setFehlertextKurz("Anzahl der Urlaubssemester (EF20) ist größer als Anzahl der Hochschulsemester (EF19)");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_298M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_298M");
+ fehler.setFehlertextKurz("Es liegen keine Semesterangaben bei der seit der letzten Meldung abgeschlossenen Prüfung vor");
+ fehler.setFehlertextLang("Bei der seit der letzten Semestermeldung abgeschlossenen Prüfung(en) in einem Erst- und oder Zweitstudium liegen keine Semesterangaben vor (Kontrolle gilt nicht für Brandenburg)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_301K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_301K");
+ fehler.setFehlertextKurz("Bei der seit der letzten Semestermeldung abgeschlossenen Prüfung sind die fachsemesterangaben zu niederig");
+ fehler.setFehlertextLang("Bei der seit der letzten Semestermeldung abgeschlossenen Prüfung(en) in einem Erst- und oder Zweitstudium liegen zu niedrige Fachsemesterangaben vor.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_307M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_307M");
+ fehler.setFehlertextKurz("Bei Freiversuch widersprüchliche Angaben bei Art der Prüfung bzw. Prüfungsergebnis");
+ fehler.setFehlertextLang("Fehlerbedingung 3 und 4 nur für Rheinland-Pfalz");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_310M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_310M");
+ fehler.setFehlertextKurz("Weiterstudium zur Verbesserung der Prüfungsnote und keine bzw. fehlerhafte Angaben.");
+ fehler.setFehlertextLang("Weiterstudium zur Verbesserung der Prüfungsnote und keine bzw. fehlerhafte Angaben bei vor dem Berichtssemester abgelegte Prüfung(en) (Kontrolle gilt nicht für Baden-Württemberg)");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_313M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_313M");
+ fehler.setFehlertextKurz("Erstimmatrikuliert und Angaben bei seit der letzten Semestermeldung abgeschlossene Prüfung(en)");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_316M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_316M");
+ fehler.setFehlertextKurz("Gleiche Lehramtsprüfung im 1. u. 2.Studiengang des Berichtssemesters");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_319M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_319M");
+ fehler.setFehlertextKurz("Gleiche Lehramtsprüfung bei vor dem Berichtssemester abgelegte Abschlußprüfung");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_322M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_322M");
+ fehler.setFehlertextKurz("Gleiche Lehramtsprüfung bei seit der letzten Semestermeldung abgelegte Abschlußprüfung");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_325M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_325M");
+ fehler.setFehlertextKurz("Fehlerhafte Angaben beim Studium im unmittelbar vorhergehenden Semester");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_328K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_328K");
+ fehler.setFehlertextKurz("Nicht zugelassenes Studium im 2. und 3. Studienfach (1. Prüfung)");
+ fehler.setFehlertextLang("Nicht zugelassenes Studium im 2. und 3. Studienfach bei den seit der letzten Semestermeldung abgeschlossenen Prüfung(en) (1. Prüfung). Diese Kontrolle gilt nicht für Nordrhein-Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_331K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_331K");
+ fehler.setFehlertextKurz("Nicht zugelassenes Studium im 2. und 3. Studienfach (2. Prüfung)");
+ fehler.setFehlertextLang("Nicht zugelassenes Studium im 2. und 3. Studienfach bei den seit der letzten Semestermeldung abgeschlossenen Prüfung(en) (2. Prüfung). Diese Kontrolle gilt nicht für Nordrhein-Westfalen.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_334K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_334K");
+ fehler.setFehlertextKurz("Bei Prüfungsabschluß an einer Kunsthochschule war der/die Absolvent(in) im Alter von 15-18 Jahren.");
+ fehler.setFehlertextLang("Bei Prüfungsabschluß an einer Kunsthochschule war der/die Absolvent(in) im Alter von 15-18 Jahren. Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_337K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_337K");
+ fehler.setFehlertextKurz("Die Ersteinschreibung liegt vor dem Jahr des Erwerbs der Hochschulzugangsberechtigung");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_340K".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_340K");
+ fehler.setFehlertextKurz("Berechnung aus Hochschul- Urlaubs- und Auslandssemetser kleiner als Fachsemester");
+ fehler.setFehlertextLang("Anzahl Hochschulsemester minus Urlaubssemester plus Auslandssemester sind kleiner als Anzahl der Fachsemester der zuletzt abgelegten Abschlußprüfung(en). Hierbei müssen vorab alle benötigten Felder mit denen gerechnet wird auf numerischen Inhalt geprüft werden.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(2);
+ return fehler;
+ }
+ if ("UF_343M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_343M");
+ fehler.setFehlertextKurz("Nicht zulässige Abschlußarten bei seit der letzten Meldung abgelegten Abschlussprüfung(en)");
+ fehler.setFehlertextLang("Bei der/den seit der letzten Semestermeldung abgelegten Abschlußprüfung(en) stehen nicht zulässige Abschlußarten");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_346M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_346M");
+ fehler.setFehlertextKurz("Die nur bei Staats- und Magisterprüfungen zulässige Gesamtnote 7 kommt auch bei anderen Abschlüssen vor");
+ fehler.setFehlertextLang("Die nur bei Staats- und Magisterprüfungen zulässige Gesamtnote 7 kommt auch bei anderen Abschlüssen vor. In Bayern ist die Gesamtnote 7 auch bei Abschluss \"88\" Master an Universitäten (Abschluss vorausgestzt) zulässig.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("UF_349M".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("UF_349M");
+ fehler.setFehlertextKurz("Der/die Absolvent(in) ist jünger als 15 bzw. 20 Jahre");
+ fehler.setFehlertextLang("Bei bestandener Prüfung an einer Kunsthochschule war der/die Absolvent(in) jünger als 15 Jahre oder bei Prüfungsabschluß (ohne Kunsthochschulen) war der/die Absolvent(in) jünger als 20 Jahre.");
+ fehler.setFehlerKorrekturhinweis("");
+ fehler.setFehlerGewicht(1);
+ fehler.setReferenzTB("T_Studenten_Pruefungen");
+ fehler.setFehlerArt(1);
+ return fehler;
+ }
+ if ("M_01stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_01stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(1);
+ fehler.setMerkmalsbezeichnung("M_01stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_02stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_02stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(2);
+ fehler.setMerkmalsbezeichnung("M_02stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_03stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_03stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(3);
+ fehler.setMerkmalsbezeichnung("M_03stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_04stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_04stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(4);
+ fehler.setMerkmalsbezeichnung("M_04stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_05stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_05stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(5);
+ fehler.setMerkmalsbezeichnung("M_05stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_06stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_06stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(6);
+ fehler.setMerkmalsbezeichnung("M_06stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_07stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_07stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(7);
+ fehler.setMerkmalsbezeichnung("M_07stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_08stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_08stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(8);
+ fehler.setMerkmalsbezeichnung("M_08stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_100stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_100stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(100);
+ fehler.setMerkmalsbezeichnung("M_100stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ if ("M_12stelligesFeldAlphanummerisch".equals(key))
+ {
+ PlausiFehler fehler = new PlausiFehler();
+ fehler.setFehlerSchluessel("M_12stelligesFeldAlphanummerisch");
+ fehler.setFehlertextKurz("Ihre Eingabe ist unzulässig.");
+ fehler.setFehlertextLang("");
+ fehler.setFehlerKorrekturhinweis("Korrigieren Sie bitte Ihre Angabe.");
+ fehler.setFehlerGewicht(9);
+ fehler.setReferenzTB("Merkmalpruefung");
+ fehler.setFehlerArt(1);
+ fehler.setMerkmalstyp(PlausiFehler.TYP_ZEICHENKETTE);
+ fehler.setWertlaenge(12);
+ fehler.setMerkmalsbezeichnung("M_12stelligesFeldAlphanummerisch");
+ return fehler;
+ }
+ throw new IllegalArgumentException("Ungueltiger Pruefschluessel " + key);
+ }
+
+ public String[] getPlausiFehlerIds(String ablauf)
+ {
+ if ("Ablauf_Studenten_Pruefungen".equals(ablauf))
+ {
+ java.util.Vector ids = new java.util.Vector();
+ ids.add("#LAND_000");
+ ids.add("#LAND_000K");
+ ids.add("#LAND_001");
+ ids.add("#LAND_002");
+ ids.add("#LAND_003");
+ ids.add("#LAND_008");
+ ids.add("#LAND_009");
+ ids.add("#LAND_006");
+ ids.add("#LAND_007");
+ ids.add("#LAND_004");
+ ids.add("#LAND_005");
+ ids.add("#LAND_010");
+ ids.add("#LAND_012");
+ ids.add("#LAND_013");
+ ids.add("#LAND_014");
+ ids.add("#LAND_015");
+ ids.add("#LAND_016");
+ ids.add("#LAND_017");
+ ids.add("#MA_003");
+ ids.add("#MA_006");
+ ids.add("#MA_009");
+ ids.add("#MA_012");
+ ids.add("#MA_015");
+ ids.add("EF16#MA_018");
+ ids.add("EF17#MA_021");
+ ids.add("EF18#MA_024");
+ ids.add("#MA_027");
+ ids.add("EF16#MA_030");
+ ids.add("EF16#MA_033");
+ ids.add("EF44#MA_036");
+ ids.add("EF41#MA_039");
+ ids.add("#MA_042");
+ ids.add("EF43#MA_045");
+ ids.add("#MA_048");
+ ids.add("#MA_051");
+ ids.add("#MA_054");
+ ids.add("#MA_057");
+ ids.add("#MA_060");
+ ids.add("#MA_063");
+ ids.add("#MA_066");
+ ids.add("EF30#MA_069");
+ ids.add("EF45#MA_072");
+ ids.add("#MA_075");
+ ids.add("#MA_078");
+ ids.add("#MA_081");
+ ids.add("#MA_084");
+ ids.add("#MA_087");
+ ids.add("EF64#MA_090");
+ ids.add("#MA_093");
+ ids.add("#MA_096");
+ ids.add("#MA_099");
+ ids.add("#MA_102");
+ ids.add("#MA_105");
+ ids.add("#MA_108");
+ ids.add("#MA_111");
+ ids.add("#MA_114");
+ ids.add("#MA_115");
+ ids.add("#MA_116");
+ ids.add("#MA_117");
+ ids.add("#MA_118");
+ ids.add("#MA_119");
+ ids.add("#MA_120");
+ ids.add("#MA_121");
+ ids.add("#MA_122");
+ ids.add("#MA_123");
+ ids.add("EF66#MA_124");
+ ids.add("EF74#MA_127");
+ ids.add("EF66#MA_129");
+ ids.add("EF74#MA_132");
+ ids.add("#MA_135");
+ ids.add("#MA_138");
+ ids.add("#MA_141");
+ ids.add("#MA_144");
+ ids.add("#MA_147");
+ ids.add("#MA_150");
+ ids.add("#MA_153");
+ ids.add("#MA_154");
+ ids.add("#MA_156");
+ ids.add("#MA_159");
+ ids.add("#MA_160");
+ ids.add("#MA_161");
+ ids.add("EF99#MA_162");
+ ids.add("EF108#MA_165");
+ ids.add("#MA_168");
+ ids.add("EF135#MA_169");
+ ids.add("EF151#MA_170");
+ ids.add("#MA_171");
+ ids.add("#MA_172");
+ ids.add("#MA_174");
+ ids.add("#MA_177");
+ ids.add("#MA_180");
+ ids.add("#MA_183");
+ ids.add("#MA_186");
+ ids.add("#MA_189");
+ ids.add("#MA_192");
+ ids.add("#MA_201");
+ ids.add("#MA_204");
+ ids.add("#MA_207");
+ ids.add("#MA_210");
+ ids.add("#MA_213");
+ ids.add("#MA_216");
+ ids.add("#MA_217");
+ ids.add("EF110#MA_219");
+ ids.add("EF110#MA_220");
+ ids.add("#MA_222");
+ ids.add("#MA_225");
+ ids.add("EF99#MA_228");
+ ids.add("EF99#MA_229");
+ ids.add("EF108#MA_231");
+ ids.add("EF108#MA_232");
+ ids.add("EF135#MA_234");
+ ids.add("EF135#MA_235");
+ ids.add("EF151#MA_237");
+ ids.add("EF151#MA_238");
+ ids.add("#MA_240");
+ ids.add("#MA_243");
+ ids.add("#SIG_001");
+ ids.add("EF7#SIG_003");
+ ids.add("EF8U1#SIG_006");
+ ids.add("EF8U2#SIG_009");
+ ids.add("EF9#SIG_012");
+ ids.add("EF4#SIG_015");
+ ids.add("EF10U1#MA_246");
+ ids.add("EF10U1#SIG_021");
+ ids.add("EF10U2#MA_248");
+ ids.add("EF10U2#SIG_027");
+ ids.add("EF11U1#MA_250");
+ ids.add("EF11U1#SIG_033");
+ ids.add("EF11U2#MA_252");
+ ids.add("EF11U2#SIG_039");
+ ids.add("EF12#MA_254");
+ ids.add("EF16#SIG_045");
+ ids.add("EF17#SIG_048");
+ ids.add("EF18#SIG_051");
+ ids.add("EF19#SIG_054");
+ ids.add("EF20#SIG_058");
+ ids.add("EF21#SIG_060");
+ ids.add("EF22#SIG_063");
+ ids.add("EF23#SIG_066");
+ ids.add("EF24#SIG_069");
+ ids.add("EF25#SIG_072");
+ ids.add("EF26#SIG_075");
+ ids.add("EF27#SIG_078");
+ ids.add("EF28#SIG_081");
+ ids.add("EF29#MA_256");
+ ids.add("EF30#SIG_087");
+ ids.add("EF31#SIG_090");
+ ids.add("EF31#SIG_093");
+ ids.add("EF32#SIG_096");
+ ids.add("EF32#SIG_099");
+ ids.add("EF34#SIG_102");
+ ids.add("EF36#SIG_105");
+ ids.add("EF41#SIG_108");
+ ids.add("EF42#SIG_111");
+ ids.add("EF43#SIG_114");
+ ids.add("EF44#SIG_117");
+ ids.add("EF45#SIG_120");
+ ids.add("EF46#SIG_123");
+ ids.add("EF47#SIG_126");
+ ids.add("EF49#SIG_129");
+ ids.add("EF51#SIG_132");
+ ids.add("EF56#SIG_135");
+ ids.add("EF59#SIG_138");
+ ids.add("EF60#SIG_141");
+ ids.add("EF61#SIG_144");
+ ids.add("EF62#SIG_147");
+ ids.add("EF64#SIG_150");
+ ids.add("EF65U1#SIG_153");
+ ids.add("EF66#SIG_156");
+ ids.add("EF69#SIG_159");
+ ids.add("EF70#SIG_162");
+ ids.add("EF71#SIG_165");
+ ids.add("EF72#SIG_168");
+ ids.add("EF74#SIG_171");
+ ids.add("EF77#SIG_174");
+ ids.add("EF78#SIG_177");
+ ids.add("EF79#SIG_180");
+ ids.add("EF80#SIG_183");
+ ids.add("EF82#SIG_186");
+ ids.add("EF83#SIG_189");
+ ids.add("EF85#SIG_192");
+ ids.add("EF86#SIG_195");
+ ids.add("EF91#SIG_198");
+ ids.add("EF92#SIG_201");
+ ids.add("EF93#SIG_204");
+ ids.add("EF94#SIG_207");
+ ids.add("EF96#SIG_210");
+ ids.add("EF97#SIG_213");
+ ids.add("EF98#SIG_216");
+ ids.add("EF99#SIG_219");
+ ids.add("EF100#SIG_222");
+ ids.add("EF101#SIG_225");
+ ids.add("EF102#SIG_228");
+ ids.add("EF103#SIG_231");
+ ids.add("EF105#SIG_234");
+ ids.add("EF106#SIG_237");
+ ids.add("EF107#SIG_240");
+ ids.add("EF108#SIG_243");
+ ids.add("EF109#SIG_246");
+ ids.add("EF110#SIG_249");
+ ids.add("EF111U1#SIG_255");
+ ids.add("EF111U2#SIG_261");
+ ids.add("EF112#SIG_264");
+ ids.add("EF113#SIG_267");
+ ids.add("EF120#SIG_270");
+ ids.add("EF120#SIG_273");
+ ids.add("EF120#SIG_276");
+ ids.add("EF121#SIG_279");
+ ids.add("EF122#SIG_282");
+ ids.add("EF123#SIG_285");
+ ids.add("EF124#SIG_288");
+ ids.add("EF125#SIG_291");
+ ids.add("EF126#SIG_294");
+ ids.add("EF127#SIG_297");
+ ids.add("EF152#SIG_300");
+ ids.add("EF152#SIG_303");
+ ids.add("EF128#SIG_306");
+ ids.add("EF129#SIG_309");
+ ids.add("EF132#SIG_312");
+ ids.add("EF133#SIG_315");
+ ids.add("EF134#SIG_318");
+ ids.add("EF135#SIG_321");
+ ids.add("EF136#SIG_324");
+ ids.add("EF136#SIG_327");
+ ids.add("EF136#SIG_330");
+ ids.add("EF137#SIG_333");
+ ids.add("EF138#SIG_336");
+ ids.add("EF139#SIG_339");
+ ids.add("EF140#SIG_342");
+ ids.add("EF141#SIG_345");
+ ids.add("EF142#SIG_348");
+ ids.add("EF143#SIG_351");
+ ids.add("EF144#SIG_354");
+ ids.add("EF145#SIG_357");
+ ids.add("EF148#SIG_360");
+ ids.add("EF149#SIG_363");
+ ids.add("EF150#SIG_366");
+ ids.add("EF151#SIG_369");
+ ids.add("#UF_003K");
+ ids.add("EF10U2#UF_006M");
+ ids.add("EF10U2#UF_009M");
+ ids.add("EF11U2#UF_012M");
+ ids.add("EF11U2#UF_015M");
+ ids.add("EF111U2#UF_018M");
+ ids.add("EF111U2#UF_021M");
+ ids.add("#UF_024K");
+ ids.add("#UF_027M");
+ ids.add("EF31#MA_262");
+ ids.add("#UF_033M");
+ ids.add("#UF_036M");
+ ids.add("#MA_264");
+ ids.add("#UF_042M");
+ ids.add("#UF_045M");
+ ids.add("#UF_048M");
+ ids.add("EF19#UF_051M");
+ ids.add("#UF_054M");
+ ids.add("#UF_057M");
+ ids.add("#UF_060M");
+ ids.add("#UF_063M");
+ ids.add("EF20#UF_066M");
+ ids.add("#UF_069K");
+ ids.add("#UF_072M");
+ ids.add("#UF_075M");
+ ids.add("EF4#UF_078M");
+ ids.add("#MA_266");
+ ids.add("EF21#UF_084M");
+ ids.add("#UF_087K");
+ ids.add("#UF_090M");
+ ids.add("EF91#UF_093K");
+ ids.add("#UF_096M");
+ ids.add("#UF_099K");
+ ids.add("#UF_102M");
+ ids.add("#UF_105M");
+ ids.add("#UF_108K");
+ ids.add("#UF_114M");
+ ids.add("#UF_117M");
+ ids.add("#UF_120M");
+ ids.add("EF56#UF_123M");
+ ids.add("#UF_126K");
+ ids.add("#UF_129K");
+ ids.add("#UF_132K");
+ ids.add("#UF_138M");
+ ids.add("#UF_141M");
+ ids.add("#UF_144M");
+ ids.add("#UF_147M");
+ ids.add("#UF_150K");
+ ids.add("#UF_153K");
+ ids.add("EF127#UF_156M");
+ ids.add("EF143#UF_159M");
+ ids.add("#UF_162K");
+ ids.add("EF4#UF_165M");
+ ids.add("#UF_168K");
+ ids.add("EF122#UF_171M");
+ ids.add("EF122#UF_174K");
+ ids.add("EF138#UF_177M");
+ ids.add("EF138#UF_180K");
+ ids.add("#UF_183M");
+ ids.add("#UF_186M");
+ ids.add("#UF_189K");
+ ids.add("#UF_191M");
+ ids.add("#UF_194K");
+ ids.add("#UF_197M");
+ ids.add("#UF_200K");
+ ids.add("#UF_203M");
+ ids.add("#UF_206K");
+ ids.add("EF19#UF_209M");
+ ids.add("#UF_211K");
+ ids.add("#UF_214K");
+ ids.add("#UF_217M");
+ ids.add("#UF_220M");
+ ids.add("#UF_223K");
+ ids.add("#UF_226K");
+ ids.add("EF97#UF_229M");
+ ids.add("#UF_231M");
+ ids.add("#UF_237M");
+ ids.add("#UF_243M");
+ ids.add("#UF_251M");
+ ids.add("#UF_260M");
+ ids.add("#UF_263M");
+ ids.add("#UF_266M");
+ ids.add("#UF_269M");
+ ids.add("#UF_271M");
+ ids.add("#UF_274M");
+ ids.add("#UF_277M");
+ ids.add("#MA_268");
+ ids.add("EF17#UF_283M");
+ ids.add("EF19#UF_286M");
+ ids.add("#UF_289K");
+ ids.add("#UF_292M");
+ ids.add("#UF_295M");
+ ids.add("#UF_296M");
+ ids.add("#UF_298M");
+ ids.add("#UF_301K");
+ ids.add("#UF_307M");
+ ids.add("#UF_310M");
+ ids.add("#UF_313M");
+ ids.add("#UF_316M");
+ ids.add("#UF_319M");
+ ids.add("#UF_322M");
+ ids.add("#UF_325M");
+ ids.add("#UF_328K");
+ ids.add("#UF_331K");
+ ids.add("#UF_334K");
+ ids.add("#UF_337K");
+ ids.add("#UF_340K");
+ ids.add("#UF_343M");
+ ids.add("#UF_346M");
+ ids.add("#UF_349M");
+ return (String[])ids.toArray(new String[0]);
+ }
+ throw new IllegalArgumentException("Ungueltiger Ablauf " + ablauf);
+ }
+}
\ No newline at end of file
diff --git a/src/de/statspez/plausi/generated/Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN.xml b/src/de/statspez/plausi/generated/Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN.xml
new file mode 100644
index 0000000..3ae20fc
--- /dev/null
+++ b/src/de/statspez/plausi/generated/Plausi_ERHEBUNG_STUDENTEN_PRUEFUNGEN.xml
@@ -0,0 +1,37334 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Feuerstein-T
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 52
+
+
+
+
+
+ Erhebung:109951172105747
+ ERHEBUNG_STUDENTEN_PRUEFUNGEN
+ VIE_Hochschulstatistik_PL.Studenten_Pruefungen
+ de.statspez.material.Erhebung
+ 1
+
+
+
+
+
+
+
+
+
+ Statspez
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 52
+
+
+
+
+
+ Merkmal:109951167120547
+ M_01stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Statspez
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 52
+
+
+
+
+
+ Merkmal:109951167120117
+ M_02stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Statspez
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 52
+
+
+
+
+
+ Merkmal:109951167120549
+ M_03stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Statspez
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 52
+
+
+
+
+
+ Merkmal:109951167120551
+ M_04stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Statspez
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 52
+
+
+
+
+
+ Merkmal:109951167120553
+ M_05stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Becker-M
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 52
+
+
+
+
+
+ Merkmal:109951171627533
+ M_06stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Statspez
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 53
+
+
+
+
+
+ Merkmal:109951167120554
+ M_07stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Statspez
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 53
+
+
+
+
+
+ Merkmal:109951167120555
+ M_08stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Feuerstein-T
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 53
+
+
+
+
+
+ Merkmal:109951167575089
+ M_100stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Becker-M
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 53
+
+
+
+
+
+ Merkmal:109951171631586
+ M_12stelligesFeldAlphanummerisch
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Merkmal
+ 1
+
+
+
+
+
+
+ Ihre Eingabe ist unzulssig.
+
+ Korrigieren Sie bitte Ihre Angabe.
+
+
+
+
+
+
+
+ Becker-M
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 53
+
+
+
+
+
+ Themenbereich:109951171626576
+ Abschluss3steller
+ VIE_Hochschulstatistik_PL
+ de.statspez.material.Themenbereich
+ 1
+
+
+
+
+
+
+
+
+ Becker-M
+
+
+ 2013
+ 02
+ 12
+
+
+ 10
+ 56
+ 53
+
+
+
+
+
+ T B Feld:109951171626579
+ gueltigAbJahr
+ VIE_Hochschulstatistik_PL.Abschluss3steller
+ de.statspez.material.TBFeld
+ 1
+
+
+ Erläuterung zur Abfrage "+m.getName()+"
");
+ buf.append(m.getErlaueterung()+"
");
+ if (m.hasSpaltenExplanations())
+ {
+ buf.append(m.getSpaltenExplanationText());
+ }
+
+ pane.setText(buf.toString());
+ pane.setCaretPosition(0);
+ }
+
+ public void actionPerformed(ActionEvent ae) {
+ print();
+ }
+
+ private void print() {
+ PrinterJob pj = PrinterJob.getPrinterJob();
+ PageFormat pageFormat = pj.defaultPage();
+ pageFormat.setOrientation(java.awt.print.PageFormat.LANDSCAPE);
+
+ // Dialog zur Auswahl des Papierformats
+ pageFormat = pj.pageDialog(pageFormat);
+
+
+
+ // A4 festvorgeben.
+ // Papiergroesse DIN A4, Rand: O + U: 1/2 Inch, L + R: 1/2 Inch
+ // alle angaben in 1/72 Inch
+
+ Paper a4 = new Paper();
+ a4.setSize(21 / 2.54 * 72, 29.7 / 2.54 * 72);
+ a4.setImageableArea(
+ 36,
+ 36,
+ (21 / 2.54 * 72) - 72,
+ (29.7 / 2.54 * 72) - 72);
+
+ pageFormat.setPaper(a4);
+ //ggfs_nurMarkierterBereich(pj,pageFormat);
+
+ pj.setPrintable(pane, pageFormat);
+ //else
+ // pj.setPrintable(tmp_drucktab, pageFormat);
+
+ if (!pj.printDialog())
+ return;
+ try {
+
+ pj.print();
+ } catch (Exception e) {
+ e.printStackTrace();
+
+ }
+ }
+
+}
+
+//Created on 07.04.2005 at 14:32:57
diff --git a/src/de/superx/applet/MaskeninfoElement.java b/src/de/superx/applet/MaskeninfoElement.java
new file mode 100644
index 0000000..1a43394
--- /dev/null
+++ b/src/de/superx/applet/MaskeninfoElement.java
@@ -0,0 +1,360 @@
+package de.superx.applet;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.sql.Date;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.Vector;
+
+import de.memtext.baseobjects.NamedObject;
+import de.memtext.baseobjects.coll.NamedIdObjectSet;
+import de.superx.common.SxResultRow;
+import de.superx.common.XilParser;
+import freemarker.template.TemplateException;
+
+public class MaskeninfoElement extends NamedObject {
+
+ private static final long serialVersionUID = 1L;
+ private Properties xilProps = new Properties();
+ private Vector felderinfos;
+ private Integer tid, breite, hoehe;
+ private NamedIdObjectSet sachgebiete = new NamedIdObjectSet();
+ private boolean isSqlInHeaders = false;
+ private Vector spaltenExplanations; // ,explanationsClone;
+ private String xilPropListString, selectStmt, cleanupStmt, hinweis;
+ private Date stand;
+ private String erlaueterung;
+ private XilParser xilParser = new XilParser();
+ private SxForm maskeForm;
+
+ MaskeninfoElement() {
+
+ }
+
+ public void setMaskeForm(SxForm maskeForm) {
+
+ this.maskeForm = maskeForm;
+ }
+
+ /*
+ * MaskeninfoElement(Vector vectorMaskeninfoEntries) throws IOException {
+ * init(vectorMaskeninfoEntries);
+ * }
+ */
+ /**
+ * fieser Trick: es wird als letztes Element noch ein Vector mit
+ * Spaltenerläuterungen mitgeliefert
+ */
+ protected void init(Vector vectorMaskeninfoEntries) throws IOException {
+ // vector of vector
+ Vector vectorCurrentMask = (Vector) vectorMaskeninfoEntries
+ .elementAt(0);
+
+ setSelectStmt(vectorCurrentMask.elementAt(1));
+
+ setXilPropListString(vectorCurrentMask.elementAt(2));
+
+ setCleanupStmt(vectorCurrentMask.elementAt(3));
+ setBreite((Integer) vectorCurrentMask.elementAt(4));
+
+ setHoehe((Integer) vectorCurrentMask.elementAt(5));
+
+ stand = new java.sql.Date(1);
+ Object tmpDate = vectorCurrentMask.elementAt(6);
+ if (tmpDate != null) {
+ try {
+ // für Informix
+ stand = (java.sql.Date) tmpDate;
+ } catch (ClassCastException e) {
+ // für Access
+ java.sql.Timestamp mytimestamp = (java.sql.Timestamp) tmpDate;
+ long mytimestampwert = mytimestamp.getTime();
+ stand = new java.sql.Date(mytimestampwert);
+ }
+
+ }
+
+ setHinweis(vectorCurrentMask.elementAt(7));
+ setErlaueterung((String) vectorCurrentMask.elementAt(8));
+ // fieser Trick
+ Object expl = vectorCurrentMask.elementAt(9);
+ if (!(expl instanceof SxResultRow)) {
+ String msg = "Es wurde ein ResultRow mit Erläuterungen erwartet (SuperXDBServlet. addExplanations). statt dessen wurde geliefert: ";
+ if (expl == null)
+ msg += "null";
+ else
+ msg += " ein " + expl.getClass() + " :" + expl;
+ throw new IllegalArgumentException(msg);
+ }
+ spaltenExplanations = new Vector();
+ spaltenExplanations
+ .addAll((SxResultRow) vectorCurrentMask.elementAt(9));
+ // cloneExplanations();
+ }
+
+ boolean hasSpaltenExplanations() {
+ boolean result = false;
+ for (Iterator it = spaltenExplanations.iterator(); it.hasNext();) {
+ String expl = (String) it.next();
+ if (expl != null && !expl.trim().equals("")) {
+ result = true;
+ break;
+ }
+ }
+ return result;
+ }
+
+ StringBuffer getSpaltenExplanationText() {
+ StringBuffer buf = new StringBuffer("");
+ for (int i = 0; i < spaltenExplanations.size(); i++) {
+ String expl = (String) spaltenExplanations.get(i);
+ if (expl != null && !expl.trim().equals(""))
+ buf.append(expl + "
");
+ }
+
+ return buf;
+ }
+
+ public void adaptExplanation(int pos, String neu) {
+ if (spaltenExplanations.size() > pos) {
+ String expl = (String) spaltenExplanations.get(pos);
+ if (expl.indexOf("") > -1) {
+ expl = "" + neu
+ + expl.substring(expl.indexOf(""), expl.length());
+ System.out.println("neu:" + expl);
+ spaltenExplanations.setElementAt(expl, pos);
+ }
+ }
+
+ }
+
+ Integer getBreite() {
+ return breite;
+ }
+
+ String getStandString() {
+ String d_str = "";
+ if (getStand() != null)
+ d_str = SxDate.toString(getStand());
+ return d_str;
+ }
+
+ String getCleanupStmt() {
+ return cleanupStmt;
+ }
+
+ String getHinweis() {
+ return hinweis;
+ }
+
+ Integer getHoehe() {
+ return hoehe;
+ }
+
+ String getSelectStmt() {
+ return selectStmt;
+ }
+
+ Date getStand() {
+ return stand;
+ }
+
+ Integer getTid() {
+ return tid;
+ }
+
+ private String getTmpXilPropListString() throws TemplateException,
+ IOException, SQLException {
+
+ String tmpxil = SxUtils.generateSQL(maskeForm, xilPropListString);
+
+
+ tmpxil = SxSQL.templateProcessor.process("XIL-Maske " + getName(),
+ tmpxil,
+
+ maskeForm.getHashMap(getTid()), (String) SxDefaults.getPropertyValue("SxDB"));
+ ByteArrayInputStream bis = new ByteArrayInputStream(tmpxil.getBytes());
+
+ xilProps.load(bis);
+ return tmpxil;
+ }
+
+ void setBreite(Integer integer) {
+ breite = integer;
+ }
+
+ void setCleanupStmt(Object stmt) {
+ if (stmt == null)
+ stmt = "";
+ cleanupStmt = (String) stmt;
+ }
+
+ void setHinweis(Object hin) {
+ hinweis = null;
+ if (hin != null)
+ hinweis = hin.toString();
+ }
+
+ void setHoehe(Integer integer) {
+ hoehe = integer;
+ }
+
+ void setSelectStmt(Object stmt) {
+ if (stmt == null)
+ throw new IllegalArgumentException(
+ "null ist nicht erlaubt für select stmt");
+ selectStmt = (String) stmt;
+ }
+
+ private void setStand(Date date) {
+ stand = date;
+ }
+
+ void setTid(Integer integer) {
+ tid = integer;
+ }
+
+ /**
+ * Hinterlegt die XIL-Proplist. Derzeit vom Applet nicht unterstützte
+ * colspan-Tags \000 werden entfernt
+ *
+ * @param xil
+ */
+ void setXilPropListString(Object xil) {
+ if (xil == null)
+ throw new IllegalArgumentException("null ist nicht erlaubt für xil");
+ StringBuffer buf = new StringBuffer(xil.toString());
+ de.memtext.util.StringUtils.replace(buf, "\\000", "\\n");
+
+ xilPropListString = buf.toString();
+ xilParser.setXilString(xilPropListString);
+ }
+
+ /**
+ * wird nur zum Auslesen des Parameters fixed_columns benötigt
+ *
+ * @return
+ */
+ Properties getXilProps() {
+ return xilProps;
+ }
+
+ Vector getFelderinfos() {
+ return felderinfos;
+ }
+
+ void setFelderinfos(Vector vector) {
+ felderinfos = vector;
+ }
+
+ void clear() {
+ felderinfos = null;
+ tid = breite = hoehe = null;
+ xilPropListString = selectStmt = cleanupStmt = hinweis = null;
+ stand = null;
+ }
+
+ /**
+ * not currently needed
+ *
+ * @throws SQLException
+ */
+ void readSachgebiete() throws SQLException {
+ sachgebiete.clear();
+ SxSQL
+ .executeQuery("select sachgebiete_id from sachgeb_maske_bez where maskeninfo_id="
+ + getTid());
+ Sachgebiet sachgeb;
+ for (Iterator iter = SxSQL.getResultVector().iterator(); iter.hasNext();) {
+ Vector row = (Vector) iter.next();
+ sachgeb = (Sachgebiet) Sachgebiete.getById(row.get(0));
+ sachgebiete.add(sachgeb);
+ }
+ }
+
+ boolean isSqlInHeaders() throws TemplateException, IOException,
+ SQLException {
+ // sets the boolean properly
+ getHeaderVector();
+ return isSqlInHeaders;
+ }
+
+ /**
+ * Gets a Vector with the column names for the table header. also sets
+ * boolean isSqlInHeaders
+ *
+ * @return
+ * @throws SQLException
+ * @throws IOException
+ * @throws TemplateException
+ */
+ Vector getHeaderVector() throws TemplateException, IOException,
+ SQLException {
+ Vector header = new Vector();
+ int pos = 0;
+ int end_pos = 0;
+ int offset = 0;
+ String tmpxil = getTmpXilPropListString();
+ int len = tmpxil.length();
+ String search_str = "heading_text=\"";
+ String header_str = null;
+ int search_len = search_str.length();
+ isSqlInHeaders = false;
+ while (offset < len) {
+ if ((pos = tmpxil.indexOf(search_str, offset)) != -1) {
+ if ((end_pos = tmpxil.indexOf("\"", pos + search_len)) != -1) {
+ header_str = tmpxil.substring(pos + search_len, end_pos);
+ if (header_str.trim().startsWith("<>"))
+ isSqlInHeaders = true;
+ header.addElement(header_str);
+ offset = pos + search_len + header_str.length() + 1;
+ } else
+ break;
+ } else
+ break;
+ }
+
+ return header;
+ }
+
+ Vector getWidthVector() throws TemplateException, IOException, SQLException {
+ xilParser.setXilString(getTmpXilPropListString());
+ return xilParser.getWidths();
+ }
+
+ /**
+ * @return Returns the erlaueterung.
+ */
+ public String getErlaueterung() {
+ return erlaueterung;
+ }
+
+ /**
+ * @param erlaueterung
+ * The erlaueterung to set.
+ */
+ public void setErlaueterung(String erlaueterung) {
+ this.erlaueterung = erlaueterung;
+ }
+
+ /*
+ * public void cloneExplanations() { explanationsClone=new Vector(); for
+ * (Iterator it = spaltenExplanations.iterator(); it.hasNext();) { String
+ * element = (String) it.next(); explanationsClone.add(new String(element)); } }
+ */
+ public int getFixedColumns() {
+
+ String fx = this.getXilProps().getProperty("fixed_columns", "1");
+ int fc = Integer.parseInt(fx);
+ if (fc == 1
+ && xilPropListString.toLowerCase().indexOf("\"ebene\"") > -1) {
+ fc = 2;
+ }
+ return fc;
+ }
+}
+
+// Created on 30.11.2003 at 17:59:08
diff --git a/src/de/superx/applet/Sachgebiet.java b/src/de/superx/applet/Sachgebiet.java
new file mode 100644
index 0000000..cfc83cc
--- /dev/null
+++ b/src/de/superx/applet/Sachgebiet.java
@@ -0,0 +1,16 @@
+package de.superx.applet;
+import de.memtext.baseobjects.NamedIdObject;
+/**
+ * not currently needed
+ * see SuperX.isSachgebieteNeeded
+ */
+public class Sachgebiet extends NamedIdObject {
+
+ public Sachgebiet(Object id, String name) {
+ super(id, name);
+ }
+
+
+}
+
+//Created on 20.11.2003
\ No newline at end of file
diff --git a/src/de/superx/applet/Sachgebiete.java b/src/de/superx/applet/Sachgebiete.java
new file mode 100644
index 0000000..23a243d
--- /dev/null
+++ b/src/de/superx/applet/Sachgebiete.java
@@ -0,0 +1,53 @@
+package de.superx.applet;
+
+import java.sql.SQLException;
+import java.util.Iterator;
+
+import de.memtext.baseobjects.NamedIdObjectI;
+import de.memtext.baseobjects.coll.NamedIdObjectSet;
+import de.superx.common.SxResultRow;
+import de.superx.common.SxResultSet;
+/**
+ * Not currently needed!
+ * see SuperX.isSachgebieteNeeded
+ */
+public class Sachgebiete {
+
+ static NamedIdObjectSet _set = new NamedIdObjectSet();
+ private Sachgebiete() {
+ }
+ public static void set(NamedIdObjectSet set) {
+ _set = set;
+ }
+ public static NamedIdObjectI getById(Object id) {
+ if (_set == null)
+ throw new IllegalStateException("list not set");
+ NamedIdObjectI result = null;
+ try {
+ result = _set.getById(id);
+
+ } catch (IllegalArgumentException e) {
+ throw new IllegalArgumentException(
+ "Es gibt kein Sachgebiet mit der Nummer " + id);
+ }
+ return result;
+ }
+ public static NamedIdObjectSet getSet() {
+ return _set;
+ }
+ public static void init() throws SQLException {
+ _set.clear();
+ SxSQL.executeQuery("select tid,name from sachgebiete");
+ SxResultSet result = SxSQL.getResult();
+ for (Iterator iter = result.iterator(); iter.hasNext();) {
+ SxResultRow row = (SxResultRow) iter.next();
+ _set.add(
+ new Sachgebiet(
+ (Integer) row.get(0),
+ row.get(1).toString()));
+ }
+
+ }
+}
+
+//Created on 19.11.2003
\ No newline at end of file
diff --git a/src/de/superx/applet/SichtApplet.java b/src/de/superx/applet/SichtApplet.java
new file mode 100644
index 0000000..3dd2f8d
--- /dev/null
+++ b/src/de/superx/applet/SichtApplet.java
@@ -0,0 +1,231 @@
+package de.superx.applet;
+
+import java.awt.Component;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Vector;
+
+import javax.swing.Icon;
+import javax.swing.JDialog;
+import javax.swing.JOptionPane;
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+
+import de.memtext.tree.HideableNode;
+import de.superx.common.AbstractSicht;
+import de.superx.common.FieldContainer;
+import de.superx.common.SelectableItemTree;
+import de.superx.common.Sichten;
+import de.superx.common.SxResultSet;
+import de.superx.servlet.SxPools;
+import de.superx.util.SqlStringUtils;
+import freemarker.template.TemplateException;
+
+/**
+ * Implementierung für den Einsatz im Applet
+ */
+public class SichtApplet extends AbstractSicht {
+
+ private static final long serialVersionUID = 1;
+
+ public SichtApplet(Sichten sichten, Object id, String name) {
+ super(sichten, id, name);
+ setCellRenderer(new SxTreeRenderer());
+ }
+
+ /**
+ * just for cloning
+ *
+ * @param id
+ * @param name
+ * @param model
+ */
+ private SichtApplet(Sichten sichten, Object id, String name,
+ DefaultTreeModel model) {
+ super(sichten, id, name, model);
+ setCellRenderer(new SxTreeRenderer());
+ }
+
+ protected SxResultSet readFromDb(String sql) throws SQLException {
+ SxSQL.executeAll(sql);
+ SxResultSet rohform = SxSQL.getResult();
+ SxSQL.close();
+ return rohform;
+ }
+
+ public void searchEntries(String such) {
+ String teststring;
+ TreePath tp;
+ boolean gefunden = false;
+ DefaultMutableTreeNode test, ausgesucht;
+ ausgesucht = null;
+ Vector treffer = new Vector();
+ Vector treffernodes = new Vector();
+
+ // alle Knoten durchlaufen
+
+ Enumeration en = getRoot().breadthFirstEnumeration();
+ while (en.hasMoreElements()) {
+ test = (DefaultMutableTreeNode) en.nextElement();
+ if (test instanceof HideableNode
+ && ((HideableNode) test).isHidden())
+ continue;
+ teststring = test.toString().toLowerCase();
+
+ if (teststring.indexOf(such) > -1) {
+ // wenn suchString im aktuellen Knoten vorhanden
+ // K
+ if (test != getRoot()) {
+ treffer.addElement(test.toString());
+ treffernodes.addElement(test);
+ }
+ }
+ }
+ if (treffer.size() > 0) {
+ if (treffer.size() > 1) {
+ // mehr als ein Treffer -> Auswahldialog
+ Object[] trefferstring = new String[treffer.size()];
+ treffer.copyInto(trefferstring);
+
+ String selectedValue = (String) showBigChoiceDialog(null,
+ "Mehrere Treffer- bitte auswählen...", "SuperX",
+ JOptionPane.INFORMATION_MESSAGE, null, trefferstring,
+ trefferstring[0]);
+
+ /*
+ * String selectedValue = (String) JOptionPane.showInputDialog(
+ * null, "Mehrere Treffer- bitte auswählen...", "SuperX",
+ * JOptionPane.INFORMATION_MESSAGE, null, trefferstring,
+ * trefferstring[0]);
+ */
+ if (selectedValue == null)
+ return;
+ gefunden = false;
+ // gewählten Knoten nach Name in Treffernodes-Vektor suchen
+ en = treffernodes.elements();
+ while (en.hasMoreElements() && gefunden == false) {
+ test = (DefaultMutableTreeNode) en.nextElement();
+ if (test.toString().equals(selectedValue)) {
+ ausgesucht = test;
+ gefunden = true;
+ }
+ }
+ }
+ if (ausgesucht == null) // bei treffer.size=1
+ ausgesucht = (DefaultMutableTreeNode) treffernodes.elementAt(0);
+ // collapse all brances + Selection anwählen
+ // if (!tree.isSelectionEmpty()) tree.clearSelection();
+ en = getRoot().depthFirstEnumeration();
+ while (en.hasMoreElements()) {
+ test = (DefaultMutableTreeNode) en.nextElement();
+ tp = new TreePath(test.getPath());
+
+ if (test != getRoot() && isExpanded(tp))
+ collapsePath(tp);
+ }
+
+ tp = new TreePath(ausgesucht.getPath());
+ addSelectionPath(tp);
+ scrollPathToVisible(tp);
+
+ validate();
+ repaint();
+ } else
+ JOptionPane.showMessageDialog(null, "Keine Treffer!", "SuperX", 1);
+ }
+
+ private Object showBigChoiceDialog(Component parentComponent,
+ Object message, String title, int messageType, Icon icon,
+ Object[] selectionValues, Object initialSelectionValue) {
+ JOptionPane pane = new JOptionPane(message, messageType,
+ JOptionPane.OK_CANCEL_OPTION, icon, null, null);
+
+ pane.setWantsInput(true);
+ pane.setSelectionValues(selectionValues);
+ pane.setInitialSelectionValue(initialSelectionValue);
+
+ JDialog dialog = pane.createDialog(parentComponent, title);
+ dialog.setSize(400, 200);
+ pane.selectInitialValue();
+ dialog.show();
+
+ Object value = pane.getInputValue();
+
+ if (value == JOptionPane.UNINITIALIZED_VALUE)
+ return null;
+ return value;
+ }
+
+ /**
+ * Im Xml-Frontend wird membervariable userid der AbstractSicht benutzt,
+ * hier wird getUserId() überschrieben, um Applet-spezifisch UseriD aus
+ * SxSQl zu holen
+ */
+ public Integer getUserid() {
+ return SxSQL.getUserID();
+ }
+
+ protected String getSqlDialect() {
+ String result = (String) SxDefaults.getPropertyValue("SxDB");
+ return result;
+
+ }
+
+ public Object clone() throws CloneNotSupportedException {
+ SelectableItemTree st = (SelectableItemTree) super.clone();
+ SichtApplet cl = new SichtApplet(sichten, getId(), getName(),
+ (DefaultTreeModel) st.getModel());
+ finishClone(cl);
+ return cl;
+ }
+
+ private class SxTreeRenderer extends DefaultTreeCellRenderer {
+
+ private static final long serialVersionUID = 1L;
+
+ public SxTreeRenderer() {
+ }
+
+
+ public Component getTreeCellRendererComponent(JTree jtree, Object obj,
+ boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
+
+ if (!((DefaultMutableTreeNode)obj).isLeaf())
+ {
+ boolean isAllChildrenHidden=true;
+ for(Enumeration en=((DefaultMutableTreeNode)obj).children();en.hasMoreElements();)
+ {
+ Object o=en.nextElement();
+ if (!(o instanceof HideableNode)||!((HideableNode)o).isHidden())
+ isAllChildrenHidden=false;
+ }
+ if (isAllChildrenHidden) {leaf=true;expanded=true;}
+ }
+ super.getTreeCellRendererComponent(jtree, obj, sel,expanded,leaf,row,hasFocus);
+
+ return this;
+ }
+ }
+ /**
+ * von Applet nicht unterstützt
+ */
+ public String dynamicSichtGenerateSql(Hashtable formular,String sql) {
+ return sql;
+
+ }
+ /**
+ * von Applet nicht unterstützt
+ */
+ public String dynmicSichtFMParsing(HashMap map,
+ FieldContainer individualFields, String sql)
+ throws TemplateException, IOException, SQLException {
+
+ return sql;
+ }
+}
diff --git a/src/de/superx/applet/SuperX.java b/src/de/superx/applet/SuperX.java
new file mode 100644
index 0000000..a140c2a
--- /dev/null
+++ b/src/de/superx/applet/SuperX.java
@@ -0,0 +1,314 @@
+package de.superx.applet;
+
+import java.awt.Image;
+import java.awt.MediaTracker;
+import java.awt.image.ImageObserver;
+import java.awt.image.PixelGrabber;
+import java.util.Hashtable;
+
+import javax.swing.ImageIcon;
+import javax.swing.JApplet;
+import javax.swing.UIManager;
+
+import de.memtext.util.HtmlUtils;
+import de.memtext.widgets.WarningMessage;
+import de.superx.common.SxUser;
+
+/**
+ * Hauptklasse von SuperX, mit der SuperX als Applet oder als Applikation
+ * aufgerufen werden kann.
+ *
+ * @version 2.0 01/01/02
+ * @author Rainer Behr, erweitert von Marlies Winterstein, Meikel Bisping
+ */
+
+public class SuperX extends JApplet {
+ static boolean isSachgebieteNeeded = false;
+ static boolean isZukünftigerStandErlaubt=true;
+ ImageIcon logo_img = new ImageIcon();
+ ImageIcon connect_img = new ImageIcon();
+ ImageIcon disconnect_img = new ImageIcon();
+ ImageIcon passwd_img = new ImageIcon();
+ ImageIcon clone_img = new ImageIcon();
+ ImageIcon copy_img = new ImageIcon();
+ ImageIcon save_img = new ImageIcon();
+ ImageIcon print_img = new ImageIcon();
+ ImageIcon info_img = new ImageIcon();
+ //Wint
+ ImageIcon help_img = new ImageIcon();
+ Hashtable img_map = new Hashtable();
+
+ static boolean isAuthentificationFound = false;
+ static String remoteUser=null;
+ private SxMask sxMask;
+
+ public void destroy() {
+ sxMask.close();
+ }
+
+ public void init() {
+
+ initImages();
+ String docBase = HtmlUtils.getCorretDocBase(this);
+
+ String prop_file = docBase + "superx.properties";
+ //System.out.println("prop_file: " + prop_file); //Wint
+ //Stuttgart verwendet http://superx/superx/applet/...
+ int pos = docBase.lastIndexOf("/superx/");
+ String defaultServerUrl = null;
+ if (pos > 0) {
+ defaultServerUrl = docBase.substring(0, pos)
+ + "/superx/servlet/SuperXDBServlet";
+ //System.out.println("default URL of Servlet: "+defaultServerUrl);
+ } else {
+ System.out
+ .println("Can't identify SxServerURL automatically, since CodeBase "+docBase+ " doesn't contain /superx/ SxServerURL has to be specified in superx.properties");
+ }
+ SxDefaults.setDefaultServerUrl(defaultServerUrl);
+ SxDefaults.setPropertyFile(prop_file);
+
+ sxMask = new SxMask("SuperX @version@", img_map, true);
+ //sxMask = new SxMask("SuperX 2.04", img_map, true);
+
+ }
+
+ private void initImages() {
+ PixelGrabber pg = null;
+
+ try {
+ UIManager
+ .setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
+ } catch (Exception ex) {
+ System.err.println("WindowsLookAndFeel nicht verfügbar");
+ }
+
+ try {
+ Image logo_icon, connect_icon, disconnect_icon, passwd_icon;
+ Image clone_icon, copy_icon, save_icon, print_icon, info_icon;
+
+ Image help_icon;
+ String img_path = "images";
+ // der ClassLoader steht ganz oben also auf gleicher Ebene wie de
+ //und sucht images im Unterverzeichnis /images
+ //de
+ //images
+ ClassLoader cl = getClass().getClassLoader();
+ logo_icon = getImage(cl.getResource(img_path + "/superx.gif"));
+ disconnect_icon = getImage(cl.getResource(img_path
+ + "/disconnect.gif"));
+ connect_icon = getImage(cl.getResource(img_path + "/connect.gif"));
+ passwd_icon = getImage(cl.getResource(img_path + "/passwd.gif"));
+ clone_icon = getImage(cl.getResource(img_path + "/clone.gif"));
+ copy_icon = getImage(cl.getResource(img_path + "/sx_copy.gif"));
+ save_icon = getImage(cl.getResource(img_path + "/sx_save.gif"));
+ print_icon = getImage(cl.getResource(img_path + "/sx_print.gif"));
+ info_icon = getImage(cl.getResource(img_path + "/info.gif"));
+ //Wint
+ help_icon = getImage(cl.getResource(img_path + "/help.gif"));
+ MediaTracker tracker = new MediaTracker(this);
+ tracker.addImage(logo_icon, 0);
+ tracker.addImage(disconnect_icon, 1);
+ tracker.addImage(connect_icon, 2);
+ tracker.addImage(clone_icon, 3);
+ tracker.addImage(copy_icon, 4);
+ tracker.addImage(save_icon, 5);
+ tracker.addImage(print_icon, 6);
+ tracker.addImage(help_icon, 7);
+ tracker.addImage(info_icon, 8);
+ tracker.addImage(passwd_icon, 9);
+ tracker.waitForAll(0);
+ if (logo_icon == null)
+ System.out.println("superx.gif nicht gefunden");
+ logo_img = new ImageIcon(logo_icon);
+ disconnect_img = new ImageIcon(disconnect_icon);
+ connect_img = new ImageIcon(connect_icon);
+ passwd_img = new ImageIcon(passwd_icon);
+ clone_img = new ImageIcon(clone_icon);
+ copy_img = new ImageIcon(copy_icon);
+ save_img = new ImageIcon(save_icon);
+ print_img = new ImageIcon(print_icon);
+ info_img = new ImageIcon(info_icon);
+ //Wint
+ help_img = new ImageIcon(help_icon);
+
+ img_map.put("disconnect", disconnect_img);
+ img_map.put("connect", connect_img);
+ img_map.put("passwd", passwd_img);
+ img_map.put("clone", clone_img);
+ img_map.put("copy", copy_img);
+ img_map.put("save", save_img);
+ img_map.put("print", print_img);
+ img_map.put("info", info_img);
+ //Wint
+ img_map.put("help", help_img);
+
+ int logow, logoh;
+ logow = logo_img.getIconWidth();
+ logoh = logo_img.getIconWidth();
+ int[] pixelarray = new int[logow * logoh];
+
+ pg = new PixelGrabber(logo_img.getImage(), 0, 0, logow, logoh,
+ pixelarray, 0, logow);
+ if (!pg.grabPixels())
+ System.err.println("init: grabPixels() failed");
+ else
+ img_map.put("logo_pixels", pixelarray);
+
+ img_map.put("logo", logo_img);
+ } catch (InterruptedException ex) {
+ System.err.println(ex.toString());
+ }
+
+ if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
+ System.err.println("image fetch aborted or error: "
+ + pg.getStatus());
+ }
+ }
+
+ public static void main(String s[]) {
+ System.out.println("SuperX @version@ (build:@sxtimestamp@)");
+
+ PixelGrabber pg = null;
+ final SxMask sxMask;
+ final Hashtable img_map = new Hashtable();
+ final ImageIcon logo_img;
+ final ImageIcon disconnect_img;
+ final ImageIcon connect_img;
+ final ImageIcon passwd_img;
+ final ImageIcon clone_img;
+ final ImageIcon copy_img;
+ final ImageIcon save_img;
+ final ImageIcon print_img;
+ final ImageIcon info_img;
+ //Wint
+ final ImageIcon help_img;
+
+ try {
+ UIManager
+ .setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
+ //UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
+ //UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
+
+ } catch (Exception ex) {
+ // System.err.println ("MacLookAndFeel not available: " +
+ // ex.toString());
+ System.err.println("WindowsLookAndFeel not available: "
+ + ex.toString());
+ }
+
+ initImagesWhenApplication(img_map);
+
+ SxDefaults
+ .setDefaultServerUrl("http://localhost:8080/superx/servlet/SuperXDBServlet");
+ //System.out.println("Hinweis: Wenn kein Eintrag für SxServerUrl in
+ // superx.properties wird mit
+ // http://localhost:8080/superx/servlet/SuperXDBServlet gearbeitet");
+ SxDefaults.setPropertyFile("file:superx.properties");
+
+ sxMask = new SxMask("SuperX @version@", img_map, false);
+
+
+
+ sxMask.open();
+ }
+
+ private static void initImagesWhenApplication(final Hashtable img_map) {
+ PixelGrabber pg;
+ final ImageIcon logo_img;
+ final ImageIcon disconnect_img;
+ final ImageIcon connect_img;
+ final ImageIcon passwd_img;
+ final ImageIcon clone_img;
+ final ImageIcon copy_img;
+ final ImageIcon save_img;
+ final ImageIcon print_img;
+ final ImageIcon info_img;
+ final ImageIcon help_img;
+ String img_dir = "images";
+ logo_img = new ImageIcon(img_dir + "/superx.gif");
+ disconnect_img = new ImageIcon(img_dir + "/disconnect.gif");
+ connect_img = new ImageIcon(img_dir + "/connect.gif");
+ passwd_img = new ImageIcon(img_dir + "/passwd.gif");
+ clone_img = new ImageIcon(img_dir + "/clone.gif");
+ copy_img = new ImageIcon(img_dir + "/sx_copy.gif");
+ save_img = new ImageIcon(img_dir + "/sx_save.gif");
+ print_img = new ImageIcon(img_dir + "/sx_print.gif");
+ info_img = new ImageIcon(img_dir + "/info.gif");
+ //Wint
+ help_img = new ImageIcon(img_dir + "/help.gif");
+
+ int logow, logoh;
+ logow = logo_img.getIconWidth();
+ logoh = logo_img.getIconWidth();
+ int[] pixelarray = new int[logow * logoh];
+
+ try {
+ pg = new PixelGrabber(logo_img.getImage(), 0, 0, logow, logoh,
+ pixelarray, 0, logow);
+ if (!pg.grabPixels())
+ System.err.println("init: grabPixels() failed");
+ else
+ img_map.put("logo_pixels", pixelarray);
+ } catch (InterruptedException ie) {
+ System.err.println(ie);
+ }
+
+ img_map.put("logo", logo_img);
+ img_map.put("disconnect", disconnect_img);
+ img_map.put("connect", connect_img);
+ img_map.put("passwd", passwd_img);
+ img_map.put("clone", clone_img);
+ img_map.put("copy", copy_img);
+ img_map.put("save", save_img);
+ img_map.put("print", print_img);
+ img_map.put("info", info_img);
+ //Wint
+ img_map.put("help", help_img);
+ }
+
+ public void start() {
+ String zukünftigerStandErlaubt=getParameter("zukünftigerStandErlaubt");
+ if (zukünftigerStandErlaubt!=null&&zukünftigerStandErlaubt.equals("false"))
+ isZukünftigerStandErlaubt=false;
+ SuperX.isAuthentificationFound=false;
+ String jsessionid = getParameter("jsessionid");
+ remoteUser=getParameter("remoteUser");
+ if (remoteUser==null||remoteUser.equals("")||remoteUser.equals("null"))
+ remoteUser=null;
+ SxDefaults.init();
+ try {
+ if (jsessionid != null && !jsessionid.trim().equals("")) {
+ // && userid != null && !userid.trim().equals("")) {
+ SuperX.isAuthentificationFound = true;
+ SxSQL.jsessionid = jsessionid;
+
+ String userstr = SxSQL.getUserFromServlet();
+ if (userstr != null) {
+ String userid = userstr.substring(0, userstr.indexOf("|"));
+ String kennung = userstr.substring(userstr.indexOf("|") + 1,userstr.indexOf("^"));
+ String admin=userstr.substring(userstr.indexOf("^")+1);
+
+ SxSQL.setUserID(new Integer(Integer.parseInt(userid)));
+ SxUser user=new SxUser("default", kennung, new Integer(Integer
+ .parseInt(userid))); // kein Mandantenbetrieb bei Applet
+ if (admin.equals("1")) user.setAdmin(true);
+ //sxMask.setUser(new SxUser(getParameter("kennung"), new
+ // Integer(Integer.parseInt(userid))));
+ sxMask.setUser(user);
+ // sxMask.setConnectPwBtnsSVisible(false);
+ int mode = 0;//anmelden
+ sxMask.initUser(mode);
+ }
+ }
+
+ SxSQL.initParams();
+ sxMask.open();
+
+ } catch (Exception e) {
+ WarningMessage.show(this, "Anmeldung fehlgeschlagen.\n" + e,
+ "SuperX");
+ e.printStackTrace();
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxDate.java b/src/de/superx/applet/SxDate.java
new file mode 100644
index 0000000..a8d34a8
--- /dev/null
+++ b/src/de/superx/applet/SxDate.java
@@ -0,0 +1,96 @@
+package de.superx.applet;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+/**
+ * Statische Klasse mit Hilfsfunktionen für Datumsobjekte.
+ *
+ * @version 2.0 01/01/02
+ * @author Rainer Behr, modified by Meikel Bisping
+ */
+
+public class SxDate {
+ static DateFormat df;
+ static java.util.Date date;
+ static java.sql.Date sql_date;
+ static Calendar calendar;
+
+ static {
+ df = DateFormat.getDateInstance(DateFormat.MEDIUM);
+ // r.b. default Jahr 4-stellig
+ df.setTimeZone(TimeZone.getDefault());
+ df.setLenient(false);
+ }
+
+ /**
+ * Wandelt einen String in ein java.sql.Date-Objekt um.
+ * @param value umzuformender String
+ * @return java.sql.Date-Objekt. Wenn der String nicht in Ordnung ist, wird NULL zurückgeliefert.
+ */
+ public static java.sql.Date getDate(String value) {
+ try {
+ if (value.endsWith("00")) {
+ switch (value.charAt(value.length() - 3)) {
+ case '-' :
+ case '.' :
+ case '/' :
+ value = value.substring(0, value.length() - 2) + "2000";
+ break;
+ }
+ }
+
+ date = df.parse(value);
+ calendar = Calendar.getInstance();
+ calendar.setTime(date);
+ int year = calendar.get(Calendar.YEAR);
+ if (year >= 0 && year < 30)
+ calendar.add(Calendar.YEAR, 2000);
+ if (year >= 30 && year < 100)
+ calendar.add(Calendar.YEAR, 1900);
+
+ sql_date = new java.sql.Date(calendar.getTime().getTime());
+ return sql_date;
+ } catch (ParseException e_parse) {
+ // System.err.println ("SxDate: ERROR: parse: Date != " + value);
+ } catch (IllegalArgumentException e_arg) {
+ // System.err.println ("SxDate: ERROR: arg: Date != " + value);
+ }
+
+ return null;
+ }
+
+ /**
+ * Wandelt ein java.sql.Date-Objekt in einen String um.
+ * @param value umzuwandelndes sql.Date-Objekt
+ * @return String
+ */
+
+ public static String toString(java.sql.Date aDate) {
+ return df.format((java.util.Date) aDate);
+ }
+
+
+ public static String getNowString() {
+ GregorianCalendar cal = new GregorianCalendar();
+ String jetzt =
+ cal.get(Calendar.DATE)
+ + "."
+ + (cal.get(Calendar.MONTH) + 1)
+ + "."
+ + cal.get(Calendar.YEAR)
+ + " "
+ + (cal.get(Calendar.HOUR_OF_DAY))
+ + ":"
+ + cal.get(Calendar.MINUTE)
+ + ":"
+ + cal.get(Calendar.SECOND);
+
+
+ return jetzt;
+ }
+
+
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxDefaults.java b/src/de/superx/applet/SxDefaults.java
new file mode 100644
index 0000000..5bf1160
--- /dev/null
+++ b/src/de/superx/applet/SxDefaults.java
@@ -0,0 +1,165 @@
+package de.superx.applet;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Properties;
+
+import javax.swing.JOptionPane;
+
+/**
+ * Defaultwerte werden aus superx.properties-Datei eingelesen (der wichtigste
+ * Wert ist SxServerURL, die URL des Servlets).
+ * Weiterhin werden Defaultwerte von Auswahlfeldern (wie Semester oder
+ * Hörerstatus) abgelegt und wieder abgerufen.Diese Funktion wird in SxForm
+ * genutzt.
+ *
+ * @version 1.0 23.4.99
+ * @author Rainer Behr
+ */
+public class SxDefaults {
+ static Hashtable defaults_map;
+ static String propertyFile;
+ static String defaultServerUrl;
+ static {
+ defaults_map = new Hashtable();
+ propertyFile = null;
+ }
+
+ public static void setPropertyFile(String file) {
+ propertyFile = new String(file);
+ }
+
+ public static void setDefaultServerUrl(String url) {
+ defaultServerUrl = url;
+ }
+
+ public static void addProperty(String name, Object nkey, Object nvalue) {
+ Properties prop = new Properties();
+ prop.put("key", nkey);
+ prop.put("value", nvalue);
+
+ defaults_map.put(name, prop);
+ }
+
+ public static Properties getProperty(String name) {
+ Properties prop = (Properties) defaults_map.get(name);
+ return prop;
+
+ }
+
+ public static Object getPropertyValue(String name) {
+ Properties prop = (Properties) defaults_map.get(name);
+ if (prop != null)
+ return prop.getProperty("value");
+ else {
+ String msg = "Property '" + name
+ + "' in 'superx.properties' nicht gefunden !";
+ throw new NullPointerException(msg);
+ }
+ }
+
+ public static void contents() {
+ Enumeration en;
+ Properties prop;
+ String name;
+ Object key;
+ Object value;
+
+ en = defaults_map.keys();
+
+ while (en.hasMoreElements()) {
+ name = (String) en.nextElement();
+ prop = (Properties) SxDefaults.getProperty(name);
+ if (prop == null)
+ continue;
+ key = prop.get("key");
+ value = prop.get("value");
+ //System.out.println (name + ": key=" + key.toString() + ", value="
+ // + value.toString());
+ }
+ }
+
+ public static void clear() {
+ defaults_map.clear();
+ defaults_map = new Hashtable();
+
+ init();
+ }
+
+
+/**
+ * Setzt auch mandantenID in SxSQL falls angegeben
+ *
+ */
+ public static void init() {
+ // Default Properties
+ // ---------------------------------------------------------------------
+
+ String prop_file;
+ Properties props = new Properties();
+ int b_len = 0;
+
+ if (propertyFile != null)
+ prop_file = propertyFile;
+ else
+ prop_file = "file:superx.properties";
+
+ try {
+ URL props_url = new URL(prop_file);
+ InputStream is = props_url.openStream();
+ if (is == null) {
+ String msg = "Ressourcedatei '" + prop_file
+ + "' nicht gefunden. ";
+ throw new IOException(msg);
+ /* Möglichkeit aus System-properties zu lesen, wenn
+ * jnlp Datei als Application
+ * Versuche aus System-properties zu lesen";
+ System.out.println(msg);
+ //MB 2/2016 versuch
+ props.put("logToKonsole",System.getProperty("logToKonsole"));
+ props.put("SxTitle",System.getProperty("SxTitle"));
+ props.put("SxDB",System.getProperty("SxDB"));
+ props.put("SxParamStart",System.getProperty("SxParamStart"));
+ props.put("SxParamEnd",System.getProperty("SxParamEnd"));
+ props.put("SxParamBoldOn",System.getProperty("SxParamBoldOn"));
+ props.put("SxParamBoldOff",System.getProperty("SxParamBoldOff"));
+ */
+ }
+
+ props.load(is);
+ is.close();
+
+ if (props.getProperty("SxServerURL") == null)
+ props.setProperty("SxServerURL", defaultServerUrl);
+ // Properties in Class SxDefaults einfuegen
+ String key;
+ String value;
+ Enumeration en = props.propertyNames();
+
+ //if no special value was speficied for the ServerUrl, use the
+ // default
+ String mandantenID="default";
+ while (en.hasMoreElements()) {
+ key = (String) en.nextElement();
+ value = (String) props.getProperty(key);
+ if (key.equals("MandantenID"))
+ mandantenID=value;
+ addProperty(key, key, value);
+ }
+ //Zuweisung darf erst hier passieren,
+ //sonst Probleme mit statischen Vars in SxSQL
+ SxSQL.mandantenID=mandantenID;
+ } catch (IOException ex) {
+ System.err.println(ex);
+ JOptionPane.showMessageDialog(null, ex.toString(), "Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ }
+ }
+
+ public static void removeProperty(String name) {
+ defaults_map.remove(name);
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxDeleteListener.java b/src/de/superx/applet/SxDeleteListener.java
new file mode 100644
index 0000000..ccb1e9d
--- /dev/null
+++ b/src/de/superx/applet/SxDeleteListener.java
@@ -0,0 +1,49 @@
+package de.superx.applet;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Vector;
+
+/**
+ *
+ * Listener für den Löschen-Button bei einer Mehrfachauswahl.
+ * @version 1.0 15.09.00
+ * @author Rainer Behr
+ * @see SxDlg
+ */
+
+public class SxDeleteListener implements ActionListener {
+ SxTablePanel sxTablePanel;
+
+ SxDeleteListener() {
+ sxTablePanel = SxDlgManager.getChoiceTable();
+ };
+
+ /**
+ *
+ * Das markierte Element wird (in der rechten Tabelle) bei einer Mehrfachauswahl gelöscht.
+ *
+ */
+
+ public void actionPerformed(ActionEvent e) {
+ SxTableSorter model =
+ (SxTableSorter) sxTablePanel.getTable().getModel();
+ Vector V_choice = SxDlgManager.getChoiceData();
+ int[] rows = sxTablePanel.getTable().getSelectedRows();
+ int cols = sxTablePanel.getTable().getColumnCount();
+ int[] indexes = model.getIndexes();
+
+ if (rows.length <= 0)
+ return;
+
+ for (int i = rows.length; i > 0; i--) {
+ V_choice.removeElementAt(indexes[rows[i - 1]]);
+ }
+
+ model.fireTableRowsDeleted(rows[0], rows[rows.length - 1]);
+
+ sxTablePanel.setData(V_choice);
+
+ model.sortByColumn(cols - 1);
+
+ }
+}
diff --git a/src/de/superx/applet/SxDlg.java b/src/de/superx/applet/SxDlg.java
new file mode 100644
index 0000000..781c9be
--- /dev/null
+++ b/src/de/superx/applet/SxDlg.java
@@ -0,0 +1,50 @@
+package de.superx.applet;
+
+import java.awt.Frame;
+import java.awt.HeadlessException;
+
+import javax.swing.JComponent;
+
+import de.memtext.baseobjects.DoubleClickMouseListener;
+import de.memtext.dlg.OkCancelClearDlg;
+import de.memtext.util.WindowUtils;
+
+public class SxDlg extends OkCancelClearDlg {
+
+ public SxDlg(Frame parent, String title, JComponent comp)
+ throws HeadlessException {
+ super(parent, title);
+ this.setCenter(comp);
+ this.pack();
+ WindowUtils.center(this);
+ if (comp instanceof SxTablePanel) {
+ SxTablePanel sxTablePanel = (SxTablePanel) comp;
+ sxTablePanel
+ .getTable()
+ .addMouseListener(new DoubleClickMouseListener() {
+ protected void doubleClickOccured() {
+ wasOkSelected = true;
+ performOk();
+ }
+ });
+ }
+ }
+
+ protected void performClear() {
+ this.hide();
+
+ }
+
+ protected void performOk() {
+ this.hide();
+
+ }
+
+ protected void performCancel() {
+ this.hide();
+
+ }
+
+}
+
+//Created on 16.03.2004 at 15:28:54
\ No newline at end of file
diff --git a/src/de/superx/applet/SxDlgListener.java b/src/de/superx/applet/SxDlgListener.java
new file mode 100644
index 0000000..db7454d
--- /dev/null
+++ b/src/de/superx/applet/SxDlgListener.java
@@ -0,0 +1,164 @@
+package de.superx.applet;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.sql.SQLException;
+import java.util.Iterator;
+
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JRootPane;
+
+import de.memtext.tree.KeyParentEqualException;
+import de.memtext.tree.NoMainEntryException;
+import de.memtext.widgets.WarningMessage;
+import de.superx.common.DBServletException;
+import de.superx.common.SelectableItem;
+import de.superx.common.Sichtgruppe;
+
+/**
+ * Dialoglistener für SxMask und SxDlg.Dabei wird unterschieden,ob es sich um
+ * einen Institutionenauswahldialog oder einen anderen Dialog handelt. Bei
+ * Ersterem werden entsprechend der Dialogart (Nr. 4/6/7) Einrichtungen aus dem
+ * Bereich Lehre angezeigt oder nicht. Aufgerufen von SxMask.addButtonField
+ *
+ * @version 2.0 01-01-02
+ * @author Rainer Behr, erweitert von Meikel Bisping, Daniel Quathamer
+ */
+
+public class SxDlgListener implements ActionListener, Runnable {
+ SxDlgListener dlg_th;
+ SxMask dlgmask;
+ private String erläuterung;
+ SxForm dlgform;
+ JButton dlgBtn;
+ SxField sxField;
+ String name;
+ int fieldnr;
+ int dlg_art;
+ private Sichtgruppe sichtgruppe;
+
+ SxDlgListener(SxMask mask, SxForm form, JButton btn, String erläuterung,
+ int n, int art) {
+ dlgmask = mask;
+
+ dlgform = form;
+ dlgBtn = btn;
+ fieldnr = n;
+ dlg_art = art;
+ this.erläuterung = erläuterung;
+ // voranstehendes L_ abschneiden
+ name = dlgBtn.getName().substring(2);
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ dlgBtn.setEnabled(false);
+ SxWaitCursor.set(dlgmask, true);
+ new Thread(this).start();
+ }
+
+ public void run() {
+ if (dlg_art == 4 || dlg_art == 6 || dlg_art == 7 || dlg_art == 12) {
+ try {
+ openTreeDlg();
+ } catch (Exception e) {
+ WarningMessage.show(dlgmask, "Konnte Dialog nicht öffnen.\n"
+ + e, "SuperX");
+ e.printStackTrace();
+ }
+ } else {
+ SxDlgManager.openDlg(dlgmask, dlgform, dlgBtn.getName(), dlgBtn
+ .getText(), fieldnr, dlg_art);
+ }
+
+ dlgBtn.setEnabled(true);
+ SxWaitCursor.set(dlgmask, false);
+ JRootPane root = dlgform.getRootPane();
+ root.setDefaultButton(dlgform.getDefaultBtn());
+
+ }
+
+ public Sichtgruppe getSichtgruppe() {
+ return sichtgruppe;
+ }
+
+ public void setSichtgruppe(Sichtgruppe sichtgruppe) {
+ this.sichtgruppe = sichtgruppe;
+ }
+
+ // dlgform.getDefaults() hier störend da das in OpenDlg passiert!
+
+ private void openTreeDlg() throws SQLException, DBServletException,
+ KeyParentEqualException, CloneNotSupportedException, NoMainEntryException {
+
+ SxTreeDlg dlg = new SxTreeDlg(dlgmask.getFrame(), dlgBtn.getText(),
+ sichtgruppe, erläuterung);
+ dlg.setVisible(true);
+ // Auf das Schließen des Dialogs warten...
+
+
+ SxField field = dlgform.getField("F_" + name);
+ // könnte eigentlich 1x beim Feldinit gemacht werden, klappt aber nicht
+ field.setSichtgruppe(sichtgruppe);
+ if (!dlg.wasCancelSelected())
+ {
+ field
+ .setSelectedSicht((SichtApplet) sichtgruppe
+ .getSelectedSicht());
+ if (dlg.isStandChanged)
+ clearRememberedValues();
+ dlgform.setErlaubt(false);
+ if (dlg.getSelections().size() == 0)
+ throw new IllegalStateException("TreeDialog hätte mindestens 1 Item liefern müssen");
+ if (dlg.getSelections().size() == 1) {//kann auch bei clear -1-Objekt für alles sein
+ if (field.isWithCombo()) {
+ JComboBox combo = (JComboBox) dlgform.getComp(field.getName());
+ combo.removeAllItems();
+ }
+ SelectableItem gewaehlt = (SelectableItem) dlg.getSelections().get(
+ 0);
+ field.setKey(gewaehlt.getId());
+ field.setText(gewaehlt.getName());
+ // für Institutionenauswahl s. Kommentar in SxUtils.generateSQL()
+ dlgform.setErlaubt(gewaehlt.isAllowed());
+ }
+ if (dlg.getSelections().size() > 1) {
+ // analog zu SxDlgManager.setField
+ if (field.isWithCombo()) {
+ JComboBox combo = (JComboBox) dlgform.getComp(field.getName());
+ combo.removeAllItems();
+ combo.setEditable(false);
+ combo.setEnabled(false);
+ String[] keys = new String[dlg.getSelections().size()];
+ boolean erlaubt=true;
+ for (int i = 0; i < dlg.getSelections().size(); i++) {
+ SelectableItem gewaehlt = (SelectableItem) dlg
+ .getSelections().get(i);
+ if (!gewaehlt.isAllowed()) erlaubt=false;
+ keys[i] = gewaehlt.getId().toString();
+ combo.insertItemAt(gewaehlt.getName(), i);
+ }
+ dlgform.setErlaubt(erlaubt);
+ field.setKey(keys);
+ field.setText(" < Ihre Auswahl > ");
+
+
+ }
+ }
+ }
+ Component err_comp = dlgform.getErrorComp(field.getName());
+ if (err_comp != null)
+ dlgform.removeErrorComp(err_comp);
+
+ }
+
+ private void clearRememberedValues() {
+ for (Iterator it = sichtgruppe.iterator(); it.hasNext();) {
+ SichtApplet eineSicht = (SichtApplet) it.next();
+ String rm = name + "-Sicht" + eineSicht.getId();
+ SxDefaults.removeProperty(rm);
+ }
+ }
+
+}
diff --git a/src/de/superx/applet/SxDlgManager.java b/src/de/superx/applet/SxDlgManager.java
new file mode 100644
index 0000000..84f435e
--- /dev/null
+++ b/src/de/superx/applet/SxDlgManager.java
@@ -0,0 +1,549 @@
+package de.superx.applet;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Frame;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.GridLayout;
+import java.awt.Insets;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Properties;
+import java.util.Vector;
+
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTable;
+import javax.swing.SwingConstants;
+import javax.swing.plaf.basic.BasicArrowButton;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+
+/**
+ * Darstellung verschiedener Auswahldialoge.
+ *
+ * @author Rainer Behr, erweitert von Meikel Bisping, Daniel Quathamer
+ *
+ *
+ *
+ */
+
+public class SxDlgManager {
+ private static boolean isSQLstatic;
+ static Hashtable dlg_map = null;
+ //static String[] DlgOptionNames = { "OK", "Abbruch", "Leeren" };
+ static Component dlg_panel = null;
+ static SxTablePanel sxTablePanel = null;
+ static SxTablePanel sxTablePanel2 = null;
+ static Vector V_header = null;
+ static Vector V_sql = null;
+ static Vector V_sql2 = null;
+ static Vector V_empty = null;
+
+ static SxSQLMetaData meta = null;
+
+ static {
+ dlg_map = new Hashtable();
+
+ V_header = new Vector();
+ V_sql = new Vector();
+ V_sql2 = new Vector();
+ V_empty = new Vector();
+
+ sxTablePanel = new SxTablePanel();
+
+ sxTablePanel.getTable().setAutoResizeMode(
+ JTable.AUTO_RESIZE_ALL_COLUMNS);
+
+ sxTablePanel2 = new SxTablePanel();
+
+ sxTablePanel2.getTable().setAutoResizeMode(
+ JTable.AUTO_RESIZE_ALL_COLUMNS);
+ }
+
+ static synchronized void openDlg(SxMask mask, SxForm form, String name,
+ String caption, int fieldnr, int dlg_art) {
+ if (dlg_art != 1 && dlg_art != 2 && dlg_art != 10)
+ return;
+
+ JComponent dlg_comp;
+ Vector v_field = (Vector) form.getFieldVector().elementAt(fieldnr);
+ isSQLstatic = true;
+ int zeilenanzahl = ((Integer) v_field.elementAt(7)).intValue();
+ // Zeilenanzahl > 1 -> Multi-Dialogauswahl
+
+ SxField field = form.getField("F_" + name.substring(2));
+
+ V_header.removeAllElements();
+ V_sql.removeAllElements();
+ V_sql2.removeAllElements();
+ V_empty.removeAllElements();
+
+
+ String stmt = getReadingSql(dlg_art, form, v_field);
+
+
+ try {
+
+
+ HashMap map = form.getHashMap(null);
+ //map.put("Maskennummer",selectedMaskeninfoElement.getTid());
+ stmt = SxSQL.templateProcessor.process("Feld sql ", stmt,
+ //Trickmethode!!
+ map, (String) SxDefaults.getPropertyValue("SxDB"));
+
+
+ //
+ Properties dlg_prop = null;
+
+ /*
+ * An dieser Stelle wird geprüft, ob der Inhalt für das Feld bereits
+ * einmal eingelesen wurde, wenn ja, dann aus Arbeitsspeicher,
+ * ansonsten bleibt dlg_prop == null und im nächsten Block wird aus
+ * der Datenbank gelesen, -> probleme wenn beim erstenmal
+ * Prüfungssemester erst ab SS92 danach erscheint nie wieder SS88
+ * immer neu einlesen MB 12.01
+ *
+ * if (isSQLstatic) { dlg_prop = getDialogSet(name); if (dlg_prop !=
+ * null) { V_header = (Vector) ((Vector)
+ * dlg_prop.get("header")).clone(); V_sql = (Vector) ((Vector)
+ * dlg_prop.get("data")).clone(); meta = (SxSQLMetaData)
+ * dlg_prop.get("meta"); } }
+ */
+
+ form.getLogo().start();
+ // System.err.println ("OpenDlg: " + stmt);
+ SxSQL.executeAll(stmt);
+ form.getLogo().stop();
+
+ dlg_comp = prepareDlgComp(form, name, caption, zeilenanzahl, field);
+
+ SxDlg dlg = new SxDlg((Frame) form.getTopLevelAncestor(),
+ //name.substring(2),
+ caption, dlg_comp);
+ dlg.show();
+ if (dlg.wasOkSelected()) {
+ // if (dlg_art != 10) { alter Institutionendialog mit vier
+ // feldern
+ if (zeilenanzahl == 1)
+ setField(field, dlg_art, false);
+ if (zeilenanzahl > 1)
+ setField(field, dlg_art, true);
+ // } else {
+ // setInstFields(SxSQL, field);
+ // }
+ }
+ if (dlg.wasClearSelected()) {
+ field.setKey(new String("-1"));
+ field.setText("");
+ if (field.isWithCombo()) {
+ JComboBox combo = (JComboBox) form.getComp("F_"
+ + name.substring(2));
+ if (combo.getItemCount() > 0)
+ combo.removeAllItems();
+ }
+ }
+
+ field.setBackground(Color.white);
+
+ field.repaint();
+ } catch (Exception ex) {
+ String msg = ex.toString();
+ // System.err.println (ex);
+ // System.err.println ("sql: " + stmt);
+ JOptionPane.showMessageDialog(form, msg.substring(msg
+ .lastIndexOf(":") + 1), "SQL-Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ }
+ }
+
+ private static JComponent prepareDlgComp(SxForm form, String name,
+ String caption, int zeilenanzahl, SxField field) {
+ JComponent dlg_comp;
+ meta = (SxSQLMetaData) SxSQL.getResultSetMetaData();
+ //Wint,das ist nicht die Stelle, um ID im rechten Fenster auszublenden
+ if (meta.getColumnCount() > 1)
+ V_header.addElement("ID");
+ //V_header.addElement(name.substring(2));
+ V_header.addElement(caption);
+ V_sql = SxSQL.getResultVector();
+
+ if (isSQLstatic)
+ addDialogSet(name, V_header.clone(), V_sql.clone(), meta);
+
+ int cols = meta.getColumnCount();
+
+ sxTablePanel.setData(V_sql, V_header, null, meta);
+
+ if (zeilenanzahl > 1) {
+ Object key = field.getKey();
+
+ if (key instanceof String[]) {
+ String[] keys = (String[]) key;
+ JComboBox combo = (JComboBox) form.getComp("F_"
+ + name.substring(2));
+ int n = combo.getItemCount();
+ for (int i = 0; i < n; i++) {
+ Vector V_row = new Vector();
+ // r.b. 15.09.00
+ // Inhalt von 'keys' in den entsprechenden Datenbanktyp
+ // konvertieren
+ // s. a. Methode tableRepresentation() in SxJDBCAdapter u.
+ // Methode SxInsertListener
+
+ switch (meta.getColumnType(1)) {
+ case Types.SMALLINT:
+ V_row.addElement(new Short(keys[i]));
+ //System.out.println("V_row: smallint");
+ break;
+ case Types.INTEGER:
+ V_row.addElement(new Integer(keys[i]));
+ //System.out.println("V_row: integer");
+ break;
+ case Types.DECIMAL:
+ case Types.DOUBLE:
+ V_row.addElement(new Double(keys[i]));
+ //System.out.println("V_row: double");
+ break;
+ case Types.DATE:
+ V_row.addElement(SxDate.getDate(keys[i]));
+ //System.out.println("V_row: date");
+ break;
+ default:
+ V_row.addElement(keys[i]);
+ //System.out.println("V_row: default");
+ break;
+ }
+
+ V_row.addElement(combo.getItemAt(i));
+ V_sql2.addElement(V_row);
+ }
+
+ sxTablePanel2.setData(V_sql2, V_header, null, meta);
+ } else {
+ // Default-Wert aus 'felderinfo'
+ if ((key.toString()).compareTo(new String("-1")) != 0) {
+ Vector V_row = new Vector();
+ V_row.addElement(key);
+ V_row.addElement(field.getText());
+ V_sql2.addElement(V_row);
+ //table2.setData (V_sql2, V_header, meta);
+ sxTablePanel2.setData(V_sql2, V_header, null, meta);
+ } else {
+ if (cols > 1)
+ V_empty.addElement(new Integer(Integer.MIN_VALUE));
+ V_empty.addElement(new String(""));
+
+ V_sql2.addElement(V_empty);
+
+ //table2.setData (V_sql2, V_header, meta);
+ sxTablePanel2.setData(V_sql2, V_header, null, meta);
+ V_sql2.removeAllElements();
+ }
+ }
+ }
+
+ Dimension dim = sxTablePanel.getTable().getPreferredSize();
+ if (dim.height > 300)
+ dim.height = 300;
+ TableColumnModel cmodel = sxTablePanel.getTable().getColumnModel();
+ //Wint, bewirkte, daß normalerweise ID und Text ausgegeben wurden
+ if (cols > 1 && SxSQL.getRowCount() > 0)
+ //&&
+ //(meta.getColumnType(1) == Types.CHAR ||
+ // meta.getColumnType(1) == Types.VARCHAR))
+ {
+ sxTablePanel.getTable().removeColumn(cmodel.getColumn(0));
+ //cols--;
+ //auch für rechte Tabelle nur 1 Feld
+ if (zeilenanzahl > 1) {
+ TableColumnModel cmodel2 = sxTablePanel2.getTable()
+ .getColumnModel();
+ sxTablePanel2.getTable().removeColumn(cmodel2.getColumn(0));
+ }
+ cols--;
+ }
+
+ if (cols > 1 && SxSQL.getRowCount() > 0)
+ cmodel.getColumn(0).setMaxWidth(80);
+ dim.width = cmodel.getTotalColumnWidth();
+ if (dim.width < 250)
+ dim.width = 250;
+
+ int row = sxTablePanel.getTable().getSelectedRow();
+ if (row >= 0)
+ sxTablePanel.getTable().setRowSelectionInterval(row, row);
+ // why ??
+ //TableColumnModel cmodel2 = sxTablePanel2.getTable().getColumnModel();
+ //cmodel2.getColumn(0).setMaxWidth (80);
+
+ sxTablePanel.getTable().setPreferredScrollableViewportSize(dim);
+ sxTablePanel2.getTable().setPreferredScrollableViewportSize(dim);
+ sxTablePanel
+ .setMinimumSize(new Dimension(dim.width + 5, dim.height + 5));
+ sxTablePanel2.setMinimumSize(new Dimension(dim.width + 5,
+ dim.height + 5));
+
+ if (zeilenanzahl > 1)
+ dlg_comp = createTwoTablesPanel();
+ else
+ dlg_comp = sxTablePanel;
+ return dlg_comp;
+ }
+
+ /**
+ *
+ * @param dlg_art
+ * @param form
+ * @param v_field
+ * @return
+ */
+ private static String getReadingSql(int dlg_art, SxForm form, Vector v_field) {
+ String stmt = null;
+ String sx_db = (String) SxDefaults.getPropertyValue("SxDB");
+ String relation = (String) v_field.elementAt(12);
+ if (relation != null)
+ relation = relation.trim();
+ boolean isTemplate = relation.toUpperCase().indexOf("FREEMARKER TEMPLATE") > -1;
+
+ String attribut = (String) v_field.elementAt(13);
+ if (attribut != null)
+ attribut = attribut.trim();
+ switch (dlg_art) {
+ case 1: // Auswahldialog (1-2 Attribute)
+
+ if (relation.startsWith("sp_")) {
+ stmt = "execute procedure " + relation;
+ if (sx_db.equals("Postgres"))
+ stmt = "select " + relation;
+
+ break;
+ }
+ if (relation.startsWith("<>"))
+ stmt = relation.substring(7);
+ else {
+ if (attribut.indexOf(',') == -1)
+ attribut = "tid, " + attribut;
+ stmt = "select " + attribut + " from " + relation
+ + " order by 2";
+ }
+ break;
+ case 2: // Stored Proc.
+ stmt = "execute procedure " + relation;
+ if (sx_db.equals("Postgres"))
+ stmt = "select " + relation;
+ break;
+ case 10: // Aufruf aus Inst.-Dialog s. createInstPanel()
+ if (relation.startsWith("sp_")) {
+ stmt = "execute procedure " + relation;
+ if (sx_db.equals("Postgres"))
+ stmt = "select " + relation;
+ break;
+ }
+ if (relation.startsWith("<>"))
+ stmt = relation.substring(7);
+ else
+ stmt = relation;
+ break;
+
+ }
+
+ //<> durch Wert ersetzen
+ String prefix = SxUtils.getFieldPrefix();
+ if (stmt.indexOf(prefix) >= 0) {
+ isSQLstatic = false;
+ stmt = SxUtils.generateSQL(form, stmt);
+ //System.out.println("sel-str: " + stmt);
+ int err_start = -1;
+ if ((err_start = stmt.indexOf(prefix)) >= 0) {
+ String suffix = SxUtils.getFieldSuffix();
+ int err_stop = stmt.indexOf(suffix, err_start);
+ err_start += prefix.length();
+ String err_field = stmt.substring(err_start, err_stop);
+ String msg = "SQL-Fehler durch '" + err_field + "' !";
+ //System.err.println (msg);
+ JOptionPane.showMessageDialog(form, msg, "Dialogfehler",
+ JOptionPane.ERROR_MESSAGE);
+ throw new IllegalArgumentException(msg);
+ }
+ }
+ if (isTemplate) stmt="--Freemarker Template\n"+stmt;
+ return stmt;
+ }
+
+ public static void setField(SxField field, int dlg_art, boolean isMultiDlg)
+ throws SQLException {
+ SxForm form = field.getForm();
+ if (form == null)
+ return;
+
+ if (!isMultiDlg) {
+ SxTableModel tmodel = (SxTableModel) sxTablePanel.getTable().getModel();
+ int row = sxTablePanel.getTable().getSelectedRow();
+ if (row < 0)
+ return;
+
+ switch (dlg_art) {
+ case 1:
+ case 2:
+ if (meta.getColumnCount() > 1) {
+ field.setKey(tmodel.getValueAt2(row, 0));
+
+ field.setText((String) tmodel.getValueAt(row, 1));
+
+ } else {
+ field.setKey(new String("-1"));
+ field.setText((String) tmodel.getValueAt(row, 0));
+ }
+
+ break;
+ default:
+ break;
+ }
+ } else {
+ SxTableModel tmodel = (SxTableModel) sxTablePanel2.getTable().getModel();
+ int rows = tmodel.getRowCount();
+ int cols = tmodel.getColumnCount();
+
+ switch (dlg_art) {
+ case 1:
+ case 2:
+ if (rows < 0)
+ break;
+ JComboBox combo = null;
+ if (field.isWithCombo()) {
+ combo = (JComboBox) form.getComp(field.getName());
+ if (combo.getItemCount() > 0)
+ combo.removeAllItems();
+ } else
+ break;
+
+ String[] keys = new String[rows];
+
+ for (int i = 0; i < rows; i++) {
+ keys[i] = (String) tmodel.getValueAt(i, 0);
+ if (cols == 1)
+ combo.insertItemAt(tmodel.getValueAt2(i, 0), i);
+ else
+ combo.insertItemAt(tmodel.getValueAt(i, 1), i);
+ }
+
+ field.setKey(keys);
+
+ break;
+ default:
+ break;
+ }
+
+ if (rows > 0)
+ field.setText(" < Ihre Auswahl > ");
+ else {
+ field.setKey(new String("-1"));
+ field.setText("");
+ }
+ }
+
+ // delete Field from Error map
+ Component err_comp = form.getErrorComp(field.getName());
+ if (err_comp != null)
+ form.removeErrorComp(err_comp);
+
+ }
+
+ public static void addDialogSet(String name, Object nheader, Object ndata,
+ Object nmeta) {
+ Properties prop = new Properties();
+ prop.put("header", nheader);
+ prop.put("data", ndata);
+ prop.put("meta", nmeta);
+
+ dlg_map.put(name, prop);
+ }
+
+ public static Properties getDialogSet(String name) {
+ Properties prop = (Properties) dlg_map.get(name);
+ return prop;
+ }
+
+ public static void clear() {
+ dlg_map.clear();
+ dlg_map = new Hashtable();
+ }
+
+ public static SxTablePanel getDlgTable() {
+ return sxTablePanel;
+ }
+
+ public static SxTablePanel getChoiceTable() {
+ return sxTablePanel2;
+ }
+
+ public static Vector getDlgData() {
+ return V_sql;
+ }
+
+ public static Vector getChoiceData() {
+ return V_sql2;
+ }
+
+ protected static JComponent createTwoTablesPanel() {
+ JPanel dlgPanel = new JPanel(new GridLayout(1, 3));
+
+ GridBagLayout gridbag = new GridBagLayout();
+ GridBagConstraints constraints = new GridBagConstraints();
+ constraints.insets = new Insets(5, 2, 5, 2);
+ dlgPanel.setLayout(gridbag);
+
+ JPanel btnPanel = new JPanel(new GridLayout(0, 1));
+
+ BasicArrowButton insertBtn = new BasicArrowButton(SwingConstants.EAST);
+ insertBtn.setHorizontalAlignment(JLabel.CENTER);
+ SxInsertListener insertl = new SxInsertListener();
+ insertBtn.addActionListener(insertl);
+ JLabel insertLabel = new JLabel("Einfügen");
+ insertLabel.setHorizontalAlignment(JLabel.CENTER);
+
+ BasicArrowButton deleteBtn = new BasicArrowButton(SwingConstants.WEST);
+ deleteBtn.setHorizontalAlignment(JLabel.CENTER);
+ SxDeleteListener deletel = new SxDeleteListener();
+ deleteBtn.addActionListener(deletel);
+ JLabel deleteLabel = new JLabel("Löschen");
+ deleteLabel.setHorizontalAlignment(JLabel.CENTER);
+
+ btnPanel.add(insertLabel);
+ btnPanel.add(insertBtn);
+ btnPanel.add(deleteLabel);
+ btnPanel.add(deleteBtn);
+
+ constraints.anchor = GridBagConstraints.WEST;
+ constraints.fill = GridBagConstraints.HORIZONTAL;
+ constraints.weightx = 0.5;
+ constraints.weighty = 1.0;
+ gridbag.setConstraints(sxTablePanel, constraints);
+ dlgPanel.add(sxTablePanel);
+
+ constraints.anchor = GridBagConstraints.CENTER;
+ constraints.fill = GridBagConstraints.NONE;
+ constraints.weightx = 0.25;
+ constraints.weighty = 0.25;
+ gridbag.setConstraints(btnPanel, constraints);
+ dlgPanel.add(btnPanel);
+
+ constraints.anchor = GridBagConstraints.EAST;
+ constraints.fill = GridBagConstraints.HORIZONTAL;
+ constraints.weightx = 0.5;
+ constraints.weighty = 1.0;
+ gridbag.setConstraints(sxTablePanel2, constraints);
+ dlgPanel.add(sxTablePanel2);
+
+ return dlgPanel;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxField.java b/src/de/superx/applet/SxField.java
new file mode 100644
index 0000000..29e6216
--- /dev/null
+++ b/src/de/superx/applet/SxField.java
@@ -0,0 +1,534 @@
+package de.superx.applet;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.text.NumberFormat;
+
+import javax.swing.ComboBoxEditor;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.table.TableCellEditor;
+
+import de.superx.common.Sichtgruppe;
+
+/**
+ * Darstellung eines Feldes auf einer Maske
+ *
+ * @version 1.0 01/11/99
+ * @author Rainer Behr, Meikel Bisping
+ * @see SxForm
+ */
+
+public class SxField extends JTextField implements ComboBoxEditor,
+ FocusListener {
+ //
+ // Static Constants
+ //
+ public static final int TYPE_STRING = 0;
+ public static final int TYPE_INTEGER = 1;
+ public static final int TYPE_DOUBLE = 2;
+ public static final int TYPE_DATE = 3;
+ public static final int TYPE_SQL = 4;
+
+ //
+ // Instants
+ //
+ //protected SxField sxField;
+ private Sichtgruppe sichtgruppe;
+ protected int field_type = TYPE_STRING;
+ protected int field_length = -1;
+ protected boolean isInputNeeded = false;
+ protected boolean field_input = false;
+ protected boolean field_withCombo = false;
+ private String field_value = "";
+ private Object field_key = new Integer(-1);
+
+ private SxForm sxForm = null; // Maskenformular
+ private JButton defaultBtn = null; // Default-Button
+ private Object defaultValue = new Integer(-1);
+ private SichtApplet selectedSicht;
+ JTable tableView = null;
+
+ public SxField() {
+ super();
+
+ init();
+ }
+
+ /**
+ * Normalerweise ist der Defaultvalue -1,da aber die Institutionsprozeduren
+ * mit char arbeiten und Informix execute procedure mit (,,) nicht klar
+ * kommt, wird für Felder die Institutionen betreffen 'null' als defaultwert
+ * festgelegt (s. SxMask.createMask()). Wird insbesondere bei isValid() und
+ * checkField() benötigt.
+ */
+ public void setDefaultValue(Object defaultValue) {
+ this.defaultValue = defaultValue;
+ }
+
+ public boolean hasSichten() {
+ return selectedSicht != null;
+ }
+
+ public SxField(int type) {
+ super();
+
+ field_type = type;
+ init();
+ }
+
+ public SxField(String text) {
+ super();
+
+ setText(text);
+ init();
+ }
+
+ public SxField(String text, int columns, int type) {
+ super();
+
+ field_type = type;
+ setText(text);
+ setColumns(columns);
+ init();
+ }
+
+ public SxField(String text, int columns) {
+ super();
+
+ setText(text);
+ setColumns(columns);
+ init();
+ }
+
+ public SxField(int type, int length) {
+ super();
+
+ field_type = type;
+ field_length = length;
+ init();
+ }
+
+ public SxField(String text, int columns, int type, int length) {
+ super();
+
+ field_type = type;
+ setText(text);
+ setColumns(columns);
+ field_length = length;
+ init();
+ }
+
+ public void setJTable(JTable table) {
+ tableView = table;
+ }
+
+ public void setForm(SxForm form) {
+ sxForm = form;
+ }
+
+ public void setWithCombo(boolean withCombo) {
+ field_withCombo = withCombo;
+ }
+
+ public boolean isWithCombo() {
+ return field_withCombo;
+ }
+
+ public SxForm getForm() {
+ return sxForm;
+ }
+
+ public void setType(int type) {
+ field_type = type;
+ }
+
+ public int getType() {
+ return field_type;
+ }
+
+ public void setKey(Object key) {
+ field_key = key;
+ }
+
+ public Object getKey() {
+ Object ret=field_key;
+ // if (field_key instanceof Double) ret=field_key.toString().replace(',','.');
+ return ret;
+ }
+
+ public void setInputNeeded(boolean input) {
+ isInputNeeded = input;
+ }
+
+ public boolean isInputNeeded() {
+ return isInputNeeded;
+ }
+
+ public boolean isValid() {
+ if (checkField()) {
+ setBackground(Color.white);
+ repaint();
+ return true;
+ }
+
+ setBackground(Color.red);
+ repaint();
+ return false;
+ }
+
+ //
+ // Interface ComboBoxEditor
+ //
+ public Component getEditorComponent() {
+ return (Component) this;
+
+ }
+
+ public Object getItem() {
+ return (Object) getText();
+ }
+
+ public void setItem(Object anObject) {
+ if (anObject == null)
+ setText("");
+ else
+ setText(anObject.toString());
+ }
+
+ // protected methods
+
+ protected void init() {
+ final SxField thisField = this;
+ KeyAdapter sxFieldKeyListener = new KeyAdapter() {
+
+ public void keyPressed(KeyEvent e) {
+ Object value;
+
+ switch (e.getKeyCode()) {
+ case KeyEvent.VK_ENTER: {
+ if (tableView != null) {
+ SxTableModel model = (SxTableModel) tableView
+ .getModel();
+ TableCellEditor editor = tableView.getCellEditor();
+ Component component = tableView.getEditorComponent();
+ int row = tableView.getSelectedRow();
+ int col = tableView.getSelectedColumn();
+ value = model.getObjectAt(row, col);
+ if (value instanceof java.lang.Integer)
+ field_type = TYPE_INTEGER;
+ if (value instanceof java.lang.Double)
+ field_type = TYPE_DOUBLE;
+ //if (value instanceof java.lang.String)
+ // field_type = TYPE_STRING;
+ if (value instanceof java.sql.Date)
+ field_type = TYPE_DATE;
+ field_value = ((JTextField) component).getText();
+ } else {
+ field_value = getText();
+ setKey(new Integer("-1"));
+ }
+
+ if (!isValid()) {
+ e.consume();
+ getToolkit().beep();
+ } else {
+ JButton defaultBtn;
+ if (sxForm != null) {
+ sxForm.removeErrorComp(thisField);
+
+ defaultBtn = sxForm.getDefaultBtn();
+ if (defaultBtn != null)
+ defaultBtn.doClick(); // DefaultButton
+ // aktivieren
+ } else {
+ defaultBtn = getRootPane().getDefaultButton();
+ if (defaultBtn != null)
+ defaultBtn.doClick(); // DefaultButton
+ // aktivieren
+ }
+ }
+
+ break;
+ }
+ case KeyEvent.VK_ESCAPE: {
+ if (tableView != null) {
+ // System.err.println("Editor canceled ..");
+ TableCellEditor editor = tableView.getCellEditor();
+ editor.cancelCellEditing();
+ }
+ break;
+ }
+ default: {
+ int metaPressed = e.getModifiers() & InputEvent.META_MASK;
+ if (metaPressed != 0) {
+ // System.err.println("keyPressed: MetaKey: " +
+ // e.getKeyChar());
+ break;
+ }
+ }
+ }
+
+ }
+
+ public void keyTyped(KeyEvent e) {
+ switch (field_type) {
+ case TYPE_INTEGER:
+ case TYPE_DOUBLE: {
+ switch (e.getKeyChar()) {
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '0':
+ case '-':
+ case '.':
+ case ',': {
+ // r.b. numerische Zeichen erlaubt
+ // System.err.println("Key: " + e.getKeyChar());
+ field_input = true;
+ break;
+ }
+ default: {
+ int metaPressed = e.getModifiers()
+ & InputEvent.META_MASK;
+ if (metaPressed != 0) {
+ // System.err.println("keyTyped: MetaKey: " +
+ // e.getKeyChar());
+ break;
+ }
+ int altPressed = e.getModifiers() & InputEvent.ALT_MASK;
+ if (altPressed != 0)
+ break;
+ // System.err.println("keyTyped: Key: " +
+ // e.getKeyChar());
+
+ if (e.getKeyChar() >= 'A' && e.getKeyChar() <= 'z') {
+ getToolkit().beep();
+ e.consume();
+ }
+
+ break;
+ }
+ }
+ break;
+ }
+ case TYPE_DATE: {
+ switch (e.getKeyChar()) {
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '0':
+ case '-':
+ case '.':
+ case '/': {
+ // r.b. Datumszeichen erlaubt
+ // System.err.println("Key: " + e.getKeyChar());
+ field_input = true;
+ break;
+ }
+ default: {
+ int metaPressed = e.getModifiers()
+ & InputEvent.META_MASK;
+ if (metaPressed != 0) {
+ // System.err.println("keyTyped: MetaKey: " +
+ // e.getKeyChar());
+ break;
+ }
+ int altPressed = e.getModifiers() & InputEvent.ALT_MASK;
+ if (altPressed != 0)
+ break;
+ // System.err.println("Key: " + e.getKeyChar());
+ if (e.getKeyChar() >= 'A' && e.getKeyChar() <= 'z') {
+ getToolkit().beep();
+ e.consume();
+ }
+
+ break;
+ }
+ }
+ break;
+ }
+ case TYPE_STRING: {
+ field_input = true;
+ break;
+ }
+
+ default:
+ // System.err.println("Key: " + e.getKeyChar());
+ break;
+ }
+
+ int text_len = getText().length();
+ if (field_length != -1) {
+ if (text_len >= field_length && getSelectedText() == null) {
+ if (e.getKeyChar() != KeyEvent.VK_ENTER
+ && e.getKeyChar() != KeyEvent.VK_BACK_SPACE) {
+ e.consume();
+ getToolkit().beep();
+ }
+ }
+ }
+
+ if (sxForm != null)
+ if (isWithCombo()) {
+ JComboBox combo = (JComboBox) sxForm.getComp(getName());
+ if (combo.getItemCount() > 0)
+ combo.removeAllItems();
+ }
+ }
+ };
+
+ addKeyListener(sxFieldKeyListener);
+
+ addFocusListener(this);
+ }
+
+ private boolean checkField() {
+ boolean error = false;
+
+ field_value="";
+ try
+ {
+ field_value = getText();
+ }
+ catch (NullPointerException e)
+ {
+ //komischer Bug in java1.6.11
+
+ }
+ if (field_value.equals("")) {
+ //setKey (new Integer ("-1"));
+ setKey(defaultValue); //s.Kommentar bei setDefaultValue
+ if (isInputNeeded())
+ return false;
+ else
+ return true;
+ }
+
+ field_value = getKey().toString();
+ if (field_value.equals("-1"))
+ field_value = getText();
+
+ try {
+ switch (field_type) {
+ case TYPE_INTEGER: {
+ new Integer(field_value);
+ //System.out.println ("Fieldtype: integer: " + field_value);
+ break;
+ }
+ case TYPE_DOUBLE: {
+ //NumberFormat nf = NumberFormat.getNumberInstance();
+ //Number new_number = nf.parse(field_value);
+ //setText(nf.format(new Double(new_number.doubleValue())));
+ //dq memo: hier locale reinbringen
+ //setText(nf.format(new Double(new_number.doubleValue())));
+ //System.out.println ("Fieldtype: double: " + field_value);
+ break;
+ }
+ case TYPE_DATE: {
+ if (!de.memtext.util.DateUtils.isValidDate(field_value))
+ throw new Exception("Date error");
+ // java.sql.Date sql_date = SxDate.getDate(field_value);
+ // if (sql_date == null) {
+ //System.err.println ("sxFieldListener: ERROR: arg: Date !=
+ // " + field_value);
+ //throw new Exception("Date error");
+ // }
+ //setText(SxDate.toString(sql_date));
+ //System.out.println ("Fieldtype: date: " + field_value);
+ break;
+ }
+ default:
+ //System.out.println ("Fieldtype: " + field_type + ": " +
+ // field_value);
+ break;
+ }
+ }
+
+ catch (Exception ex) {
+ // System.err.println ("checkField(): ERROR: Type: " + field_type +
+ // ": " + field_value);
+ error = true;
+ }
+
+ if (error)
+ return false;
+ else
+ return true;
+
+ }
+
+ public void focusGained(FocusEvent e) {
+ field_input = false;
+ }
+
+ public void focusLost(FocusEvent e) {
+ if (field_input == true) {
+ setKey(new Integer("-1"));
+ if (sxForm != null)
+ if (isWithCombo()) {
+ JComboBox combo = (JComboBox) sxForm.getComp(getName());
+ if (combo.getItemCount() > 0)
+ combo.removeAllItems();
+ }
+ }
+
+ if (!isValid()) {
+ if (sxForm != null)
+ sxForm.addErrorComp(this);
+ } else {
+ if (sxForm != null)
+ sxForm.removeErrorComp(this);
+ }
+ }
+
+ public SichtApplet getSelectedSicht() {
+ return selectedSicht;
+ }
+
+ public void setSelectedSicht(SichtApplet sicht) {
+ this.selectedSicht = sicht;
+ }
+ public void clearSichtSelections()
+ {
+ if (selectedSicht!=null) selectedSicht.clearSelection();
+ if (sichtgruppe!=null) sichtgruppe.clearSelections();
+ }
+ public String toString() {
+ String result = "";
+ if (getText() != null)
+ result += getText();
+ result += " -key:";
+ if (getKey() != null)
+ result += getKey();
+ else
+ result += " null";
+
+ return result;
+ }
+ public Sichtgruppe getSichtgruppe() {
+ return sichtgruppe;
+ }
+ public void setSichtgruppe(Sichtgruppe sichtgruppe) {
+ this.sichtgruppe = sichtgruppe;
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxForm.java b/src/de/superx/applet/SxForm.java
new file mode 100644
index 0000000..883c2cb
--- /dev/null
+++ b/src/de/superx/applet/SxForm.java
@@ -0,0 +1,930 @@
+package de.superx.applet;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.Insets;
+import java.text.NumberFormat;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Properties;
+import java.util.Vector;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPasswordField;
+import javax.swing.JRootPane;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.JToggleButton;
+
+import de.memtext.util.DateUtils;
+
+/**
+ *
+ * Stellt ein Maskenformular dar, auf dem sich einzelne Eingabe/Auswahlfelder
+ * (vom Typ SxField) wie Semester oder Haushaltsjahr befinden.
+ *
+ * @version 1.0 01/11/99
+ * @author Rainer Behr
+ * @see SxField
+ */
+
+public class SxForm extends JPanel {
+ private SxForm sxForm; // r.b. 'this'
+ private JButton defaultBtn; // Default-Button
+ private SxPosLayout pL;
+ private Insets defInsets = new Insets(2, 2, 2, 2);
+ private int distX = 20;
+ private int distY = 20;
+ private int posX = 20;
+ private int posY = 20;
+ private int diffX = 20;
+ private int diffY = 20;
+ private HashMap fmMap = new HashMap();
+ private int prefWidth = 200; //400;
+ private int prefHeight = 150;
+ private int prefCompHeight = 25;
+
+ private SxLogoPanel logo = null; // Logo
+ private Vector fieldVector = null; // Vector for field params
+ private Vector fieldKeys = null; // Vector for field names
+ private Hashtable formMap; // Hashtable for Components
+ private Hashtable errorMap; // Hashtable for Error-Components
+
+ private boolean isErlaubt = false;
+ private String hinweis;
+
+ private static NumberFormat nf = NumberFormat.getInstance();
+
+ public SxForm() {
+ super();
+
+ sxForm = this;
+
+ init();
+ }
+
+ public SxForm(int dist_x, int dist_y, int diff_x, int diff_y) {
+ super();
+
+ sxForm = this;
+
+ distX = dist_x;
+ distY = dist_y;
+ diffX = diff_x;
+ diffY = diff_y;
+
+ init();
+ }
+
+ public void addComp(String value, String comp_name, String class_name,
+ int columns, int type, int length, int obligatorisch) {
+ Dimension dim = null;
+ JButton button;
+ JToggleButton toggle;
+ JCheckBox checkbox;
+ JLabel label;
+ SxField field;
+ JPasswordField passwordfield;
+ JComboBox combo;
+ //MBComboView combov;
+ JTextArea t_area;
+
+ if (class_name.equals("JButton")) {
+ button = new JButton(value);
+ button.setName(comp_name);
+ button.setMargin(defInsets);
+ button.setFont(new Font("SansSerif", Font.BOLD, 12));
+ add(comp_name, button);
+ dim = button.getPreferredSize();
+ dim.height = prefCompHeight;
+ // dim.width=1000;
+ button.setPreferredSize(dim);
+ pL.setPosition(button, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, button);
+ }
+
+ if (class_name.equals("JToggleButton")) {
+ toggle = new JToggleButton(value);
+ toggle.setName(comp_name);
+ toggle.setMargin(defInsets);
+ toggle.setFont(new Font("Arial", Font.BOLD, 12));
+ add(comp_name, toggle);
+ dim = toggle.getPreferredSize();
+ dim.height = prefCompHeight;
+ toggle.setPreferredSize(dim);
+ pL.setPosition(toggle, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, toggle);
+ }
+
+ if (class_name.equals("JCheckBox")) {
+ checkbox = new JCheckBox(value);
+ checkbox.setName(comp_name);
+ checkbox.setMargin(defInsets);
+ checkbox.setFont(new Font("Arial", Font.BOLD, 12));
+ add(comp_name, checkbox);
+ dim = checkbox.getPreferredSize();
+ dim.height = prefCompHeight;
+ checkbox.setPreferredSize(dim);
+ pL.setPosition(checkbox, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, checkbox);
+ }
+
+ if (class_name.equals("JLabel")) {
+ label = new JLabel(value);
+ label.setName(comp_name);
+ label.setFont(new Font("SansSerif", Font.PLAIN, 12));
+ add(comp_name, label);
+ //MB n
+ dim = label.getPreferredSize();
+ if (!comp_name.equals("L_parameter")) {
+
+ dim.height = prefCompHeight;
+ label.setPreferredSize(dim);
+ }
+ pL.setPosition(label, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, label);
+ }
+
+ if (class_name.equals("SxField")) {
+ field = new SxField(value, columns, type, length);
+ field.setName(comp_name);
+ field.setForm(sxForm);
+ field.setMargin(defInsets);
+ field.setBackground(Color.white);
+ if (length > 0)
+ field.setEditable(true);
+ else
+ field.setEditable(false);
+ if (obligatorisch != 0)
+ field.setInputNeeded(true);
+ add(comp_name, field);
+ dim = field.getPreferredSize();
+ dim.height = prefCompHeight;
+ field.setPreferredSize(dim);
+ pL.setPosition(field, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, field);
+ }
+ if (class_name.equals("JPasswordField")) {
+ passwordfield = new JPasswordField(value);
+ passwordfield.setName(comp_name);
+ passwordfield.setMargin(defInsets);
+ passwordfield.setFont(new Font("Arial", Font.BOLD, 12));
+ add(comp_name, passwordfield);
+ dim = passwordfield.getPreferredSize();
+ dim.height = prefCompHeight;
+ passwordfield.setPreferredSize(dim);
+ pL.setPosition(passwordfield, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, passwordfield);
+ }
+
+ if (class_name.equals("JTextArea")) {
+ t_area = new JTextArea(value);
+ t_area.setName(comp_name);
+ t_area.setMargin(defInsets);
+ t_area.setBackground(Color.white);
+ if (length > 0)
+ t_area.setEditable(true);
+ else
+ t_area.setEditable(false);
+ add(comp_name, t_area);
+ dim = t_area.getPreferredSize();
+ dim.height = prefCompHeight;
+ t_area.setPreferredSize(dim);
+ pL.setPosition(t_area, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, t_area);
+ }
+
+ if (class_name.equals("JComboBox")) {
+ combo = new JComboBox();
+ combo.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
+ combo.setName(comp_name);
+ combo.setBackground(Color.white);
+ if (length > 0) {
+ field = new SxField(type, length);
+ field.setName(comp_name);
+ field.setWithCombo(true);
+ field.setMargin(defInsets);
+ field.setForm(sxForm);
+ if (obligatorisch != 0)
+ field.setInputNeeded(true);
+ combo.setEditor(field);
+ combo.setEditable(true);
+ } else
+ combo.setEditable(false);
+ add(comp_name, combo);
+ dim = combo.getPreferredSize();
+ dim.height = prefCompHeight;
+ combo.setPreferredSize(dim);
+ pL.setPosition(combo, posX, posY, dim.width, dim.height);
+ formMap.put(comp_name, combo);
+ }
+
+ /*
+ * MB wie ComboBox nur ohne Selektionsmöglichkeit if (class_name.equals
+ * ("JComboView")) { combov = new MBComboView(comp_name.substring(2));
+ * //combo.addItem(" ");
+ * combov.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
+ * combov.setName (comp_name); combov.setBackground(Color.white);
+ * field=new SxField(); if (length > 0) { field = new SxField (type,
+ * length); field.setName (comp_name); field.setWithCombo (true);
+ * field.setMargin(defInsets); field.setForm (sxForm); if (input != 0)
+ * field.needsInput(true); combov.setEditor (field);
+ * combov.setEditable(true); field.setText (" < Ihre Auswahl > "); }
+ *
+ * combo.addActionListener(new ActionListener(){ public void
+ * actionPerformed(ActionEvent e){ combo.setSelectedIndex(1); }} );
+ * JButton help=(JButton)this.getComp("L_"+comp_name.substring(2));
+ * ComboViewAL spezialItemListener=new ComboViewAL(combov,help);
+ * combov.addItemListener(spezialItemListener);
+ *
+ * combov.setRenderer(new ComboViewRenderer());
+ *
+ * add (comp_name, combov);
+ *
+ * dim = combov.getPreferredSize(); dim.height = prefCompHeight;
+ * combov.setPreferredSize(dim); pL.setPosition(combov, posX, posY,
+ * dim.width, dim.height); formMap.put (comp_name, combov); }
+ */
+
+ fieldKeys.add(comp_name);
+
+ if (diffX + dim.width + posX < prefWidth) {
+ posX += diffX + dim.width;
+ } else {
+ posX = distX;
+ posY += diffY + dim.height;
+ }
+ }
+
+ public void addErrorComp(Component comp) {
+ String err_name = comp.getName();
+ if (err_name != null) {
+ if (!errorMap.containsKey(err_name))
+ errorMap.put(err_name, comp);
+ }
+ }
+
+ public JComponent getComp(String comp_name) {
+ return (JComponent) formMap.get(comp_name);
+ }
+
+ public JButton getDefaultBtn() {
+ if (defaultBtn == null) {
+ JRootPane root = sxForm.getRootPane();
+ return root.getDefaultButton();
+ }
+
+ return defaultBtn;
+ }
+
+ /**
+ *
+ *
+ */
+ public void restoreValuesFromFormerSelections() {
+ Enumeration en;
+ String name;
+ SxField field;
+ Properties prop;
+ Object key;
+ Object value;
+
+ en = formMap.keys();
+
+ while (en.hasMoreElements()) {
+ name = (String) en.nextElement();
+ if (name.startsWith("F_")) {
+ field = getField(name);
+ if (field == null)
+ continue;
+ name = name.substring(2);
+ if (field.hasSichten())
+ name += "-Sicht" + field.getSelectedSicht().getId();
+ prop = (Properties) SxDefaults.getProperty(name);
+ if (prop == null)
+ continue;
+ try {
+ key = prop.get("key");
+ field.setKey(key);
+ if (field.hasSichten()) {
+ if (key == null || key.toString().equals("null"))
+ field.getSelectedSicht().clearSelection();
+ else
+ {
+ field.getSelectedSicht().setSelectedKey(key.toString());
+
+ }
+ }
+ value = prop.get("value");
+
+ if (field.isWithCombo()) {
+ if (value instanceof String[]) {
+ String[] values = (String[]) value;
+
+ JComboBox combo = (JComboBox) getComp("F_" + name);
+ int n = values.length;
+ for (int i = 0; i < n; i++)
+ combo.insertItemAt(values[i], i);
+
+ field.setText(" < Ihre Auswahl> ");
+ } else {
+ field.setText(value.toString());
+ }
+
+ } else { //not combo
+ if (key instanceof String[])
+ return;
+ field.setText(value.toString());
+ }
+ }
+ catch (Exception e)
+ {
+ System.out.println("Problem beim Wiederherstellen von Auswahlwert "+e);
+ }
+ }
+ }
+
+ }
+
+ public boolean isErlaubt() {
+ return isErlaubt;
+ }
+
+ /**
+ * Get first component that causes an error - if any
+ *
+ * @return 1st component that causes an error - null if everything OK
+ */
+ public Component getErrorComp() {
+ Enumeration en = errorMap.keys();
+ String err_name;
+
+ if (en.hasMoreElements()) {
+ err_name = (String) en.nextElement();
+ //System.out.println("err_name: " + err_name);
+ return (Component) errorMap.get(err_name);
+ } else
+ return null;
+ }
+
+ public Component getErrorComp(String name) {
+ return (Component) errorMap.get(name);
+ }
+
+ public SxField getField(Object obj) {
+ SxField field = null;
+
+ if (obj == null)
+ return null;
+
+ if (obj instanceof SxField)
+ return (SxField) obj;
+
+ if (obj instanceof JComboBox) {
+ JComboBox combo = (JComboBox) obj;
+ field = (SxField) combo.getEditor();
+ return field;
+ }
+
+ return field;
+ }
+
+ public SxField getField(String comp_name) {
+ return getField(getComp(comp_name));
+ }
+
+ /**
+ * fiese Methode, die für jedes Feld prüft, ob sichten hinterlegt sind, wenn
+ * ja wird die ausgewählte Sicht unter Feldnamen in einen Hashtable gepackt
+ * bei normalen Felder wird der ausgewählte Wert für den Schlüssel
+ * hinterlegt
+ * @param maskNo TODO
+ *
+ * @deprecated not really deprecated but evil
+ * @return Hashtable
+ */
+ HashMap getHashMap(Integer maskNo) {
+
+ if (maskNo!=null) fmMap.put("Maskennummer",maskNo);
+ for (Enumeration enumeration = getMap().keys(); enumeration
+ .hasMoreElements();) {
+ String fieldname = (String) enumeration.nextElement();
+ if (fieldname.startsWith("F_")) {
+ SxField aField = getField(fieldname);
+ if (aField.hasSichten()) {
+ fmMap.put(aField.getName().substring(2), aField
+ .getSelectedSicht());
+
+ aField.getSelectedSicht().updateKlappstatus();
+ if (aField.getSelectedSicht().isStandbuttonWanted())
+ fmMap.put(aField.getName().substring(2) + "-Stand", aField
+ .getSelectedSicht().getStand());
+ } else {
+ Object o=aField.getKey();
+ if (o!=null&&o.toString().equals("-1"))
+ o=getFieldKey(aField.getName());
+ //aField.getKey() liefert falsches Ergebnis für direkeingabeFelder
+ //eigentlich getFieldKey(aField.getName())); dann aber potentiell
+ //zu viele ' einfache Anführungszeichen
+
+ fmMap.put(aField.getName().substring(2), o);
+ aField.getItem();
+ }
+ }
+ }
+ return fmMap;
+ }
+
+ /**
+ * Checks if all fields that require input also contain input If a field
+ * doesn't it is added to errorComp collection
+ *
+ * getFieldContents also does a check - can we just remove that?
+ *
+ * @throws Exception
+ */
+ void checkFields() throws Exception {
+ for (Enumeration enumeration = getMap().keys(); enumeration
+ .hasMoreElements();) {
+ String fieldname = (String) enumeration.nextElement();
+ if (fieldname.startsWith("F_")) {
+ SxField aField = getField(fieldname);
+
+ String content = aField.getText();
+ if (aField.isInputNeeded()
+ && (content == null || content.equals(""))) {
+ aField.setBackground(Color.red);
+ addErrorComp(aField);
+ }
+
+ }
+ }
+ Component err_comp = getErrorComp();
+ if (err_comp != null) {
+ String err_name = err_comp.getName().substring(2);
+ throw new Exception("Im Feld '" + err_name
+ + "' müssen Sie etwas auswählen bzw. eingeben!");
+ }
+ }
+
+ private String getFieldContents(String field_name) {
+ SxField field;
+ String contents = null;
+
+ field = getField(field_name);
+ if (field == null)
+ return null;
+
+ if (field.getText().equals(""))
+ return null;
+
+ if (field.getType() == SxField.TYPE_DATE) {
+ contents = field.getText();
+ }
+ if (field.getType() == SxField.TYPE_DOUBLE) {
+ try {
+ Number number_value = nf.parse(field.getText().replace('.', ','));
+ Double double_value = new Double(number_value.doubleValue());
+
+ if (double_value != null)
+ contents = double_value.toString();
+ } catch (Exception ex) {
+ contents = null;
+ }
+ }
+ if (field.getType() == SxField.TYPE_STRING) {
+ contents = field.getText();
+ if (contents!=null) contents=contents.replace(';','^');
+ //manchmal Fehler wenn man Leeren drückt wird für execute procedure
+ // zu (,,) nicht ('null',xxx)
+ //evtl. hier anpassen
+ //if (contents.equals("-1") contents="null";
+ }
+ if (field.getType()==SxField.TYPE_SQL) {
+ contents = field.getText();
+ if (contents!=null) contents=contents.replace(';','^');
+ }
+ if (field.getType() == SxField.TYPE_INTEGER)
+ contents = field.getText();
+
+ // moved to method checkField, can I just delete it??
+ if (field.isInputNeeded() && (contents == null || contents.equals(""))) {
+ System.err.println("Eingabe in '" + field_name.substring(2)
+ + "' fehlt !");
+ field.setBackground(Color.red);
+ addErrorComp(field);
+ }
+
+ return contents;
+
+ }
+
+ public String getFieldKey(String field_name) {
+ Object obj;
+ SxField field;
+ Object key;
+ String sx_db = (String) SxDefaults.getPropertyValue("SxDB");
+
+ obj = getComp(field_name);
+ if (obj == null)
+ return null;
+
+ field = getField(obj);
+ if (field == null)
+ return null;
+
+ key = field.getKey();
+ //System.out.println("Feldname: "+field_name+"; key: " +
+ // key.toString());
+
+ if (!field.isWithCombo()) {
+ if (key instanceof String[])
+ return "";
+ if (key.toString().equals("null"))
+ if (field.getType() == SxField.TYPE_STRING
+ || field.getType() == SxField.TYPE_DATE)
+ return "'null'";
+ else
+ return "";
+ if (key.toString().equals("-1")) {
+ //Einfaches Textfeld
+ String w = getFieldContents(field_name);
+ int dummy=1;
+ if (w == null)
+ return "";
+ if (field.getType() == SxField.TYPE_STRING
+ || field.getType() == SxField.TYPE_DATE)
+ return "'" + w + "'";
+ else
+ if (field.getType()==SxField.TYPE_DOUBLE)
+ return w.replace(',','.');
+ else return w;
+
+ } else {
+ //Dialogfeld mit key:
+ if (key.toString().equals(""))
+ return "";
+ if (field.getType() == SxField.TYPE_STRING
+ || field.getType() == SxField.TYPE_DATE)
+ return "'" + key.toString() + "'";
+ else
+ if (field.getType()==SxField.TYPE_DOUBLE)
+ return key.toString().replace(',','.');
+ else
+ return key.toString();
+
+ //}
+ }
+ } else {
+ //Das Applet setzt Mehrfachauswahlfelder automatisch je nach Typ um
+ // als int oder string
+ //Die explizite Deklaration wird in Felderinfo definiert (typ)
+ String key_str = "";
+ if (key instanceof String[]) {
+ String[] keys = (String[]) key;
+
+ for (int i = 0; i < keys.length; i++) {
+ if (i > 0)
+ key_str = key_str + ",";
+ if (field.getType() == SxField.TYPE_STRING)
+ key_str = key_str + "'" + keys[i] + "'";
+ else
+ key_str = key_str + keys[i];
+ }
+ } else {
+ //manchmal Fehler wenn man Leeren drückt wird für execute
+ // procedure zu (,,) nicht ('null',xxx)
+ //evtl. getFieldContents anpassen
+
+ if (key.toString().equals("-1"))
+ return getFieldContents(field_name);
+ else
+ //System.out.println("KEYS"+field_name);
+ if (field.getType() == SxField.TYPE_STRING)
+ return "'" + key.toString() + "'";
+ else
+ return key.toString();
+ }
+
+ return key_str;
+ }
+ }
+
+ public Vector getFieldVector() {
+ return fieldVector;
+ }
+
+ public SxLogoPanel getLogo() {
+ return logo;
+ }
+
+ public Hashtable getMap() {
+ return formMap;
+ }
+
+ public String getParamList(String username, boolean isHtmlWanted) {
+ Enumeration en;
+ String name;
+ SxField field;
+ Properties prop;
+
+ StringBuffer contents;
+ StringBuffer paramList = new StringBuffer();
+
+ // HTML-Properties aus SxDefaults
+ String html_start = "";
+ String html_end = "";
+ String html_bold_on = "";
+ String html_bold_off = "";
+ try {
+ html_start = (String) SxDefaults.getPropertyValue("SxParamStart");
+ html_end = (String) SxDefaults.getPropertyValue("SxParamEnd");
+ html_bold_on = (String) SxDefaults
+ .getPropertyValue("SxParamBoldOn");
+ html_bold_off = (String) SxDefaults
+ .getPropertyValue("SxParamBoldOff");
+ } catch (NullPointerException ex) {
+ System.err.println(ex);
+ JOptionPane.showMessageDialog(sxForm, ex.toString(), "Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ }
+ if (isHtmlWanted)
+ paramList.append(html_start);
+
+ // sort keys
+ //java.util.List L_keys = Arrays.asList (formMap.keySet().toArray());
+ //Collections.sort (L_keys, Collator.getInstance());
+ //
+ String orgStand = "";
+ for (int k = 0; k < fieldKeys.size(); k++) {
+ name = (String) fieldKeys.elementAt(k);
+ if (!name.startsWith("F_"))
+ continue;
+ field = getField(name);
+ if (field == null || !field.isVisible())
+ continue;
+ contents = new StringBuffer();
+
+ if (!field.isWithCombo()) {
+ contents.append(field.getText());
+ } else {
+ JComboBox combo = (JComboBox) getComp(name);
+ int n = combo.getItemCount();
+ if (n == 0)
+ contents.append(field.getText());
+ else
+ for (int i = 0; i < n; i++) {
+ contents.append((String) combo.getItemAt(i));
+ if (i < n - 1)
+ contents.append(", ");
+ }
+ }
+
+ if (field.hasSichten()) {
+ if (contents.length() == 0) {
+ contents.append("keine Einschränkung ");
+ }
+ if (!field.getSelectedSicht().isPerfectlyRegular())
+ contents.append(" (" + field.getSelectedSicht().getName()
+ + ")");
+ if (field.getSelectedSicht().isStandbuttonWanted())
+ contents.append(" - Stand "
+ + field.getSelectedSicht().getStand());
+ }
+ if (contents.length() <= 0)
+ continue;
+
+ if (isHtmlWanted)
+ paramList.append(html_bold_on + name.substring(2)
+ + html_bold_off);
+ else
+ paramList.append(name.substring(2));
+ paramList.append(" = " + contents.toString() + "; ");
+ if (!isHtmlWanted)
+ paramList.append("\n");
+
+ }
+ if (isHtmlWanted)
+ paramList.append(html_bold_on + "User" + html_bold_off + "="
+ + username + ";
");
+ else
+ paramList.append("User=" + username + "\n");
+ paramList.append(this.getHinweis());
+ if (isHtmlWanted)
+ paramList.append(html_end);
+
+ //System.err.println("ParamList:");
+ //System.err.println(paramList.toString());
+
+ return paramList.toString();
+ }
+
+ public void init() {
+ sxForm.setBorder(BorderFactory.createEtchedBorder());
+ pL = new SxPosLayout(distX, distY, diffX, diffY);
+ pL.setPreferredSize(prefWidth, prefHeight);
+ sxForm.setLayout(pL);
+ sxForm.setFont(new Font("Arial", Font.PLAIN, 12));
+
+ formMap = new Hashtable();
+ fieldKeys = new Vector();
+ errorMap = new Hashtable();
+ }
+
+ public void removeAll() {
+ super.removeAll();
+
+ formMap.clear();
+ fieldKeys.clear();
+ errorMap.clear();
+
+ defaultBtn = null;
+
+ posX = 20;
+ posY = 20;
+ }
+
+ public void removeComp(String name) {
+ Component comp;
+ comp = getComp(name);
+ if (comp == null)
+ return;
+ formMap.remove(comp);
+ super.remove(comp);
+ comp = null;
+ }
+
+ public void removeErrorComp(Component comp) {
+ String err_name = comp.getName();
+ if (err_name != null) {
+ errorMap.remove(err_name);
+ //System.out.println("err_name in removeErrorComp: " + err_name);
+ }
+
+ }
+
+ //MB 5/04
+ //only used by SxMask for L_Parameter, obsolete
+ /*
+ * public void resizeComp(String name, int width) { JComponent comp;
+ * Dimension comp_dim; comp = getComp(name); if (comp == null) return;
+ *
+ * comp_dim = comp.getSize(); comp_dim.width = width; super.remove(comp);
+ * comp.setSize(comp_dim); super.add(comp); }
+ */
+ public void setCompXY(String comp_name, int pos_x, int pos_y) {
+ Component comp = (Component) getComp(comp_name);
+ if (comp == null)
+ return;
+ Dimension dim = comp.getPreferredSize();
+ pL.setPosition(comp, pos_x, pos_y, dim.width, dim.height);
+ }
+
+ public void setDefaultBtn(JButton btn) {
+ defaultBtn = btn;
+ }
+
+ public void rememberSelectionsAsDefaults() {
+ Enumeration en;
+ String name;
+ SxField field;
+
+ // erlaubt=new Integer(0);
+ en = formMap.keys();
+
+ while (en.hasMoreElements()) {
+ name = (String) en.nextElement();
+
+ if (name.startsWith("F_")) {
+ field = getField(name);
+ if (field == null)
+ continue;
+ name = name.substring(2);
+ if (!field.isWithCombo()) {
+ if (field.hasSichten())
+ name += "-Sicht" + field.getSelectedSicht().getId();
+ SxDefaults.addProperty(name, field.getKey(), field
+ .getText());
+ } else {
+ //COMBOFIELD
+ if (field.getKey() instanceof Object[]) {
+ String[] keys = (String[]) field.getKey();
+ String[] values = new String[keys.length];
+ JComboBox combo = (JComboBox) getComp("F_" + name);
+ int n = combo.getItemCount();
+ for (int i = 0; i < n; i++)
+ values[i] = (String) combo.getItemAt(i);
+
+ SxDefaults.addProperty(name, keys, values);
+ } else {
+ SxDefaults.addProperty(name, field.getKey(), field
+ .getText());
+ }
+ }
+ }
+ }
+ } //MB die zwei Methoden werden für Institutionenauswahl
+
+ //benötigt, s. Kommentar in SxUtils.generateSQL()
+ public void setErlaubt(boolean erl) {
+ isErlaubt = erl;
+ }
+
+ public void setFieldVector(Vector V_field) {
+ fieldVector = V_field;
+ }
+
+ public void setLogo(SxLogoPanel alogo) {
+ logo = alogo;
+ }
+
+ public void setPreferredCompHeight(String comp_name, int height) {
+ JComponent comp = (JComponent) getComp(comp_name);
+ if (comp == null)
+ return;
+ Dimension dim = comp.getPreferredSize();
+ dim.height = height;
+ comp.setPreferredSize(dim);
+ }
+
+ public void setPreferredCompWidth(String comp_name, int width) {
+ JComponent comp = (JComponent) getComp(comp_name);
+ if (comp == null)
+ return;
+ Dimension dim = comp.getPreferredSize();
+ dim.width = width;
+ comp.setPreferredSize(dim);
+ }
+
+ public void setPreferredSize(int width, int height) {
+ prefWidth = width;
+ prefHeight = height;
+ pL.setPreferredSize(prefWidth, prefHeight);
+ }
+
+ public String getHinweis() {
+ return hinweis != null ? hinweis : new String("");
+ }
+
+ public void setHinweis(Object Hinw) {
+ if (Hinw == null)
+ this.hinweis = null;
+ else
+ this.hinweis = Hinw.toString();
+
+ }
+
+ String getDefaultStand() {
+ //prüfen für Default-Stand-Wert
+ String defaultstand = null;
+ String teststring;
+ SxField testfield;
+ //Feste Abhängigkeiten rausgenommen
+ //auf Wunsch von M.Winterstein 30.6.06
+ /* try {
+ testfield = getField("F_Haushaltsjahr");
+ if (testfield != null) {
+ String s4 = testfield.getText();
+ if (s4.length() == 4) //valid date
+ defaultstand = new String("1.1." + s4);
+ else
+ defaultstand = DateUtils.getTodayString();
+ }
+ testfield = getField("F_Datum");
+ if (testfield != null)
+ defaultstand = new String(testfield.getText());
+ testfield = getField("F_Semester");
+ if (testfield != null) {
+ SxSQL
+ .executeQuery("select sem_beginn from semester where eintrag='"
+ + testfield.getText() + "';");
+ Vector erg = SxSQL.getResultVector();
+ defaultstand = (String) erg.elementAt(0);
+ }
+
+ DateFormat df;
+ df = DateFormat.getDateInstance(DateFormat.MEDIUM);
+ // r.b. default Jahr 4-stellig
+ df.setTimeZone(TimeZone.getDefault());
+ df.setLenient(false);
+
+ } catch (Exception e) {
+
+ }*/
+ if (defaultstand == null)
+ defaultstand = DateUtils.getTodayString();
+ return defaultstand;
+ }
+
+
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxHeaderRenderer.java b/src/de/superx/applet/SxHeaderRenderer.java
new file mode 100644
index 0000000..14e1df6
--- /dev/null
+++ b/src/de/superx/applet/SxHeaderRenderer.java
@@ -0,0 +1,166 @@
+package de.superx.applet;
+import java.awt.Component;
+import java.awt.Font;
+import java.awt.GridLayout;
+import java.util.Vector;
+
+import javax.swing.BorderFactory;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTable;
+import javax.swing.border.BevelBorder;
+import javax.swing.table.TableCellRenderer;
+/**
+ *Darstellung der Tabellen-Header. Wird von SxTable verwendet.
+ *
+ * @version 1.0 01/11/02
+ * @author Rainer Behr
+ * @see SxTable
+ */
+
+public class SxHeaderRenderer extends JPanel implements TableCellRenderer
+{
+//
+// Static Constants
+//
+
+//
+// Instants
+//
+ protected SxHeaderRenderer renderer;
+
+ protected Font header_font = null;
+ protected Vector V_buttons = new Vector ();
+ protected int num_lines = 1;
+ protected Vector V_textlines = new Vector ();
+
+ public SxHeaderRenderer()
+ {
+ super();
+
+ renderer = this;
+
+ renderer.setLayout(new GridLayout(0, 1));
+ renderer.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
+
+ JLabel line = new JLabel ();
+ line.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
+ line.setHorizontalAlignment (JLabel.CENTER);
+ V_buttons.addElement (line);
+ renderer.add (line);
+
+ setOpaque(true);
+ }
+
+ public void setNumLines(int lines)
+ {
+ num_lines = lines;
+
+ renderer.removeAll ();
+ V_buttons.removeAllElements ();
+
+ for (int i = 0; i < num_lines; i++)
+ {
+ JLabel line = new JLabel ();
+ line.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
+ line.setHorizontalAlignment (JLabel.CENTER);
+ if (header_font != null)
+ line.setFont (header_font);
+ V_buttons.insertElementAt (line, i);
+ renderer.add (line);
+ }
+ }
+
+ public int getNumLines()
+ {
+ return num_lines;
+ }
+
+ public void setTextLines(String header_value)
+ {
+ int offset = 0;
+ int pos, next_pos;
+ int nr_lines = 0;
+ int n = 0;
+
+ V_textlines.removeAllElements ();
+
+ while (offset < header_value.length())
+ {
+ if ((pos = header_value.indexOf ("\\n", offset)) != -1)
+ {
+ V_textlines.insertElementAt(header_value.substring (offset, pos), n);
+ n++;
+ nr_lines++;
+
+ if ((next_pos = header_value.indexOf ("\\n", pos + 2)) != -1)
+ {
+ offset = next_pos + 2;
+ V_textlines.insertElementAt(header_value.substring (pos + 2, next_pos), n);
+ n++;
+ nr_lines++;
+ }
+ else
+ {
+ offset = pos + 2;
+ V_textlines.insertElementAt(header_value.substring (pos + 2), n);
+ n++;
+ nr_lines++;
+ break;
+ }
+ }
+ else
+ {
+ V_textlines.insertElementAt(header_value.substring (offset), n);
+ n++;
+ nr_lines++;
+ break;
+ }
+ }
+
+ setNumLines (nr_lines);
+
+ for (int i = 0; i < num_lines; i++)
+ {
+ JLabel line = (JLabel) V_buttons.elementAt (i);
+ line.setText ((String) V_textlines.elementAt(i));
+ }
+ }
+
+ public void setHeaderFont(Font newfont)
+ {
+ header_font = newfont;
+ }
+
+ public void setHorizontalAlignment(int alignment)
+ {
+ for (int i = 0; i < num_lines; i++)
+ {
+ JLabel line = (JLabel) V_buttons.elementAt (i);
+ line.setHorizontalAlignment (alignment);
+ }
+ }
+
+ public void setText(Object value)
+ {
+ if (V_textlines.size () == 0)
+ setTextLines(value.toString());
+
+ for (int i = 0; i < num_lines; i++)
+ {
+ JLabel line = (JLabel) V_buttons.elementAt (i);
+ line.setText ((String) V_textlines.elementAt(i));
+ }
+ }
+
+ public Component getTableCellRendererComponent (JTable table, Object value,
+ boolean isSelected,
+ boolean hasFocus,
+ int row, int column)
+ {
+ if (value != null)
+ setText (value.toString());
+
+ return (Component) renderer;
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxInsertListener.java b/src/de/superx/applet/SxInsertListener.java
new file mode 100644
index 0000000..629bcd4
--- /dev/null
+++ b/src/de/superx/applet/SxInsertListener.java
@@ -0,0 +1,68 @@
+package de.superx.applet;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Vector;
+
+import javax.swing.JOptionPane;
+import javax.swing.JTable;
+/**
+ *
+ * Listener für den Einfügen-Button bei einer Mehrfachauswahl.
+ * @version 1.0 15.09.00
+ * @author Rainer Behr
+ * @see SxDlg
+ */
+public class SxInsertListener implements ActionListener
+{
+ SxTablePanel table;
+ JTable jtable;
+ JTable jtable2;
+ SxTablePanel table2;
+
+ SxInsertListener()
+ {
+ table = SxDlgManager.getDlgTable();
+ jtable = table.getTable();
+ table2 = SxDlgManager.getChoiceTable();
+ jtable2 = table2.getTable();
+ };
+
+ public void actionPerformed(ActionEvent e)
+ {
+ Vector V_data = SxDlgManager.getDlgData();
+ Vector V_choice = SxDlgManager.getChoiceData();
+ int [] rows = jtable.getSelectedRows();
+ int cols = jtable.getColumnCount();
+
+ SxTableSorter model = (SxTableSorter) jtable.getModel();
+ SxTableSorter model2 = (SxTableSorter) jtable2.getModel();
+ int [] indexes = model.getIndexes();
+
+ if (rows.length <= 0)
+ return;
+
+ if (rows.length > 30)
+ {
+ String msg = "Bitte nicht mehr als 30 Werte auswählen !";
+ // System.err.println (msg);
+ JOptionPane.showMessageDialog(table.getParent(), msg, "Dialogfehler",
+ JOptionPane.ERROR_MESSAGE);
+ return;
+ }
+
+ for (int i = 0; i < rows.length; i++)
+ {
+
+// r.b. 15.09.00
+// findet den entsprechenden Eintrag nur wenn Object-Typ in Tabelle u. Vector
+// uebereinstimmt s.o.
+ if (!V_choice.contains (V_data.elementAt(indexes[rows[i]])))
+ V_choice.addElement (V_data.elementAt(indexes[rows[i]]));
+ }
+
+ table2.setData (V_choice);
+
+ model2.sortByColumn (cols - 1);
+ }
+}
+
diff --git a/src/de/superx/applet/SxJDBCAdapter.java b/src/de/superx/applet/SxJDBCAdapter.java
new file mode 100644
index 0000000..3c4de4a
--- /dev/null
+++ b/src/de/superx/applet/SxJDBCAdapter.java
@@ -0,0 +1,545 @@
+// Beispielklasse aus dem JavaTutorial (http://java.sun.com/docs/books/tutorial) für SuperX angepasst
+/*
+ * @(#)JDBCAdapter.java 1.5 97/12/03
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * This software is the confidential and proprietary information of Sun
+ * Microsystems, Inc. ("Confidential Information"). You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with Sun.
+ *
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
+ * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
+ * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
+ * THIS SOFTWARE OR ITS DERIVATIVES.
+ *
+ */
+
+/**
+ * An adaptor, transforming the JDBC interface to the TableModel interface.
+ *
+ * @version 1.20 09/25/97
+ * @author Philip Milne
+ */
+
+package de.superx.applet;
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.Properties;
+import java.util.Vector;
+
+import javax.swing.table.AbstractTableModel;
+
+import de.superx.common.SuperX_el;
+
+
+/**
+ * Ein Adapter, der das JDBC-Interface an das TableModel-Interface anpasst.
+ * Angepasst für SuperX
+ * @autor Philip Milne, erweitert von R. Behr
+ * @version 1.2
+*/
+
+public class SxJDBCAdapter extends AbstractTableModel implements SxTableModel {
+ Connection connection;
+ Properties db_props = null;
+ boolean isClosed = true;
+ boolean isEditable = false;
+ Statement statement = null;
+ ResultSet resultSet = null;
+ String[] columnNames = {};
+ Class[] columnTpyes = {};
+ Vector rows = new Vector();
+ SxSQLMetaData metaData;
+ NumberFormat nf = NumberFormat.getInstance();
+ //DecimalFormat df=(DecimalFormat) nf;
+
+ /* public SxJDBCAdapter(String url, String driverName,
+ String user, String passwd) throws Exception {
+ try
+ {
+ Class.forName(driverName);
+ System.err.println("Opening db connection");
+
+ if (!isClosed)
+ {
+ statement.close();
+ connection.close ();
+ isClosed = true;
+ }
+
+ db_props = new Properties ();
+ db_props.put ("user", user);
+ db_props.put ("password", passwd);
+
+ connection = DriverManager.getConnection(url, db_props);
+ statement = connection.createStatement();
+ isClosed = false;
+ }
+ catch (Exception ex)
+ {
+ isClosed = true;
+ throw new SQLException (ex.toString());
+ }
+ }*/
+
+ public SxJDBCAdapter() {}
+
+ public void executeQuery(String query) throws SQLException
+ {
+ resultSet = statement.executeQuery(query);
+ // resultSet = statement.getResultSet();
+ metaData = new SxSQLMetaData (new SuperX_el());
+ //metaData = resultSet.getMetaData();
+
+ int numberOfColumns = metaData.getColumnCount();
+ columnNames = new String[numberOfColumns];
+ // Get the column names and cache them.
+ // Then we can close the connection.
+ for(int column = 0; column < numberOfColumns; column++)
+ {
+ columnNames[column] = metaData.getColumnLabel(column+1);
+ // System.err.println ("Column: " + columnNames[column] + ", max width: " +
+ // metaData.getColumnDisplaySize(column+1));
+ }
+
+ // Get all rows.
+ rows = new Vector();
+ while (resultSet.next())
+ {
+ Vector newRow = new Vector();
+ for (int i = 0; i < getColumnCount(); i++)
+ {
+ // newRow.addElement(dbRepresentation(i, resultSet.getObject(i + 1)));
+ newRow.addElement(resultSet.getObject(i + 1));
+ }
+ rows.addElement(newRow);
+ }
+ // close(); // Need to copy the metaData, bug in jdbc:odbc driver.
+ fireTableChanged(null); // Tell the listeners a new table has arrived.
+ }
+
+ public void cancel(String url, String user, String passwd) throws Exception
+ {
+ try
+ {
+ System.err.println("Cancel statement");
+ statement.cancel();
+ }
+ catch (Exception e)
+ {
+ System.err.println("Error canceling statement: " + e);
+ }
+ }
+
+ public void close() throws SQLException
+ {
+ try
+ {
+ System.err.println("Closing db connection");
+ if (!isClosed)
+ {
+ if (resultSet != null)
+ resultSet.close();
+ if (statement != null)
+ statement.close();
+ connection.close();
+ isClosed = true;
+ }
+ }
+ catch (SQLException e)
+ {
+ System.err.println("Error closing db connection: " + e);
+ }
+ }
+
+ protected void finalize() throws Throwable
+ {
+ if (!isClosed)
+ {
+ close();
+ isClosed = true;
+ }
+ super.finalize();
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation des TableModelInterface
+ //
+ //////////////////////////////////////////////////////////////////////////
+
+ // MetaData
+
+ public String getColumnName(int column) {
+ if (columnNames[column] != null) {
+ return columnNames[column];
+ } else {
+ return "";
+ }
+ }
+
+ public int getColumnSize(int column)
+ {
+ if (metaData == null)
+ return -1;
+
+ return metaData.getColumnDisplaySize(column+1);
+ }
+
+ public Class getColumnClass(int column)
+ {
+ int type;
+
+ if (metaData == null)
+ return Object.class;
+
+ type = metaData.getColumnType(column+1);
+
+ switch(type)
+ {
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return String.class;
+
+ case Types.BIT:
+ return Boolean.class;
+
+ case Types.TINYINT:
+ case Types.SMALLINT:
+ return Short.class;
+
+ case Types.INTEGER:
+ return Integer.class;
+
+ case Types.BIGINT:
+ return Long.class;
+
+ case Types.FLOAT:
+ case Types.DOUBLE:
+ return Double.class;
+
+ case Types.DATE:
+ return java.sql.Date.class;
+
+ case Types.DECIMAL:
+ case Types.NUMERIC:
+ return java.math.BigDecimal.class;
+
+ case Types.TIMESTAMP:
+ return java.sql.Timestamp.class;
+
+ default:
+ return Object.class;
+ }
+ }
+
+ public void setEditable(boolean editable)
+ {
+ isEditable = editable;
+ }
+
+ public boolean isCellEditable(int row, int column)
+ {
+ if (isEditable)
+ return metaData.isWritable(column);
+ else
+ return false;
+ }
+
+ public int getColumnCount() {
+ return columnNames.length;
+ }
+
+ // Data methods
+
+ public int getRowCount() {
+ return rows.size();
+ }
+
+ public Object getValueAt(int aRow, int aColumn)
+ {
+ Vector row = (Vector)rows.elementAt(aRow);
+ Object value = row.elementAt(aColumn);
+ return dbRepresentation(aColumn, value, true);
+ }
+
+ public Object getObjectAt(int aRow, int aColumn)
+ {
+ Vector row = (Vector)rows.elementAt(aRow);
+ return row.elementAt(aColumn);
+ }
+
+ private String dbRepresentation(int column, Object value, boolean isDecimalParsingWanted)
+ {
+ int type;
+ int scale;
+ double db;
+ String str;
+
+ if (metaData == null)
+ return value.toString();
+
+ if (value == null||value.equals(""))
+ return " ";
+
+ type = metaData.getColumnType(column+1);
+ scale = metaData.getScale(column+1);
+
+ switch(type)
+ {
+ case Types.SMALLINT:
+ int int_value = Short.MIN_VALUE;
+ if (value instanceof Short)
+ int_value = ((Short) value).shortValue();
+ else
+ if (value instanceof Integer)
+ int_value = ((Integer) value).intValue();
+ if (int_value == Short.MIN_VALUE)
+ return (" ");
+ return value.toString();
+ case Types.INTEGER:
+ if (!(value instanceof Integer))
+ return value.toString();
+ if (((Integer) value).intValue() == Integer.MIN_VALUE)
+ return (" ");
+ return value.toString();
+ case Types.DOUBLE:
+ if (isDecimalParsingWanted)
+ {
+ if (((Double) value).isNaN())
+ return " ";
+ nf.setMinimumFractionDigits(scale); // r.b. Nachkommastellen setzen
+ nf.setGroupingUsed(true);
+ //df.setDecimalSeparatorAlwaysShown(true);
+ //df.applyLocalizedPattern("#.#00,0#");
+ if (scale > 3)
+ nf.setMaximumFractionDigits(3); // r.b. Nachkommastellen setzen
+ return nf.format((Double) value);
+ }
+ else
+ return value.toString();
+ case Types.DECIMAL:
+ case Types.NUMERIC:
+ if (isDecimalParsingWanted)
+ {
+ db = ((BigDecimal) value).doubleValue();
+ nf.setGroupingUsed(true);
+ if (db == Double.NaN)
+ return " ";
+ //MB bigdecimal kann immer >65000 Nachkommastellen haben, wird immer auf 5 gesetzt
+ //bei Studiabfragen nach Abschlüssen, ist wahrscheinlich ganz gut, dass ,00 verschwindet (wenngleich gewichtete Fälle)
+ //bei Cob abfragen wäre schön
+ //if (scale > 5) nf.setMaximumFractionDigits(5); // r.b. Nachkommastellen setzen
+ //else nf.setMinimumFractionDigits(scale); // r.b. Nachkommastellen setzen
+ //, einfach mal fest von 2 ausgehen
+ nf.setMaximumFractionDigits(2);
+ nf.setMinimumFractionDigits(2);
+ //df.setDecimalSeparatorAlwaysShown(true);
+ //df.applyLocalizedPattern("#.#00,0#");
+ return nf.format(db);
+ }
+ else
+ return value.toString();
+ case Types.BIT:
+ return ((Boolean)value).booleanValue() ? "1" : "0";
+ case Types.DATE:
+ str = SxDate.toString((java.sql.Date) value);
+ if (str.length() == 0)
+ return (" ");
+ return str;
+ case Types.TIMESTAMP:
+ str = ((Timestamp) value).toString();
+ if (str.length() == 0)
+ return (" ");
+ return str;
+ default:
+ if (value.toString().length() == 0)
+ return (" ");
+ return value.toString();
+ }
+ }
+
+ private Object tableRepresentation(int column, Object value)
+ {
+ int type;
+
+ if (value == null)
+ {
+ return "";
+ }
+
+ if (metaData == null)
+ return value;
+
+ type = metaData.getColumnType(column+1);
+
+ switch(type)
+ {
+ case Types.SMALLINT:
+ {
+ try
+ {
+ return new Short (value.toString());
+ }
+ catch (NumberFormatException e)
+ {
+ System.err.println ("tableRepresentation: ERROR: " + value.toString());
+ return "";
+ }
+ }
+ case Types.INTEGER:
+ {
+ try
+ {
+ return new Integer (value.toString());
+ }
+ catch (NumberFormatException e)
+ {
+ System.err.println ("tableRepresentation: ERROR: " + value.toString());
+ return "";
+ }
+ }
+ case Types.DOUBLE:
+ case Types.FLOAT:
+ {
+ try
+ {
+ Number new_number = nf.parse(value.toString());
+ Double new_double = new Double(new_number.doubleValue());
+ return new_double;
+ }
+ catch (ParseException e)
+ {
+ System.err.println ("tableRepresentation: ERROR parse: Double=" + value.toString());
+ return "";
+ }
+ }
+ case Types.DECIMAL:
+ {
+ try
+ {
+ Number new_number = nf.parse(value.toString());
+ BigDecimal new_dec = new BigDecimal(new_number.doubleValue());
+ return new_dec;
+ }
+ catch (ParseException e)
+ {
+ System.err.println ("tableRepresentation: ERROR parse: BigDecimal=" + value.toString());
+ return "";
+ }
+ }
+ case Types.BIT:
+ return new Boolean (value.toString());
+ case Types.DATE:
+ return SxDate.getDate(value.toString());
+ case Types.TIMESTAMP:
+ return Timestamp.valueOf(value.toString());
+ default:
+ return value;
+ }
+
+ }
+
+ public void setValueAt(Object value, int row, int column)
+ {
+ try
+ {
+ String tableName = "info_usr"; // r.b. metaData.getTableName(column+1);
+ // Some of the drivers seem buggy, tableName should not be null.
+ if (tableName == null)
+ {
+ System.err.println("Table name returned null.");
+ }
+ String colName = getColumnName(column);
+
+ Object new_value = tableRepresentation(column, value);
+ if (new_value == null)
+ throw new SQLException ("conversion error");
+
+ System.err.println ("column: " + colName + ", value: " + new_value);
+ String query =
+ "update "+tableName+
+ " set "+colName+" = " + "'" + dbRepresentation(column, new_value, true) + "'" +
+ " where ";
+ // We don't have a model of the schema so we don't know the
+ // primary keys or which columns to lock on. To demonstrate
+ // that editing is possible, we'll just lock on everything.
+ for(int col = 0; col= 0; b--)
+
+ rpixelarray[c][(int)(Math.abs(a*turnw+turnw/2-(m*b)))]=tpixelarray[a*turnw+turnw/2-b];
+
+
+
+ for (a = 0; a < turnh; a++)
+
+ {
+
+ for (b = 0; b < turnw/2; b++)
+
+ {
+
+ rpixelarray[c][(int)(Math.abs(a*turnw+turnw/2+(m*b)))]=tpixelarray[a*turnw+turnw/2+b];
+
+ }
+
+ }
+
+
+
+ imagearray[c] = createImage(new MemoryImageSource(turnw,turnh,rpixelarray[c],0,turnw));
+
+
+
+ for (a = 0; a < turnh; a++)
+
+ for (b = 0; b < turnw; b++)
+
+ helpimagearray[c][a*turnw+b] = rpixelarray[c][a*turnw+turnw-b-1];
+
+
+
+ imagearray2[c] = createImage(new MemoryImageSource(turnw,turnh,helpimagearray[c],0,turnw));
+
+
+
+ phi+=phistep;
+
+ if (phi > (Math.PI)) phi %= Math.PI;
+
+ }
+
+
+
+ count=0;
+
+ for (int i = 0; i < steps; i++)
+
+ {
+
+ images.insertElementAt(new ImageIcon (imagearray[i]), count);
+
+ count++;
+
+ }
+
+ for (int i = 0; i < steps; i++)
+
+ {
+
+ images.insertElementAt(new ImageIcon (imagearray2[i]), count);
+
+ count++;
+
+ }
+
+
+
+ // *******************************************************
+
+ // * Background-Bild erzeugen
+
+ // *******************************************************
+
+ Image bg_img;
+
+ int[] bg_pixels = new int [imageW * imageH];
+
+ int bg_colorint = bg_color.getRGB();
+
+
+
+ for (int i = 0; i < imageW * imageH; i++)
+
+ bg_pixels[i] = bg_colorint;
+
+
+
+ bg_img = createImage(new MemoryImageSource(imageW, imageH, bg_pixels, 0, imageW));
+
+ bg = new ImageIcon (bg_img);
+
+
+
+ bg_pixels = null;
+
+ rpixelarray = null;
+
+ helpimagearray = null;
+
+ imagearray = null;
+
+ imagearray2 = null;
+
+
+ }
+
+
+
+ public void paint(Graphics g)
+
+ {
+
+
+
+ if (images.size() > 0)
+
+ {
+
+ if (aktImage > count - 1)
+
+ aktImage=0;
+
+ image = (ImageIcon) images.elementAt(aktImage);
+
+
+
+ if (image != null)
+
+ g.drawImage (image.getImage(), imageX, imageY, bg_color, this);
+
+ }
+
+
+
+
+
+ }
+
+
+
+ public Dimension getMinimumSize() {
+
+ return new Dimension(imageW + imageX,imageH + imageY);
+
+ }
+
+
+
+ public Dimension getMaximumSize() {
+
+ return new Dimension(imageW + imageX,imageH + imageY);
+
+ }
+
+
+
+ public Dimension getPreferredSize() {
+
+ return new Dimension(imageW + imageX,imageH + imageY);
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxMask.java b/src/de/superx/applet/SxMask.java
new file mode 100644
index 0000000..babea98
--- /dev/null
+++ b/src/de/superx/applet/SxMask.java
@@ -0,0 +1,2440 @@
+package de.superx.applet;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.Rectangle;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.sql.SQLException;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.util.Calendar;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.TimeZone;
+import java.util.Vector;
+
+import javax.help.CSH;
+import javax.help.HelpBroker;
+import javax.help.HelpSet;
+import javax.swing.BorderFactory;
+import javax.swing.BoxLayout;
+import javax.swing.Icon;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JComponent;
+import javax.swing.JDialog;
+import javax.swing.JEditorPane;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JRootPane;
+import javax.swing.JScrollBar;
+import javax.swing.JScrollPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.JToolBar;
+import javax.swing.JTree;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+
+import de.memtext.util.ClipboardUtils;
+import de.memtext.util.DateUtils;
+import de.memtext.util.WindowUtils;
+import de.memtext.widgets.HorizontalBox;
+import de.memtext.widgets.VerticalBox;
+import de.memtext.widgets.WarningMessage;
+import de.superx.common.DBServletException;
+import de.superx.common.FieldContainer;
+import de.superx.common.Sichten;
+import de.superx.common.Sichtgruppe;
+import de.superx.common.SxResultRow;
+import de.superx.common.SxUser;
+
+/**
+ * SuperX-Hauptmaske, mit dem Buttons für Anmelden, Kopieren, Drucken etc und
+ * den Registerkarten Themenauswahl, Maske und Ergebnistabelle.
+ *
+ * @version 2.0 01-01-02
+ * @author Rainer Behr, erweitert von Marlies Winterstein, Meikel Bisping
+ */
+
+public class SxMask extends JPanel implements ComponentListener {
+
+
+ private static final long serialVersionUID = 1L;
+ private static final Font SMALL_BOLD_FONT = new Font("SansSerif",
+ Font.BOLD, 10);
+ private static final Font NORMAL_BOLD_FONT = new Font("SansSerif",
+ Font.BOLD, 12);
+ private static final Font NORMAL_FONT = new Font("SansSerif", Font.PLAIN,
+ 12);
+ private static final Font SMALL_FONT = new Font("SansSerif", Font.PLAIN, 10);
+
+ private SxUser user = new SxUser("default"); //kein Mandantenbetrieb für Applet
+ private static boolean isApplet = false;
+ private static boolean isLogin = false;
+ private boolean helpsetfound = false;
+ private static int countFrame = 0;
+ private boolean dummyLogin = false;
+ private JFrame sxFrame;
+ private SxMask sxMask; // r.b. 'this'
+ private SxLogoPanel logo;
+
+ private Hashtable sx_map = null;
+
+ private Thread activeThread = null;
+ private boolean isInterrupted = false;
+
+ private JTabbedPane tabPane;
+ private ConnectionDlg connectionDlg;
+ //Um Erläuterungen zu Masken anzuzeigen
+ private ExplanationFrame explanationFrame = new ExplanationFrame();
+ private JButton btnExplanation = new JButton("Erläuterung");
+
+ private MaskeninfoElement selectedMaskeninfoElement = new MaskeninfoElement();
+ private String sxTitle, serverURL, logToKonsole;
+ private ParameterPanel parameterPanel = new ParameterPanel();
+ // private Vector V_sachgeb = new Vector();
+ private Vector V_thema = new Vector(100);
+
+ private SxTablePanel sxTablePanel = null;
+
+ private Integer lastMaskeID = new Integer(-1);
+ private JButton dbBtn, openBtn, searchBtn, resetBtn, stopBtn,
+ themenAuswahlBtn;
+ private JButton cloneBtn, copyBtn, saveBtn, printBtn, infoBtn, passwdBtn;
+
+ private JScrollPane themenwahlscroll;
+ private JTree themenwahltree;
+
+ private GridBagConstraints gbctree = new GridBagConstraints();
+ private GridBagLayout gbl = new GridBagLayout();
+ JEditorPane terlaeuterung = new JEditorPane("text/html", "");
+
+ private JButton suchAbfrBtn, themenStandBtn, helpBtn;
+ private SxThemenbaum sxThemenbaum;
+ private JLabel themenStandLabel, aktuelleNachrichtL;
+
+ private SxForm maskeForm;
+
+ private JPanel sxSpanel;
+ private JTextField statusField;
+
+ private HelpSet hs;
+ private HelpBroker hb;
+ //String helpItemString = "tut.starttoc";
+ private String helpItemString = "SuperXAnleitung.htm";
+
+ class CloneListener implements ActionListener, Runnable {
+ CloneListener clone_th;
+
+ CloneListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ if (isLogin == false)
+ return;
+ clone_th = new CloneListener();
+
+ new Thread(clone_th).start();
+ }
+
+ public void run() {
+ SxMask cloneM = new SxMask("SuperX", sx_map, isApplet);
+ cloneM.setUser(user);
+ }
+ }
+
+ class OpenListener implements ActionListener, Runnable {
+ OpenListener open_th;
+
+ OpenListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ //Wint Hilfe entsprechend setzen
+ if (selectedMaskeninfoElement.getTid() != null) {
+ helpItemString = "M" + selectedMaskeninfoElement.getTid()
+ + ".htm";
+ //System.out.println("helpItemString: " + helpItemString);
+ }
+ //helpItemString = "build.build";
+ //CSH.setHelpIDString(openBtn,helpItemString);
+ if (helpsetfound) {
+ CSH.setHelpIDString(helpBtn, helpItemString);
+ hb.enableHelpKey(getRootPane(), helpItemString, hs);
+ }
+
+ open_th = new OpenListener();
+
+ activeThread = new Thread(open_th);
+ activeThread.start();
+ }
+
+ public void run() {
+
+ // System.err.println ("OpenListener: " + openBtn.getActionCommand
+ // ());
+ if (selectedMaskeninfoElement.getTid() == null) {
+ getToolkit().beep();
+ statusField.setText("Bitte ein Thema auswählen !");
+ return;
+ }
+
+ maskeOeffnen();
+
+ activeThread = null;
+
+ }
+ }
+
+ class ConnectListener implements ActionListener, Runnable {
+
+ private ConnectListener connect_th;
+ private int mode;
+
+ ConnectListener(int mode) {
+ this.mode = mode;
+ }
+
+ public void actionPerformed(ActionEvent e) {
+
+ dbBtn.setEnabled(false);
+ int rc = -1;
+ if (isLogin && countFrame > 1)
+ rc = 0;
+ else
+ rc = showConnectionDialog();
+
+ if (rc < 0 || rc == 2) {
+ dbBtn.setEnabled(true);
+ return;
+ }
+ DefaultTreeModel model =(DefaultTreeModel) themenwahltree.getModel();
+ DefaultMutableTreeNode root=(DefaultMutableTreeNode) themenwahltree.getModel().getRoot();
+ root.removeAllChildren();
+ model.reload(root);
+ connect_th = new ConnectListener(rc);
+
+ activeThread = new Thread(connect_th);
+ activeThread.start();
+ }
+
+ public void run() {
+
+ //ist ja An/Ummeldung daher
+ SuperX.isAuthentificationFound = false;
+ initUser(mode);
+ }
+ }
+
+ class SearchListener implements ActionListener, Runnable {
+ SearchListener search_th;
+
+ SearchListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ //Wint Hilfe entsprechend setzen
+ if (selectedMaskeninfoElement.getTid() != null) {
+ helpItemString = "T" + selectedMaskeninfoElement.getTid()
+ + ".htm";
+ //System.out.println("helpItemString: " + helpItemString);
+ }
+ //helpItemString = "debug.overview";
+ if (helpsetfound) {
+ CSH.setHelpIDString(helpBtn, helpItemString);
+ hb.enableHelpKey(getRootPane(), helpItemString, hs);
+ }
+
+ search_th = new SearchListener();
+ activeThread = new Thread(search_th);
+ activeThread.start();
+ }
+
+ public void run() {
+ try {
+ logo.start();
+
+ isInterrupted = false;
+
+ searchBtn.setEnabled(false);
+ resetBtn.setEnabled(false);
+
+ Integer fixedColumns = new Integer(selectedMaskeninfoElement
+ .getXilProps().getProperty("fixed_columns", "1"));
+ sxTablePanel.setFixedColumns(fixedColumns.intValue());
+
+ String hinweis = selectedMaskeninfoElement.getHinweis();
+
+ if (hinweis != null) {
+ if (hinweis.startsWith("<>")) {
+ hinweis = hinweis.substring(7, hinweis.length());
+ try {
+ //in Generate-sql wird auch Stand von Sichtfeldern
+ // gesetzt
+ String sql = SxUtils
+ .generateSQL(maskeForm, hinweis);
+ SxSQL.executeQuery(sql);
+ SxResultRow r=(SxResultRow) SxSQL.getResult().first();
+ hinweis = (String) r.get(0);
+ } catch (Exception e) {
+ hinweis = null;
+ }
+ }
+ //System.out.println("setting Hinweis:"+Hinweis);
+
+ }
+ maskeForm.setHinweis(hinweis);
+ //throws an exception if something's wrong
+ maskeForm.checkFields();
+
+ // Generate SQL
+ boolean isTemplate = selectedMaskeninfoElement.getSelectStmt()
+ .toUpperCase().indexOf("FREEMARKER TEMPLATE") > -1;
+
+ String selectString = SxUtils.generateSQL(maskeForm,
+ selectedMaskeninfoElement.getSelectStmt() + "\n"
+ + selectedMaskeninfoElement.getCleanupStmt());
+
+ if (isTemplate) {
+ //Trickmethode!!
+ HashMap map = maskeForm.getHashMap(selectedMaskeninfoElement.getTid());
+
+ selectString = SxSQL.templateProcessor.process("Maske "
+ + selectedMaskeninfoElement.getName(),
+ selectString,
+
+ map, (String) SxDefaults.getPropertyValue("SxDB"));
+ }
+ statusField.setBackground(Color.yellow);
+ statusField.setText("Bitte warten ..");
+
+ // Default-Values
+ //Wint, vorübergehend zum Testen der Abfragen, Merken der Werte
+ // ausschalten
+ //Gedächtnis!
+ maskeForm.rememberSelectionsAsDefaults();
+
+ // Parameterliste setzen
+ parameterPanel.setParams(maskeForm.getParamList(user.getName(),
+ true));
+ parameterPanel.setStand(selectedMaskeninfoElement
+ .getStandString());
+ parameterPanel.setAbfragename(selectedMaskeninfoElement
+ .getName());
+ //JLabel F_parameter = (JLabel)
+ // tabelleForm.getComp("F_parameter");
+ //F_parameter.setText();
+ // Parameterliste
+
+ stopBtn.setEnabled(true);
+
+ SxSQL.executeAll("--Abfrage\n" + selectString);
+
+ if (SxSQL.getRowCount() == 0)
+ lastMaskeID = new Integer(-1);
+
+ if (!selectedMaskeninfoElement.isSqlInHeaders()
+ && selectedMaskeninfoElement.getTid().equals(
+ lastMaskeID))
+ sxTablePanel.setData(SxSQL.getResultVector());
+ else {
+ Vector headerVector = selectedMaskeninfoElement
+ .getHeaderVector();
+ Vector resultVector = SxSQL.getResultVector();
+ SxSQLMetaData metaData = SxSQL.getResultSetMetaData();
+
+ if (selectedMaskeninfoElement.isSqlInHeaders())
+ runSqlInTableHeaders(headerVector);
+ sxTablePanel.setData(resultVector, headerVector,
+ selectedMaskeninfoElement.getWidthVector(),
+ //selectedMaskeninfoElement.getSpaltenExplanations(),
+ metaData);
+ }
+ if (SxSQL.getRowCount() > 0)
+ lastMaskeID = selectedMaskeninfoElement.getTid();
+
+ //if (cleanupString.length () > 0)
+ // SxSQL.execute (cleanupString);
+ //MB }
+ String nachr = SxSQL.getAktuelleNachricht();
+ if (nachr != null && !nachr.equals("")) {
+ //aktuelleNachrichtL.setText(""+nachr+"");
+ //aktuelleNachrichtL.setBackground(java.awt.Color.orange);
+ statusField
+ .setText("Bei der Abfrage ist ein SQL-Fehler aufgetreten (siehe Java-Konsole)");
+ System.out.println("SQL-Fehler: " + nachr);
+ }
+
+ //MB vertikal Scrollbar nach oben
+ JScrollBar vsbar = sxTablePanel.getScrollPane()
+ .getVerticalScrollBar();
+ vsbar.setValue(vsbar.getMinimum());
+ tabPane.setSelectedIndex(2);
+ sxMask.repaint();
+ statusField.setBackground(Color.white);
+ if (nachr == null || nachr.length() < 1)
+ statusField.setText(sxTablePanel.getTable().getRowCount()
+ + " Sätze gefunden");
+ } catch (SQLException ex) {
+ String msg = ex.toString();
+ // System.err.println("msg: " + msg);
+ ex.printStackTrace();
+ statusField.setText(msg.substring(msg.lastIndexOf(":") + 1));
+ ClipboardUtils.setContents(msg, null);
+ statusField.setBackground(Color.red);
+
+ try {
+ // Bei Fehler neue Verbindung --> temp. Tabellen werden
+ // geloescht
+ SxSQL.close();
+
+ ImageIcon disconnect_icon = (ImageIcon) sx_map
+ .get("disconnect");
+ dbBtn.setIcon(disconnect_icon);
+ dbBtn.setDisabledIcon(disconnect_icon);
+ if (countFrame == 1)
+ passwdBtn.setEnabled(false);
+ passwdBtn.setVisible(SuperX.remoteUser == null);
+
+ openBtn.setEnabled(false);
+ //TODO logging eintrag über Maskenaufruf
+ /*
+ * SxSQL.setUrl(serverURL); SxSQL.setLogMode(logToKonsole);
+ * SxSQL.check(user);
+ */
+ lastMaskeID = new Integer(-1);
+
+ statusField.setBackground(Color.white);
+ //statusField.setText("DB-Verbindung erneuert");
+
+ ImageIcon connect_icon = (ImageIcon) sx_map.get("connect");
+ dbBtn.setIcon(connect_icon);
+ dbBtn.setDisabledIcon(connect_icon);
+ if (countFrame == 1)
+ passwdBtn.setEnabled(true);
+ passwdBtn.setVisible(SuperX.remoteUser == null);
+
+ openBtn.setEnabled(true);
+ } catch (Exception ex2) {
+ String msg2 = ex2.toString();
+ ex2.printStackTrace();
+ statusField.setText(msg2
+ .substring(msg2.lastIndexOf(":") + 1));
+ ClipboardUtils.setContents(msg2, null);
+ }
+ } catch (Exception ex_input) {
+ String msg = ex_input.toString();
+ ex_input.printStackTrace();
+ System.out.println(ex_input.toString());
+ JOptionPane.showMessageDialog(sxMask, msg.substring(msg
+ .lastIndexOf(":") + 1), "Eingabefehler",
+ JOptionPane.ERROR_MESSAGE);
+ ClipboardUtils.setContents(msg, null);
+ }
+
+ searchBtn.setEnabled(true);
+ resetBtn.setEnabled(true);
+ stopBtn.setEnabled(false);
+ logo.stop();
+
+ JRootPane root = sxMask.getRootPane();
+ root.setDefaultButton(searchBtn); // DefaultButton setzen
+
+ sxMask.repaint();
+
+ activeThread = null;
+
+ }
+
+ private void runSqlInTableHeaders(Vector headerVector) {
+ //selectedMaskeninfoElement.cloneExplanations();
+ for (int i = 0; i < headerVector.size(); i++) {
+ String aHeader = headerVector.get(i).toString();
+ String query;
+ if (aHeader.trim().startsWith("<>")) {
+ try {
+ query = SxUtils.generateSQL(maskeForm, aHeader
+ .substring(7));
+ SxSQL.executeQuery(query);
+ Vector row0 = (Vector) SxSQL.getResultVector().get(0);
+ String newHeader = row0.get(0).toString();
+ headerVector.remove(i);
+ headerVector.add(i, newHeader);
+ selectedMaskeninfoElement.adaptExplanation(i,newHeader);
+ } catch (SQLException e) {
+ WarningMessage.show(sxMask,
+ "Spaltenüberschrift mit dem Ausdruck\n"
+ + aHeader
+ + "\nkonnte nicht aufgebaut werden",
+ "SuperX");
+ ClipboardUtils.setContents(e.toString(), null);
+ }
+
+ }
+ }
+
+ }
+ }
+
+ class StopListener implements ActionListener {
+ StopListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ stopBtn.setEnabled(false);
+
+ try {
+ logo.start();
+
+ statusField.setBackground(Color.red);
+ statusField.setText("Abbrechen ..");
+
+ if (activeThread != null) {
+ activeThread.interrupt();
+ isInterrupted = true;
+ SxSQL.cancel(); // Methode not supplied by Informix JDBC
+ isInterrupted = true;
+ searchBtn.setEnabled(true);
+
+ }
+ } catch (Exception ex) {
+ String msg = ex.toString();
+ // System.err.println("msg: " + msg);
+ ex.printStackTrace();
+ statusField.setText(msg.substring(msg.lastIndexOf(":") + 1));
+ ClipboardUtils.setContents(msg, null);
+ }
+
+ stopBtn.setEnabled(true);
+
+ logo.stop();
+ }
+
+ }
+
+ class ResetListener implements ActionListener {
+ ResetListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+
+ resetBtn.setEnabled(false);
+ String fielddefault = new String();
+ String fieldname = new String();
+ for (int i = 0; i < selectedMaskeninfoElement.getFelderinfos()
+ .size(); i++) {
+ Vector V_field = (Vector) selectedMaskeninfoElement
+ .getFelderinfos().elementAt(i);
+ fieldname = (String) V_field.elementAt(1);
+ if (fieldname != null)
+ fieldname = fieldname.trim();
+
+ fielddefault = (String) V_field.elementAt(14);
+ if (fielddefault != null)
+ fielddefault = fielddefault.trim();
+
+ SxField field = maskeForm.getField("F_" + fieldname);
+
+ if (field!=null&&field.hasSichten())
+ field.clearSichtSelections();
+
+
+ // Default-Wert aus Tab. 'felderinfo' setzen
+ if (fielddefault != null) {
+
+ if (fielddefault.startsWith("<>")) {
+ try {
+ String stmt = fielddefault.substring(7);
+ SxSQL.executeAll(stmt);
+
+ Vector V_default = (Vector) SxSQL.getResultVector()
+ .elementAt(0);
+ Object key, value;
+ if (V_default.size() == 2) {
+ key = V_default.elementAt(0);
+ field.setKey(key);
+ value = V_default.elementAt(1);
+ if (value instanceof java.sql.Date)
+ value = SxDate
+ .toString((java.sql.Date) value);
+ field.setText(value.toString());
+ }
+ if (V_default.size() == 1) {
+ field.setKey(new Integer("-1"));
+ value = V_default.elementAt(0);
+ if (value instanceof java.sql.Date)
+ value = SxDate
+ .toString((java.sql.Date) value);
+ field.setText(value.toString());
+ }
+ } catch (Exception ex) {
+ System.err.println(ex.toString());
+ ClipboardUtils.setContents(ex.toString(), null);
+ }
+ } else {
+ if (field != null)
+ {field.setText(fielddefault);
+ field.setKey(new Integer(-1));
+ }
+ }
+ }
+
+ }
+ maskeForm.rememberSelectionsAsDefaults();
+ resetBtn.setEnabled(true);
+
+ logo.stop();
+
+ }
+ }
+
+ class CopyListener implements ActionListener, Runnable {
+ CopyListener copy_th;
+
+ CopyListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ copy_th = new CopyListener();
+
+ new Thread(copy_th).start();
+ }
+
+ public void run() {
+
+ if (sxTablePanel == null)
+ return;
+ StringBuffer data = new StringBuffer();
+ data.append(SxDefaults.getPropertyValue("SxTitle"));
+ data.append("\n\n");
+
+ data.append(selectedMaskeninfoElement.getName());
+ data.append("\n");
+ data.append(selectedMaskeninfoElement.getStand());
+ data.append("\n\nEingabeparameter:\n");
+ data.append(maskeForm.getParamList(user.getName(), false));
+ data.append("\n\n");
+ //Wint "\n" in Überschrift streichen
+ String s1 = SxUtils.replace(sxTablePanel.getText(), "\\n", "");
+ s1 = SxUtils.replace(s1, "\"", "'"); //wg. Problemen mit Excel
+ data.append(s1);
+ ClipboardUtils.setContents(data, null);
+
+ }
+ }
+
+ class SaveDlgListener implements ActionListener {
+ SaveDlgListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ try {
+ JFileChooser file_dlg = new JFileChooser();
+ file_dlg.setDialogType(JFileChooser.SAVE_DIALOG);
+ SaveListener savel = new SaveListener(file_dlg);
+ file_dlg.addActionListener(savel);
+ file_dlg.showDialog(sxMask, "Sichern ..");
+ } catch (Exception ex) {
+ ClipboardUtils.setContents(ex.toString(), null);
+ JOptionPane.showMessageDialog(sxMask, ex.toString(), "Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ }
+ }
+ }
+
+ class SaveListener implements ActionListener, Runnable {
+ SaveListener save_th;
+ JFileChooser file_dlg;
+
+ SaveListener(JFileChooser aFile_dlg) {
+ file_dlg = aFile_dlg;
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ if (e.getActionCommand().equals("CancelSelection"))
+ return;
+
+ save_th = new SaveListener(file_dlg);
+
+ new Thread(save_th).start();
+ }
+
+ public void run() {
+ File out_file = file_dlg.getSelectedFile();
+
+ //if (out_file != null)
+ // sxTablePanel.saveTable(out_file, sxMask);
+ }
+ }
+
+ class PrintListener implements ActionListener, Runnable {
+ PrintListener print_th;
+
+ PrintListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ print_th = new PrintListener();
+
+ new Thread(print_th).start();
+ }
+
+ public void run() {
+ try {
+ printBtn.setEnabled(false);
+
+ sxTablePanel.printTable(sxMask);
+
+ } catch (Exception ex) {
+ String msg = ex.toString();
+ ClipboardUtils.setContents(msg, null);
+ statusField.setText(msg.substring(msg.lastIndexOf(":") + 1));
+ }
+
+ printBtn.setEnabled(true);
+ }
+ }
+
+ /*
+ * //Wint class HelpListener implements ActionListener, Runnable {
+ * HelpListener help_th;
+ *
+ * HelpListener(HelpBroker mainhb) { new CSH.DisplayHelpFromSource(mainhb); };
+ *
+ * public void actionPerformed(ActionEvent e) { help_th = new
+ * HelpListener(hb);
+ *
+ * new Thread(help_th).start(); }
+ *
+ * public void run() { try { helpBtn.setEnabled(false);
+ * //helpBtn.addActionListener(new CSH.DisplayHelpFromSource(hb)); String
+ * p_maske = SxMask.this.getName(); if (activeMaskeID != null)
+ * System.out.println("ID: " + activeMaskeID.toString().toString());
+ * System.out.println(p_maske); CSH.setHelpIDString(getRootPane(),
+ * "edit.editsource"); //helpBtn.addActionListener(new
+ * CSH.DisplayHelpAfterTracking(hb)); helpBtn.addActionListener(new
+ * CSH.DisplayHelpFromSource(hb)); } catch (Exception ex) { String msg =
+ * ex.toString(); statusField.setText(msg.substring(msg.lastIndexOf(":") +
+ * 1)); }
+ *
+ * helpBtn.setEnabled(true); } }
+ */
+
+ class PwdListener implements ActionListener {
+ JFrame frame;
+
+ PwdListener(JFrame frame) {
+ this.frame = frame;
+ };
+
+ public void actionPerformed(ActionEvent e) {
+ int rc = -1;
+ //Hilfe für Paßwortänderung
+ if (helpsetfound) {
+ helpItemString = "Anmelden.htm";
+ CSH.setHelpIDString(passwdBtn, helpItemString);
+ hb.enableHelpKey(passwdBtn, helpItemString, hs);
+ hb.enableHelp(passwdBtn, helpItemString, hs);
+ //CSH.setHelpIDString(helpBtn,helpItemString);
+ }
+ SxPasswdChangeDlg passwdChangeDlg = new SxPasswdChangeDlg(frame, "Passwort ändern");
+ passwdChangeDlg.setNewPasswordChecker(SxSQL.newPasswordChecker);
+
+ // if (SxSQL.isAdmin()) {
+ // passwdChangeDlg.setUsernameFieldEnabled(true);
+ // passwdChangeDlg.setCheckOldPasswdWanted(false);
+ // } else {
+ passwdChangeDlg.setUsername(user.getName());
+ passwdChangeDlg.setUsernameFieldEnabled(false);
+ passwdChangeDlg.setCheckOldPasswdWanted(true);
+ // }
+
+ passwdChangeDlg.show();
+ if (!passwdChangeDlg.wasOkSelected())
+ return;
+
+ try {
+
+ WindowUtils.setWaitCursor(statusField, true);
+ //admin könnte auch von anderen Usern dass Passwort
+ //ändern, darum wird nicht direkt user genommen,
+ //sondern userToBeChanged
+ SxUser userToBeChanged = null;
+ if (user.getName().equals(passwdChangeDlg.getUsername()))
+ userToBeChanged = user;
+ else
+ userToBeChanged = new SxUser("default",
+ passwdChangeDlg.getUsername(), passwdChangeDlg.getOldPasswd());
+ SxSQL.storePwd(userToBeChanged, passwdChangeDlg.getNewPasswd(),
+ true); //kein Mandantenbetrieb bei Applet
+ statusField.setBackground(Color.white);
+ statusField.setText("Kennwort geändert");
+ passwdChangeDlg.clear();
+
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ String msg = ex.toString();
+ ClipboardUtils.setContents(msg, null);
+ msg = msg.substring(msg.lastIndexOf(":") + 1);
+ statusField.setBackground(Color.red);
+ statusField.setText(msg);
+
+ JOptionPane.showMessageDialog(sxMask, msg, "Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ statusField.setBackground(Color.white);
+ statusField.setText("");
+ }
+ finally
+ {
+ WindowUtils.setWaitCursor(statusField, false);
+ }
+
+ }
+
+ }
+
+ class SuchAbfrListener implements ActionListener, Runnable {
+ SuchAbfrListener SuchAbfr_th;
+ JTree tree;
+
+ SuchAbfrListener(JTree ltree) {
+ tree = ltree;
+ };
+
+ public void actionPerformed(ActionEvent e) {
+
+ SuchAbfr_th = new SuchAbfrListener(tree);
+
+ new Thread(SuchAbfr_th).start();
+ }
+
+ public void run() {
+ // AbfrageSuchen();
+ JTree tree = themenwahltree;
+ String such = JOptionPane.showInputDialog(null,
+ "Suche nach Abfragen:", "SuperX",
+ JOptionPane.QUESTION_MESSAGE);
+ if (such.length() < 1)
+ return;
+ such = such.toLowerCase();
+ String teststring;
+ TreePath tp;
+ boolean gefunden = false;
+ DefaultMutableTreeNode root, test, ausgesucht;
+ ausgesucht = null;
+ Vector treffer = new Vector();
+ Vector treffernodes = new Vector();
+
+ //alle Knoten durchlaufen
+ root = (DefaultMutableTreeNode) tree.getModel().getRoot();
+ Enumeration en = root.breadthFirstEnumeration();
+ while (en.hasMoreElements()) {
+ test = (DefaultMutableTreeNode) en.nextElement();
+ teststring = test.toString().toLowerCase();
+
+ if (teststring.indexOf(such) > -1) {
+ //wenn suchString im aktuellen Knoten vorhanden
+ //K
+ treffer.addElement(test.toString());
+ treffernodes.addElement(test);
+ }
+ }
+ if (treffer.size() > 0) {
+ if (treffer.size() > 1) {
+ //mehr als ein Treffer -> Auswahldialog
+ String[] trefferstring = new String[treffer.size()];
+ treffer.copyInto(trefferstring);
+
+ String selectedValue = (String) showBigChoiceDialog(null,
+ "Mehrere Treffer- bitte auswählen...", "SuperX",
+ JOptionPane.INFORMATION_MESSAGE, null,
+ trefferstring, trefferstring[0]);
+
+ if (selectedValue == null)
+ return;
+ gefunden = false;
+ //gewählten Knoten nach Name in Treffernodes-Vektor suchen
+ en = treffernodes.elements();
+ while (en.hasMoreElements() && gefunden == false) {
+ test = (DefaultMutableTreeNode) en.nextElement();
+ if (test.toString().equals(selectedValue)) {
+ ausgesucht = test;
+ gefunden = true;
+ }
+ }
+ }
+ if (ausgesucht == null) //bei treffer.size=1
+ ausgesucht = (DefaultMutableTreeNode) treffernodes
+ .elementAt(0);
+ // collapse all brances + Selection anwählen
+ tree.clearSelection();
+ en = root.depthFirstEnumeration();
+ while (en.hasMoreElements()) {
+ test = (DefaultMutableTreeNode) en.nextElement();
+ tp = new TreePath(test.getPath());
+ if (tree.isExpanded(tp))
+ tree.collapsePath(tp);
+ }
+
+ tp = new TreePath(ausgesucht.getPath());
+
+ tree.clearSelection();
+
+ tree.setSelectionPath(tp);
+ tree.scrollPathToVisible(tp);
+ // tree.makeVisible(tp);
+ //tree.validate();
+ //tree.repaint();
+ } else
+ JOptionPane.showMessageDialog(null, "Keine Treffer!", "SuperX",
+ 1);
+
+ }
+
+ private Object showBigChoiceDialog(Component parentComponent,
+ Object message, String title, int messageType, Icon icon,
+ Object[] selectionValues, Object initialSelectionValue) {
+ JOptionPane pane = new JOptionPane(message, messageType,
+ JOptionPane.OK_CANCEL_OPTION, icon, null, null);
+
+ pane.setWantsInput(true);
+ pane.setSelectionValues(selectionValues);
+ pane.setInitialSelectionValue(initialSelectionValue);
+
+ JDialog dialog = pane.createDialog(parentComponent, title);
+ dialog.setSize(400, 200);
+ pane.selectInitialValue();
+ dialog.show();
+
+ Object value = pane.getInputValue();
+
+ if (value == JOptionPane.UNINITIALIZED_VALUE)
+ return null;
+ return value;
+ }
+ }
+
+ class ThemenStandListener implements ActionListener {
+
+ ThemenStandListener() {
+ };
+
+ public void actionPerformed(ActionEvent e) {
+
+ DateFormat df;
+ String neuerStand = JOptionPane.showInputDialog(null,
+ "Neues Datum eingeben:", "SuperX",
+ JOptionPane.QUESTION_MESSAGE);
+ df = DateFormat.getDateInstance(DateFormat.MEDIUM);
+ // r.b. default Jahr 4-stellig
+ df.setTimeZone(TimeZone.getDefault());
+ df.setLenient(false);
+ String geprueft = null;
+ try {
+ if (neuerStand.endsWith("00")) {
+ switch (neuerStand.charAt(neuerStand.length() - 3)) {
+ case '-':
+ case '.':
+ case '/':
+ neuerStand = neuerStand.substring(0, neuerStand
+ .length() - 2)
+ + "2000";
+ break;
+ }
+ }
+
+ java.util.Date date = df.parse(neuerStand);
+ Calendar calendar = Calendar.getInstance();
+ calendar.setTime(date);
+ int year = calendar.get(Calendar.YEAR);
+ if (year >= 0 && year < 30)
+ calendar.add(Calendar.YEAR, 2000);
+ if (year >= 30 && year < 100)
+ calendar.add(Calendar.YEAR, 1900);
+
+ java.sql.Date adate = new java.sql.Date(calendar.getTime()
+ .getTime());
+
+ //wenn Format nicht OK bleibt geprueft null
+ geprueft = df.format((java.util.Date) adate);
+
+ } catch (ParseException e_parse) {
+ // System.err.println ("SxDate: ERROR: parse: Date != " +
+ // value);
+ } catch (IllegalArgumentException e_arg) {
+ // System.err.println ("SxDate: ERROR: arg: Date != " + value);
+ }
+
+ if (geprueft != null) // Form Ok
+
+ {
+ sxMask.setCursor(new Cursor(Cursor.WAIT_CURSOR));
+
+ themenStandLabel.setText(neuerStand);
+
+ try {
+ installThemenbaum(neuerStand);
+ } catch (SQLException e1) {
+ ClipboardUtils.setContents(e1.toString(), null);
+ WarningMessage.show(sxMask, e1.toString(), "Fehler");
+ }
+ sxMask.validate();
+ sxMask.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
+ } else
+ JOptionPane.showMessageDialog(null, "Ungültige Eingabe!",
+ "SuperX", JOptionPane.ERROR_MESSAGE);
+
+ }
+ }
+
+ class ThemenwahlPanel extends JPanel {
+ ThemenwahlPanel() {
+ super(new BorderLayout());
+ JPanel centerp = new JPanel();
+ GridBagConstraints gbc = new GridBagConstraints();
+ centerp.setLayout(gbl);
+
+ themenStandLabel = new JLabel(DateUtils.getTodayString());
+ themenStandLabel.setFont(SMALL_FONT);
+ JLabel lerlaueterung = new JLabel("Erläuterung");
+ lerlaueterung.setBackground(java.awt.Color.orange);
+ JLabel platzhalterl = new JLabel(" ");
+ JLabel platzhalterr = new JLabel(" ");
+
+ themenStandBtn = new JButton("anderer Stand");
+ themenStandBtn.setFont(SMALL_FONT);
+ themenStandBtn.setToolTipText("Zugriff auf alte Abfragen");
+ ThemenStandListener tsl = new ThemenStandListener();
+ themenStandBtn.addActionListener(tsl);
+ gbc.gridx = 0;
+ gbc.gridy = 0;
+ gbc.gridwidth = 1;
+ gbc.gridheight = 1;
+ gbc.weightx = 0;
+ gbc.weighty = 0;
+
+ gbc.insets = new Insets(10, 2, 2, 0);
+ gbc.fill = GridBagConstraints.NONE;
+ gbc.anchor = GridBagConstraints.CENTER;
+ gbl.setConstraints(platzhalterl, gbc);
+ centerp.add(platzhalterl);
+
+ JPanel pstand = new JPanel();
+ //Stand des Themenbaum erstmal nicht anzeigen
+ //pstand.add(ThemenStandLabel);
+ //pstand.add(ThemenStandBtn);
+
+ gbc.gridx = 1;
+ gbc.gridy = 0;
+ gbl.setConstraints(pstand, gbc);
+ centerp.add(pstand);
+
+ gbc.gridx = 2;
+ gbc.gridy = 0;
+
+ // gbl.setConstraints(ThemenStandBtn, gbc);
+ // centerp.add(ThemenStandBtn);
+
+ gbc.gridx = 2;
+ gbc.gridy = 0;
+ gbl.setConstraints(platzhalterr, gbc);
+ centerp.add(platzhalterr);
+
+ gbc.gridx = 5;
+ gbc.gridy = 0;
+ gbl.setConstraints(lerlaueterung, gbc);
+ centerp.add(lerlaueterung);
+
+ //Pseudo initial-Baum anzeigen
+ DefaultMutableTreeNode dummy = new DefaultMutableTreeNode(
+ "Abfragen");
+ dummy.add(new DefaultMutableTreeNode(""));
+ themenwahltree = new JTree(dummy);
+ TreePath tp = new TreePath(dummy.getPath());
+ themenwahltree.collapsePath(tp);
+ themenwahlscroll = new JScrollPane(themenwahltree);
+ themenwahlscroll
+ .setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+ gbctree.gridx = 0;
+ gbctree.gridy = 1;
+ gbctree.gridwidth = 4;
+ gbctree.gridheight = 4;
+ gbctree.insets = new Insets(0, 0, 0, 0);
+ gbctree.weightx = 100;
+ gbctree.weighty = 100;
+ gbctree.fill = GridBagConstraints.BOTH;
+ gbl.setConstraints(themenwahlscroll, gbctree);
+ centerp.add(themenwahlscroll);
+
+ terlaeuterung.setFont(NORMAL_FONT);
+ terlaeuterung.setEditable(false);
+ terlaeuterung.setAlignmentX(CENTER_ALIGNMENT);
+ JScrollPane erlScroll = new JScrollPane(terlaeuterung);
+ gbc.gridx = 4;
+ gbc.gridy = 1;
+ gbc.gridwidth = 2;
+ gbc.gridheight = 4;
+ gbc.weightx = 100;
+ gbc.weighty = 1000;
+ gbc.fill = GridBagConstraints.BOTH;
+ gbc.insets = new Insets(0, 0, 0, 0);
+ gbl.setConstraints(erlScroll, gbc);
+
+ centerp.add(erlScroll);
+
+ gbc.gridx = 1;
+ gbc.gridy = 5;
+ gbc.gridwidth = 1;
+ gbc.gridheight = 1;
+ gbc.insets = new Insets(5, 0, 5, 0);
+
+ suchAbfrBtn = new JButton("Abfrage suchen");
+ suchAbfrBtn.setFont(SMALL_FONT);
+ suchAbfrBtn.setToolTipText("Suchen von Abfragen mittels Stichwort");
+ SuchAbfrListener sabl = new SuchAbfrListener(themenwahltree);
+ suchAbfrBtn.addActionListener(sabl);
+ //psuchAbfr.add(suchAbfrBtn);
+
+ gbc.gridx = 2;
+ gbc.gridy = 5;
+ gbc.gridwidth = 1;
+ gbc.gridheight = 1;
+ gbc.insets = new Insets(5, 0, 5, 0);
+ gbc.fill = GridBagConstraints.NONE;
+ gbc.weightx = 0;
+ gbc.weighty = 0;
+ gbc.ipadx = 0;
+ gbl.setConstraints(suchAbfrBtn, gbc);
+ centerp.add(suchAbfrBtn);
+
+ JButton anpassenBtn = new JButton("anpassen");
+ anpassenBtn.setVisible(false);
+ anpassenBtn.setFont(SMALL_FONT);
+ gbc.gridx = 4;
+ gbc.gridy = 5;
+ gbc.gridwidth = 1;
+ gbc.gridheight = 1;
+ gbc.insets = new Insets(5, 0, 5, 0);
+ gbc.fill = GridBagConstraints.NONE;
+ gbc.weightx = 0;
+ gbc.weighty = 0;
+ gbl.setConstraints(anpassenBtn, gbc);
+ centerp.add(anpassenBtn);
+
+ aktuelleNachrichtL = new JLabel("");
+ aktuelleNachrichtL.setBackground(java.awt.Color.orange);
+ aktuelleNachrichtL.setVisible(true);
+ aktuelleNachrichtL.setFont(SMALL_FONT);
+ gbc.gridx = 1;
+ gbc.gridy = 6;
+ gbc.gridwidth = 5;
+ gbc.gridheight = 1;
+ gbc.insets = new Insets(5, 0, 5, 0);
+ gbc.fill = GridBagConstraints.NONE;
+ gbc.weightx = 0;
+ gbc.weighty = 0;
+ gbl.setConstraints(aktuelleNachrichtL, gbc);
+ centerp.add(aktuelleNachrichtL);
+
+ JPanel openBtnPanel = new JPanel();
+
+ openBtnPanel.setBorder(BorderFactory.createEtchedBorder());
+
+ openBtn = new JButton("Öffnen");
+ openBtn.setMnemonic(KeyEvent.VK_O);
+ openBtn.addActionListener(new OpenListener());
+ openBtn.setFont(NORMAL_BOLD_FONT);
+ openBtn.setEnabled(false);
+ //Hilfe
+ //helpItemString = "proj.import";
+ helpItemString = "Themaauswhlen.htm";
+ CSH.setHelpIDString(openBtn, helpItemString);
+
+ openBtnPanel.add(openBtn);
+ this.add(centerp, BorderLayout.CENTER);
+ this.add(openBtnPanel, BorderLayout.SOUTH);
+
+ }
+ }
+
+ //der Druckdialog greift direkt auf die JLabels zu
+ //wegen Font, Größe und Inhalt
+ class ParameterPanel extends JPanel {
+ JLabel lblAbfragename, lblEingabeparam, lblParams, lblStand;
+
+ ParameterPanel() {
+ super(new BorderLayout());
+ VerticalBox topBox = new VerticalBox();
+ topBox.addStrut(10);
+ lblAbfragename = new JLabel();
+ lblAbfragename.setFont(new Font("SansSerif", Font.BOLD, 14));
+ lblParams = new JLabel();
+ this.setMaximumSize(new Dimension(200, 1000));
+ lblEingabeparam = new JLabel("Parameter: ");
+ topBox.add(lblAbfragename);
+ topBox.addStrut(5);
+ topBox.add(lblEingabeparam);
+ topBox.addStrut(5);
+ this.add(topBox, BorderLayout.NORTH);
+ this.add(lblParams, BorderLayout.CENTER);
+ lblStand = new JLabel();
+ this.add(lblStand, BorderLayout.SOUTH);
+ }
+
+ public void setAbfragename(String name) {
+ lblAbfragename.setText(name);
+ }
+
+ public void setParams(String params) {
+
+ lblParams.setText(params);
+ }
+
+ public void setStand(String stand) {
+ lblStand.setText("Stand: " + stand);
+ }
+ }
+
+ class SxToolbar extends JToolBar {
+ SxToolbar(JFrame frame) {
+ // images in sx_map
+ ImageIcon disconnect_icon = (ImageIcon) sx_map.get("disconnect");
+ ImageIcon clone_icon = (ImageIcon) sx_map.get("clone");
+ ImageIcon copy_icon = (ImageIcon) sx_map.get("copy");
+ ImageIcon save_icon = (ImageIcon) sx_map.get("save");
+ ImageIcon print_icon = (ImageIcon) sx_map.get("print");
+ ImageIcon info_icon = (ImageIcon) sx_map.get("info");
+ ImageIcon passwd_icon = (ImageIcon) sx_map.get("passwd");
+
+ ImageIcon help_icon = (ImageIcon) sx_map.get("help");
+ this.setFloatable(false);
+ dbBtn = new JButton("Anmelden", disconnect_icon);
+ dbBtn.setMargin(new Insets(2, 2, 2, 2));
+ dbBtn.setDisabledIcon(disconnect_icon);
+ dbBtn.setMnemonic(KeyEvent.VK_D);
+ dbBtn.setHorizontalTextPosition(JButton.CENTER);
+ dbBtn.setVerticalTextPosition(JButton.BOTTOM);
+ dbBtn.setFont(NORMAL_FONT);
+ ConnectListener conl = new ConnectListener(0);
+ dbBtn.addActionListener(conl);
+ this.add(dbBtn);
+ dbBtn.setVisible(SuperX.remoteUser == null);
+ passwdBtn = new JButton("Passwort", passwd_icon);
+
+ passwdBtn.setMargin(new Insets(2, 2, 2, 2));
+ passwdBtn.setHorizontalTextPosition(JButton.CENTER);
+ passwdBtn.setVerticalTextPosition(JButton.BOTTOM);
+ passwdBtn.setFont(NORMAL_FONT);
+ PwdListener pwdl = new PwdListener(frame);
+ passwdBtn.addActionListener(pwdl);
+ passwdBtn.setEnabled(countFrame == 1 ? true : false);
+ passwdBtn.setEnabled(false);
+ this.add(passwdBtn);
+ passwdBtn.setVisible(SuperX.remoteUser == null);
+
+ cloneBtn = new JButton("Clone", clone_icon);
+ cloneBtn
+ .setToolTipText("öffnet weiteres SuperX-Fenster! Anschließend Anmelden anklicken!");
+ cloneBtn.setMargin(new Insets(2, 2, 2, 2));
+ cloneBtn.setHorizontalTextPosition(JButton.CENTER);
+ cloneBtn.setVerticalTextPosition(JButton.BOTTOM);
+ cloneBtn.setFont(NORMAL_FONT);
+ cloneBtn.setEnabled(false);
+ CloneListener clonel = new CloneListener();
+ cloneBtn.addActionListener(clonel);
+ this.add(cloneBtn);
+ copyBtn = new JButton("Kopieren", copy_icon);
+ copyBtn
+ .setToolTipText("Ergebnisse in Zwischenablage kopieren (als Trennzeichen wird Tabulator benutzt)");
+ copyBtn.setMargin(new Insets(2, 2, 2, 2));
+ copyBtn.setHorizontalTextPosition(JButton.CENTER);
+ copyBtn.setVerticalTextPosition(JButton.BOTTOM);
+ copyBtn.setFont(NORMAL_FONT);
+ CopyListener copyl = new CopyListener();
+ copyBtn.addActionListener(copyl);
+ this.add(copyBtn);
+ saveBtn = new JButton("Sichern", save_icon);
+ saveBtn.setToolTipText("Ergebnisse in Datei speichern");
+ saveBtn.setMargin(new Insets(2, 2, 2, 2));
+ saveBtn.setHorizontalTextPosition(JButton.CENTER);
+ saveBtn.setVerticalTextPosition(JButton.BOTTOM);
+ saveBtn.setFont(NORMAL_FONT);
+ SaveDlgListener savedlgl = new SaveDlgListener();
+ saveBtn.addActionListener(savedlgl);
+ //Wint 24.7.2001 Button gesperrt, wegen Problemen mit Policy
+ //da angenommen wird, das er sowieso nicht benutzt wird.
+ //Die Fehlermeldungen weisen darauf hin, dass FileChoser die ganze
+ //Platte durchlesen will -- evtl. Vorbehalte bei Usern
+ //this.add (saveBtn);
+ printBtn = new JButton("Drucken", print_icon);
+ printBtn.setMargin(new Insets(2, 2, 2, 2));
+ printBtn.setHorizontalTextPosition(JButton.CENTER);
+ printBtn.setVerticalTextPosition(JButton.BOTTOM);
+ printBtn.setFont(NORMAL_FONT);
+ PrintListener printl = new PrintListener();
+ printBtn.addActionListener(printl);
+ this.add(printBtn);
+
+ if (helpsetfound) {
+ helpBtn = new JButton("Hilfe", help_icon);
+ helpBtn.setMargin(new Insets(2, 2, 2, 2));
+ helpBtn.setHorizontalTextPosition(JButton.CENTER);
+ helpBtn.setVerticalTextPosition(JButton.BOTTOM);
+ helpBtn.setFont(NORMAL_FONT);
+ //JMenuItem menu_help = new JMenuItem(" ??");
+ //HelpListener helpl = new HelpListener(hb);
+ //helpBtn.addActionListener(helpl);
+ //helpBtn.addActionListener(new CSH.DisplayHelpFromSource(hb));
+ helpBtn.addActionListener(new CSH.DisplayHelpAfterTracking(hb));
+ helpBtn.setEnabled(true);
+ helpBtn.setToolTipText("Hilfesystem aufrufen");
+ this.add(helpBtn);
+ }
+
+ //InfoButton MB
+ infoBtn = new JButton("Info", info_icon);
+ infoBtn.setMargin(new Insets(2, 5, 2, 5));
+ infoBtn.setHorizontalTextPosition(JButton.CENTER);
+ infoBtn.setVerticalTextPosition(JButton.BOTTOM);
+ infoBtn.setFont(NORMAL_FONT);
+ infoBtn.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ JOptionPane
+ .showMessageDialog(
+ null,
+ "SuperX Version @version@\nbuild:@sxtimestamp@\n"
+
+ + "Das Data Warehouse für Hochschulen\n"
+ + "www.superx-projekt.de\nKontakt: info@superx-projekt.de"
+ + "\nMandant: "
+ + SxSQL.mandantenID
+ + ",public/private key "
+ + (SxSQL.dsaHandler == null ? "nicht aktiv"
+ : "aktiv"), "SuperX", 1);
+ }
+ });
+ this.add(infoBtn);
+
+ }
+ }
+
+ public SxMask(String title, Hashtable img_map, boolean ifApplet) {
+ super();
+
+ isApplet = ifApplet;
+ sxMask = this;
+ sx_map = img_map;
+
+ sxFrame = new JFrame(title);
+ countFrame++;
+
+ init();
+
+ sxFrame.addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent e) {
+ close();
+ }
+ });
+
+ sxFrame.getContentPane().add(sxMask, BorderLayout.CENTER);
+ if (countFrame > 1) {
+ try {
+ installThemenbaum(DateUtils.getTodayString());
+ } catch (SQLException e1) {
+ ClipboardUtils.setContents(e1.toString(), null);
+ WarningMessage.show(sxMask, e1.toString(), "Fehler");
+ }
+ }
+
+ sxFrame.pack();
+ sxFrame.setBounds(100 + countFrame * 50, 100 + countFrame * 50, 600,
+ 500);
+ sxFrame.setVisible(true);
+
+ connectionDlg = new ConnectionDlg(user);
+
+ }
+
+ private void installThemenbaum(String date) throws SQLException {
+ sxThemenbaum = new SxThemenbaum(sxMask);
+ themenwahltree = sxThemenbaum.getTree(date);
+ themenwahlscroll.setViewportView(themenwahltree);
+ openBtn.setEnabled(true);
+ }
+
+ void clearThemenbaum() {
+ themenwahltree.setModel(new DefaultTreeModel(
+ new DefaultMutableTreeNode("Abfragen")));
+ }
+
+ /**
+ * Brings up a JDialog using JOptionPane containing the connectionPanel. If
+ * the user clicks on the 'Connect' button the connection is reset.
+ */
+
+ public int showConnectionDialog() {
+ int rc = -999;
+ if (!dummyLogin) {
+ rc = connectionDlg.showDlg(this.getFrame());
+ user.setName(connectionDlg.getUserName());
+ user.setPasswd(connectionDlg.getPassword());
+ } else {
+
+ rc = JOptionPane.YES_OPTION;
+ user.setName("admin");
+ //user.setUsername("testuser");
+ user.setPasswd("anfang12");
+
+ }
+ //SxNew autologin!
+ return rc;
+
+ }
+
+ protected void addMouseListenerToLogo() {
+ MouseAdapter listMouseListenerToLogo = new MouseAdapter() {
+ public void mousePressed(MouseEvent e) {
+ int button1 = e.getModifiers() & InputEvent.BUTTON1_MASK;
+ if (button1 != 0) {
+ if (activeThread != null) {
+ try {
+ // System.err.println ("interrupt ..");
+ activeThread.interrupt();
+ //SxSQL.cancel();
+ } catch (Exception ex) {
+ System.err.println(ex.toString());
+ }
+ }
+ }
+ }
+ };
+ logo.addMouseListener(listMouseListenerToLogo);
+ }
+
+ public synchronized void close() {
+ countFrame--;
+ if (SxSQL.isActive()) {
+ try {
+ SxSQL.close();
+
+ } catch (Exception ex) {
+ System.err.println(ex.toString());
+ }
+ }
+ if (countFrame <= 1) {
+ connectionDlg.setPassword("");
+ user.setPasswd("");
+ }
+ if (countFrame <= 0) {
+ isLogin = false;
+ clearThemenbaum();
+ //if (!isApplet)
+ // System.exit(0);
+ }
+
+ }
+
+ public void componentHidden(ComponentEvent e) {
+ }
+
+ public void componentMoved(ComponentEvent e) {
+ }
+
+ public void componentResized(ComponentEvent e) {
+
+ this.repaint();
+ }
+
+ public void componentShown(ComponentEvent e) {
+ }
+
+ /**
+ * Creates the connectionPanel, which will contain all the fields for the
+ * connection information.
+ *
+ * @throws SQLException
+ * @throws DBServletException
+ */
+ protected void createMask() throws SQLException, DBServletException {
+ // --------------------------------------------------------------------
+ // r.b.
+ // direkt abgeleitet aus SuperX C++-Modul 'PlaceFields' in 'sx_win.cxx'
+ // --------------------------------------------------------------------
+ int oldx = 20; // orginal: oldx = 50 + 10;
+ int oldy = 20; // orginal: oldy = 50 + 10;
+ int leftmargin = 20; // orginal: leftmargin = 50 + 10;
+ int x_ofs = 20;
+ int y_ofs = 20;
+ int oldnw = 0, oldfw = 0;
+ String fieldname = null;
+ int fieldnr;
+ int x;
+ int y;
+ int buttonbreite;
+ int feldbreite;
+ int zeilenanzahl;
+ String typ;
+ int laenge;
+ int obligatorisch;
+ int art;
+ String relation = null;
+ String attribut = null;
+ String fielddefault = null;
+ String sx_db = (String) SxDefaults.getPropertyValue("SxDB");
+
+ // Maskenelemente loeschen u. neu anlegen
+ maskeForm.removeAll(); // "alte" Maskenelemente loeschen
+
+ maskeForm.addComp(
+ // (String) H_thema.get(activeMaskeID),
+ selectedMaskeninfoElement.getName(), "M_headline", "JLabel", 0,
+ 0, 0, 0);
+ maskeForm.setPreferredCompWidth("M_headline", 500);
+ maskeForm.setCompXY("M_headline", 20, 20);
+ JLabel L_M_headline = (JLabel) maskeForm.getComp("M_headline");
+ L_M_headline.setFont(new Font("SansSerif", Font.BOLD, 14));
+
+ // Tabelle loeschen u. neu anlegen
+ lastMaskeID = new Integer(-1);
+
+ sxTablePanel.setData(new Vector(), new Vector(), new Vector(), null);
+
+ // Maskengroesse auslesen
+ int m_breite = selectedMaskeninfoElement.getBreite().intValue();
+ // Maskenbreite
+ int m_hoehe = selectedMaskeninfoElement.getHoehe().intValue();
+ // Maskenhoehe
+
+ // Unsichtbares Feld <>
+ maskeForm.addComp("UserID", "L_UserID", "JLabel", 0, 0, 0, 0);
+ JLabel L_userid = (JLabel) maskeForm.getComp("L_UserID");
+ L_userid.setVisible(false);
+
+ // s.o. Benutzerautorisierung mit UserID
+ maskeForm.addComp(SxSQL.getUserID().toString(), "F_UserID", "SxField",
+ 0, SxField.TYPE_INTEGER, 4, 0);
+ // maskeForm.addComp ("1", "F_UserID", "SxField", 0,
+ // SxField.TYPE_INTEGER, 4, 0);
+ SxField F_userid = (SxField) maskeForm.getComp("F_UserID");
+ F_userid.setVisible(false);
+
+ // Einzelfelder einfügen
+ addIndividualFields(oldy, leftmargin, x_ofs, y_ofs, oldnw, oldfw, sx_db);
+
+ // Feld-Angaben in Form speichern
+ maskeForm.setFieldVector(selectedMaskeninfoElement.getFelderinfos());
+
+ // Default-Values (letzte Feld-Eingaben)
+ maskeForm.restoreValuesFromFormerSelections();
+ // Default-Button
+ maskeForm.setDefaultBtn(searchBtn);
+
+ // Fenstergroesse anpassen
+
+ int diff_height = 0;
+ maskeForm.revalidate(); //Wint
+ maskeForm.setPreferredSize(new Dimension(m_breite, m_hoehe));
+
+ Rectangle m_rect = new Rectangle(0, 0, m_breite, m_hoehe);
+ Rectangle f_rect = maskeForm.getBounds();
+ Container toplevel = maskeForm.getTopLevelAncestor();
+ Rectangle top_rect = toplevel.getBounds();
+
+ if (!f_rect.contains(m_rect)) {
+ diff_height = m_rect.height - f_rect.height;
+ f_rect.width += m_rect.width - f_rect.width + 5;
+ f_rect.height += m_rect.height - f_rect.height;
+ }
+
+ if (!top_rect.contains(f_rect))
+ top_rect.width += f_rect.width - top_rect.width;
+
+ top_rect.height += diff_height;
+ if (top_rect.height > 600) // Fensterhoehe auf 600 Pixels begrenzen
+ top_rect.height = 600;
+
+ toplevel.setBounds(top_rect);
+ sxFrame.invalidate();
+ sxFrame.validate();
+ sxFrame.repaint();
+ }
+
+ /**
+ * einzelne Felder auf die Maske packen von CreateMask aufgerufen
+ *
+ * @param oldy
+ * @param leftmargin
+ * @param x_ofs
+ * @param y_ofs
+ * @param oldnw
+ * @param oldfw
+ * @param sx_db
+ * @throws SQLException
+ * @throws DBServletException
+ */
+ private void addIndividualFields(int oldy, int leftmargin, int x_ofs,
+ int y_ofs, int oldnw, int oldfw, String sx_db) throws SQLException,
+ DBServletException {
+ int oldx;
+ String fieldname;
+ int fieldnr;
+ int x;
+ int y;
+ int buttonbreite;
+ int feldbreite;
+ int zeilenanzahl;
+ String typ;
+ int laenge;
+ int obligatorisch;
+ int art;
+ String relation;
+ String attribut;
+ String fielddefault;
+ SichtApplet defaultsicht = null;
+ for (int i = 0; i < selectedMaskeninfoElement.getFelderinfos().size(); i++) {
+ defaultsicht = null;
+ Vector V_field = (Vector) selectedMaskeninfoElement
+ .getFelderinfos().elementAt(i);
+
+ fieldname = (String) V_field.elementAt(1);
+ if (fieldname != null)
+ fieldname = fieldname.trim();
+
+ //captions holen
+ SxSQL.executeQuery("select contents_short, contents_long "
+ + " from sx_captions " + " where table_name='felderinfo' "
+ + " and field_name='" + fieldname
+ + "' and (record_no is null or record_no="
+ + V_field.elementAt(0) + ")");
+ Vector v_captions = SxSQL.getResultVector();
+ String erläuterung = "";
+ String fieldCaption = fieldname;
+ if (v_captions.size() > 0) {
+ Vector row = (Vector) v_captions.get(0);
+ String cap = (String) row.get(0);
+ if (cap != null)
+ fieldCaption = cap;
+ erläuterung = (String) row.get(1);
+ }
+ fieldnr = ((Integer) V_field.elementAt(2)).intValue();
+
+ x = ((Integer) V_field.elementAt(3)).intValue();
+ if (x == 0)
+ x += leftmargin;
+ if (x < 0)
+ x = 0;
+
+ y = ((Integer) V_field.elementAt(4)).intValue();
+ if (y == 0) {
+ y = oldy + 25 + y_ofs;
+ }
+ if (y == -1) {
+ x += 2 * x_ofs;
+ y = oldy;
+ }
+
+ buttonbreite = ((Integer) V_field.elementAt(5)).intValue();
+ if (buttonbreite == 0)
+ buttonbreite = oldnw;
+ else
+ buttonbreite += x_ofs;
+
+ feldbreite = ((Integer) V_field.elementAt(6)).intValue();
+ if (feldbreite == 0)
+ feldbreite = oldfw;
+
+ zeilenanzahl = ((Integer) V_field.elementAt(7)).intValue();
+ typ = (String) V_field.elementAt(8);
+ if (typ != null)
+ typ = typ.trim();
+ laenge = ((Integer) V_field.elementAt(9)).intValue();
+ obligatorisch = ((Integer) V_field.elementAt(10)).intValue();
+ art = ((Integer) V_field.elementAt(11)).intValue();
+ //MB XML-Querabhängiges Feldart 16 wird einfach als reguläre 1 umgesetzt
+ // gar nicht mehr nötig if (art==16) art=1;
+ relation = (String) V_field.elementAt(12);
+ if (relation != null)
+ relation = relation.trim();
+ attribut = (String) V_field.elementAt(13);
+ if (attribut != null)
+ attribut = attribut.trim();
+ fielddefault = (String) V_field.elementAt(14);
+ if (fielddefault != null)
+ fielddefault = fielddefault.trim();
+ /*
+ * System.err.println ("Feld : " + fieldname + ", x=" + x + ", y=" +
+ * y + ", buttonbreite=" + buttonbreite + ", feldbreite=" +
+ * feldbreite);
+ */
+ //Rückgabewert defaultsicht ist brutale Methode um defaultsicht zu
+ // merken
+ if ((art > 0 && art <= 7) || art == 12) {
+ defaultsicht = addButtonField(fieldname, fieldCaption,
+ obligatorisch, art, relation, zeilenanzahl,erläuterung, i);
+ } else {
+ addLabelField(fieldname, x, y, buttonbreite, obligatorisch);
+ }
+
+ JComponent comp = (JComponent) maskeForm.getComp("L_" + fieldname);
+ if(art==13||art==15) comp.setVisible(false);
+ comp.setToolTipText(erläuterung);
+
+ FontMetrics font_m = comp.getFontMetrics(comp.getFont());
+ int label_width = font_m.stringWidth(fieldCaption) + 10;
+ maskeForm.setPreferredCompWidth("L_" + fieldname, label_width);
+ maskeForm.setCompXY("L_" + fieldname, x + buttonbreite
+ - label_width, y);
+
+ String field_type = "SxField";
+
+ //MB Mehrfachwahlanzeige
+ if (zeilenanzahl > 1)
+ field_type = "JComboBox";
+ if (art == 10)
+ field_type = "JCheckbox";
+ if (art == 11)
+ field_type = "JPasswordField";
+ //field_type = "JComboView";
+ if (art != 8&&art!=13&&art!=15)
+ //wenn es sich nicht um ein reines Label-Feld oder unsichtbare Felder handelt: Eingabefeld
+ // einfügen
+ {
+
+ if (typ.toLowerCase().equals("integer"))
+ maskeForm.addComp("", "F_" + fieldname, field_type, 0,
+ SxField.TYPE_INTEGER, laenge, obligatorisch);
+
+ if (typ.toLowerCase().equals("date"))
+ maskeForm.addComp("", "F_" + fieldname, field_type, 0,
+ SxField.TYPE_DATE, laenge, obligatorisch);
+ if (typ.toLowerCase().equals("char"))
+ maskeForm.addComp("", "F_" + fieldname, field_type, 0,
+ SxField.TYPE_STRING, laenge, obligatorisch);
+ if (typ.toLowerCase().equals("decimal"))
+ maskeForm.addComp("", "F_" + fieldname, field_type, 0,
+ SxField.TYPE_DOUBLE, laenge, obligatorisch);
+ if (typ.toLowerCase().equals("sql"))
+ maskeForm.addComp("", "F_" + fieldname, field_type, 0,
+ SxField.TYPE_SQL, laenge, obligatorisch);
+ maskeForm.setPreferredCompWidth("F_" + fieldname, feldbreite);
+ maskeForm.setCompXY("F_" + fieldname, x_ofs + buttonbreite + x,
+ y);
+
+ SxField valuefield = maskeForm.getField("F_" + fieldname);
+ if (art == 1 || art == 12) {
+ valuefield.setEditable(false);
+ }
+
+ //ggfs. eine Default Sicht hinterlegen
+ //vergl. addButtonField
+ if (defaultsicht != null) {
+ valuefield.setSelectedSicht(defaultsicht);
+ }
+ // Default-Wert aus Tab. 'felderinfo' setzen
+ setFieldDefault(sx_db, fieldname, art, fielddefault, valuefield);
+
+ }
+ oldx = x;
+ oldy = y;
+ oldnw = buttonbreite;
+ oldfw = feldbreite;
+ }
+ }
+
+ /**
+ * basis Default-werte setzen, später kommt noch Methode, die ggfs. durch
+ * letzte Eingaben überlagert see createMask
+ *
+ * @param sx_db
+ * @param fieldname
+ * @param art
+ * @param fielddefault
+ * @param field
+ */
+ private void setFieldDefault(String sx_db, String fieldname, int art,
+ String fielddefault, SxField field) {
+ if (fielddefault != null) {
+ String stmt = "";
+ if (fielddefault.startsWith("<>")
+ || fielddefault.startsWith("sp_")) {
+ readFieldDefaultFromDb(sx_db, fieldname, fielddefault, field,
+ stmt);
+ } else {
+ if (field != null)
+ field.setText(fielddefault);
+ field.setKey(new Integer(-1));
+ }
+ //bei einem Institutionendialog, fielddefault auf null setzen
+ //siehe Kommentar in SxField.setDefaultValue()
+ if (art == 4 || art == 6 || art == 7 || art == 12) {
+ field.setKey("null");
+ field.setDefaultValue("null");
+ }
+ }
+
+ }
+
+ private void readFieldDefaultFromDb(String sx_db, String fieldname,
+ String fielddefault, SxField field, String stmt) {
+
+ try {
+ stmt = fielddefault;
+
+ if (fielddefault.startsWith("<>"))
+ stmt = fielddefault.substring(7);
+ stmt = stmt.trim();
+ if (stmt.startsWith("sp_")) {
+ if (sx_db.equals("Postgres")) {
+ stmt = "select " + stmt;
+ } else {
+ stmt = "execute procedure " + stmt;
+ }
+ }
+
+ System.out.println(stmt);
+ stmt = SxUtils.generateSQL(maskeForm, stmt);
+ //MB 2/2016 auch Freemarker Parsing
+ //Trickmethode!!
+ HashMap map = maskeForm.getHashMap(selectedMaskeninfoElement.getTid());
+
+ stmt = SxSQL.templateProcessor.process("Felderdefault "+fieldname
+ , stmt,
+ map, (String) SxDefaults.getPropertyValue("SxDB"));
+
+ SxSQL.executeAll(stmt);
+ Vector result = SxSQL.getResultVector();
+ if (result.size() == 0)
+ throw new IllegalStateException(
+ "Defaultwert konnte nicht ermittelt werden, da der select nichts lieferte.");
+ Vector V_default = (Vector) result.elementAt(0);
+ Object key, value;
+ if (V_default.size() == 2) {
+ key = V_default.elementAt(0);
+ field.setKey(key);
+ value = V_default.elementAt(1);
+ if (value instanceof java.sql.Date)
+ value = SxDate.toString((java.sql.Date) value);
+
+ field.setText(value.toString());
+
+ }
+ if (V_default.size() == 1) {
+ //field.setKey(new Integer("-1"));
+ value = V_default.elementAt(0);
+ key = value;
+ if (value instanceof java.sql.Date)
+ value = SxDate.toString((java.sql.Date) value);
+ field.setText(value.toString());
+ }
+ } catch (Exception ex) {
+ System.out.println("Fehler beim Lesen von Defaultwert für Feld "
+ + fieldname + "\n Sql-stmt=" + stmt);
+ ex.printStackTrace();
+
+ }
+ }
+
+ private void addLabelField(String fieldname, int x, int y,
+ int buttonbreite, int obligatorisch) {
+ maskeForm.addComp(fieldname, "L_" + fieldname, "JLabel", 0, 0, 0, 0);
+ maskeForm.setPreferredCompWidth("L_" + fieldname, buttonbreite);
+ maskeForm.setCompXY("L_" + fieldname, x, y);
+ JLabel L_fieldname = (JLabel) maskeForm.getComp("L_" + fieldname);
+ L_fieldname.setHorizontalAlignment(JLabel.RIGHT);
+ if (obligatorisch != 0)
+ L_fieldname.setFont(NORMAL_BOLD_FONT);
+ else
+ L_fieldname.setFont(NORMAL_FONT);
+ }
+
+ private SichtApplet addButtonField(String fieldname, String fieldCaption,
+ int obligatorisch, int art, String relation,int zeilenanzahl, String erläuterung,
+ int i) throws SQLException, DBServletException {
+ SichtApplet defaultsicht = null;
+ maskeForm
+ .addComp(fieldCaption, "L_" + fieldname, "JButton", 0, 0, 0, 0);
+ JButton btn = (JButton) maskeForm.getComp("L_" + fieldname);
+ btn.setHorizontalAlignment(JLabel.RIGHT);
+ if (obligatorisch != 0)
+ btn.setFont(NORMAL_BOLD_FONT);
+ else
+ btn.setFont(NORMAL_FONT);
+
+ Sichtgruppe sichtgruppe = null;
+ if (art == 4 || art == 6 || art == 7 || art == 12) {
+ Vector sichtentids = new Vector();
+ try {
+ //Falls Datenbankzugriff nötig hier schon machen
+ //vergleichbare Methode im Servlet in Field.initSichtengruppe
+ if (art == 12 && relation != null
+ && relation.startsWith("<>")) {
+ SxSQL.executeQuery(relation.substring(7));
+ Vector result = SxSQL.getResultVector();
+ for (Iterator iter = result.iterator(); iter.hasNext();) {
+ Vector aRow = (Vector) iter.next();
+ Integer eineSichtTid = (Integer) aRow.get(0);
+ sichtentids.add(eineSichtTid);
+ }
+ }
+ //MB 1/16 dynamsiche Sichten vom Applet nicht unterstützt
+ sichtgruppe = user.getSichten().getGruppe(new Hashtable(),new HashMap(),new FieldContainer(), fieldname,art,
+ sichtentids, relation, zeilenanzahl,maskeForm.getDefaultStand(),SxSQL.mandantenID);
+ } catch (Exception e) {
+ String msg = "Konnte Sichten nicht einlesen:" + e.toString();
+ ClipboardUtils.setContents(msg, null);
+ WarningMessage.show(sxMask, msg, "SuperX");
+ e.printStackTrace();
+ }
+ }
+ SxDlgListener dlgl = new SxDlgListener(sxMask, maskeForm, btn,
+ erläuterung, i, art);
+
+ if (sichtgruppe != null) {
+
+
+ defaultsicht = (SichtApplet) sichtgruppe.getSelectedSicht();
+ dlgl.setSichtgruppe(sichtgruppe);
+ }
+
+ btn.addActionListener(dlgl);
+ return defaultsicht;
+ }
+
+ void initUser(int mode) {
+ try {
+ stopBtn.setEnabled(true);
+ statusField.setBackground(Color.yellow);
+
+ //anmelden
+ if (mode == 0) {
+ String sql_stmt;
+ logo.start();
+
+ if (SxSQL.isActive()) {
+ SxSQL.close();
+ }
+ // delete Dialog-Cache
+ SxDlgManager.clear();
+ // delete Defaults-Cache
+ SxDefaults.clear();
+ SxDefaults.init();
+ V_thema = null;
+
+ user.getSichten().clear();
+
+ statusField.setText("Anmelden ..");
+ passwdBtn.setEnabled(false);
+ passwdBtn.setVisible(SuperX.remoteUser == null);
+
+ SxSQL.setLogMode(logToKonsole);
+ SxSQL.setUrl(serverURL);
+ if (!SuperX.isAuthentificationFound)
+ SxSQL.check(user);
+ //bei An/ummeldung wird im connectListener
+ // isAuthenficationFound auf false gesetzt
+ SxSQL.readFMTemplates();
+ if (SuperX.remoteUser != null)
+ passwdBtn.setEnabled(true);
+ statusField.setText("Lade Standardwerte ..");
+
+ //Sichten einlesen
+ SxSQL.executeQuery(Sichten.getReadingSql(user));
+
+
+ user.getSichten().init(SxSQL.mandantenID, SxSQL.getResult(),
+ SichtApplet.class);
+ SxSQL.executeQuery("select distinct tid,type from sichten S where "
+ + Sichten.getErlaubteSichtenSql(user));
+
+ user.getSichten().setAllowedSichten(SxSQL.getResult(), user.isAdmin());
+
+ if (SuperX.isSachgebieteNeeded)
+ Sachgebiete.init();
+
+ installThemenbaum(DateUtils.getTodayString());
+
+ terlaeuterung.setText("");
+ statusField.setBackground(Color.white);
+ statusField.setText("Anmeldung erfolgreich");
+
+ ImageIcon connect_icon = (ImageIcon) sx_map.get("connect");
+ dbBtn.setIcon(connect_icon);
+ dbBtn.setDisabledIcon(connect_icon);
+
+ if (countFrame == 1)
+ passwdBtn.setEnabled(true);
+ openBtn.setEnabled(true);
+
+ isLogin = true;
+ cloneBtn.setEnabled(true);
+
+ tabPane.setSelectedIndex(0);
+
+ JRootPane root = sxMask.getRootPane();
+ root.setDefaultButton(openBtn); // DefaultButton setzen
+ }
+ if (mode == 1) {
+ logo.start();
+
+ statusField.setText("Abmelden ..");
+
+ if (SxSQL.isActive())
+ SxSQL.close();
+
+ // delete Dialog-Cache
+ SxDlgManager.clear();
+
+ // delete Defaults-Cache
+ SxDefaults.clear();
+
+ statusField.setBackground(Color.white);
+ statusField.setText("Keine DB-Verbindung");
+
+ ImageIcon disconnect_icon = (ImageIcon) sx_map
+ .get("disconnect");
+ dbBtn.setIcon(disconnect_icon);
+ dbBtn.setDisabledIcon(disconnect_icon);
+
+ if (countFrame == 1)
+ passwdBtn.setEnabled(false);
+ openBtn.setEnabled(false);
+
+ lastMaskeID = new Integer(-1);
+
+ if (countFrame <= 1) {
+ isLogin = false;
+ cloneBtn.setEnabled(false);
+ //sx_map.clear(); //Wint wars nicht!!
+
+ }
+ //Wint:Da bei http-Verbindung kein closeConnection
+ //möglich ist, wird Applet-Fenster geschlossen
+ close();
+ }
+
+ } catch (Exception ex) {
+ String msg = ex.toString();
+ // System.err.println("msg: " + msg);
+ ex.printStackTrace();
+ statusField.setText(msg);
+ ClipboardUtils.setContents(msg, null);
+ }
+
+ dbBtn.setEnabled(true);
+ stopBtn.setEnabled(false);
+ logo.stop();
+
+ sxMask.repaint();
+ activeThread = null;
+
+ }
+
+ void setUser(SxUser user) {
+ this.user = user;
+ }
+
+ public Vector getFieldVector() {
+ return selectedMaskeninfoElement.getFelderinfos();
+ }
+
+ public SxForm getForm() {
+ return maskeForm;
+ }
+
+ public JFrame getFrame() {
+ return sxFrame;
+ }
+
+ public SxLogoPanel getLogo() {
+ return logo;
+ }
+
+ public JTextField getStatusField() {
+ return statusField;
+ }
+
+ public void init() {
+ int start_x = 20, start_y = 20;
+
+ sxMask.setLayout(new BorderLayout());
+
+ JPanel heading = new JPanel();
+
+ GridBagLayout gridbag = new GridBagLayout();
+ GridBagConstraints constraints = new GridBagConstraints();
+ heading.setLayout(gridbag);
+ constraints.weightx = 1.0;
+ constraints.weighty = 1.0;
+
+ int[] logo_pixels = (int[]) sx_map.get("logo_pixels");
+ JPanel sxTpanel = new JPanel();
+ sxTpanel.setLayout(new BoxLayout(sxTpanel, BoxLayout.X_AXIS));
+
+ initHelpSystem();
+
+ JToolBar toolbar = new SxToolbar(this.getFrame());
+ sxTpanel.add(toolbar);
+
+ constraints.anchor = GridBagConstraints.CENTER;
+ gridbag.setConstraints(sxTpanel, constraints);
+ heading.add(sxTpanel);
+
+ ImageIcon logo_icon = (ImageIcon) sx_map.get("logo");
+
+ logo = new SxLogoPanel(logo_icon, logo_pixels, 20, 50);
+ addMouseListenerToLogo();
+ constraints.insets = new Insets(5, 5, 5, 5);
+ constraints.anchor = GridBagConstraints.EAST;
+ gridbag.setConstraints(logo, constraints);
+ heading.add(logo);
+
+ sxMask.add(heading, BorderLayout.NORTH);
+
+ // Workpanel
+ JPanel sxWpanel = new JPanel();
+ sxWpanel.setLayout(new BorderLayout());
+ sxWpanel.setBorder(BorderFactory.createEtchedBorder());
+
+ tabPane = new JTabbedPane();
+ tabPane.setFont(NORMAL_BOLD_FONT);
+
+ // Themenauswahl
+ ThemenwahlPanel themap = new ThemenwahlPanel();
+ tabPane.addTab("Themenauswahl", themap);
+ //Hilfe für Thema
+ helpItemString = "Themaauswhlen.htm";
+ CSH.setHelpIDString(themap, helpItemString);
+ if (helpsetfound) {
+ hb.enableHelpKey(themap, helpItemString, hs);
+ hb.enableHelp(themap, helpItemString, hs);
+ }
+
+ // Maske
+ // ---------------------------------------------------------------------
+ initMaskeTab();
+
+ // Tabelle
+ // ---------------------------------------------------------------------
+ initTableTab();
+ // ---------------------------------------------------------------------
+
+ tabPane.setSelectedIndex(0);
+
+ sxWpanel.add(tabPane, "Center");
+
+ // Statusbar
+ sxSpanel = new JPanel();
+ sxSpanel.setLayout(new BorderLayout());
+ sxSpanel.setBorder(BorderFactory.createEtchedBorder());
+
+ statusField = new JTextField("");
+ statusField.setFont(NORMAL_FONT);
+ statusField.setMargin(new Insets(5, 5, 5, 5));
+ statusField.setEditable(false);
+ sxSpanel.add(statusField, "Center");
+
+ sxMask.add(sxWpanel, "Center");
+ sxMask.add(sxSpanel, "South");
+
+ // Default Properties laden
+ // ---------------------------------------------------------------------
+
+ SxDefaults.init();
+
+ try {
+ serverURL = (String) SxDefaults.getPropertyValue("SxServerURL");
+ //MB 20.6.06 damit schon früher bekannt
+ SxSQL.setUrl(serverURL);
+ } catch (Exception ex) {
+ ClipboardUtils.setContents(ex.toString(), null);
+ System.err.println(ex);
+ JOptionPane.showMessageDialog(sxMask, ex.toString(), "Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ }
+ try {
+ logToKonsole = (String) SxDefaults.getPropertyValue("logToKonsole");
+ } catch (Exception ex) {
+ logToKonsole = "none";
+ }
+ sxTitle = sxFrame.getTitle();
+ try {
+ sxTitle = sxTitle + ", "
+ + (String) SxDefaults.getPropertyValue("SxTitle");
+ sxFrame.setTitle(sxTitle);
+ } catch (Exception ex) {
+ sxFrame.setTitle(sxTitle);
+ }
+
+ }
+
+ ParameterPanel getParameterPanel() {
+ return parameterPanel;
+ }
+
+ private void initTableTab() {
+ JPanel tableTab = new JPanel();
+ tableTab.setLayout(new BorderLayout());
+
+ // Ergebnistabelle fuer Maske
+ sxTablePanel = new SxTablePanel();
+
+ //MB selection Deselektion ermöglichen (dekl. sxTablePanel drüber)
+ parameterPanel.addMouseListener(new MouseAdapter() {
+ public void mousePressed(MouseEvent e) {
+ int button1 = e.getModifiers() & InputEvent.BUTTON1_MASK;
+ if (button1 == 0)
+ return;
+ sxTablePanel.table.setColumnSelectionAllowed(false);
+ sxTablePanel.rowheaderTable.setColumnSelectionAllowed(false);
+ sxTablePanel.table.setRowSelectionAllowed(true);
+ sxTablePanel.rowheaderTable.setRowSelectionAllowed(true);
+ sxTablePanel.table.clearSelection();
+ sxTablePanel.rowheaderTable.clearSelection();
+ }
+ });
+ HorizontalBox hbox = new HorizontalBox();
+ hbox.add(parameterPanel);
+ hbox.addGlue();
+ tableTab.add(hbox, BorderLayout.NORTH);
+ //tableTab.add(parameterPanel, BorderLayout.NORTH);
+
+ tableTab.add(sxTablePanel, BorderLayout.CENTER);
+
+ //Hilfe für Tabelle
+ //helpItemString = "debug.overview";
+ if (helpsetfound) {
+ helpItemString = "Auswertungsmglichkei.htm";
+ CSH.setHelpIDString(tableTab, helpItemString);
+ hb.enableHelpKey(tableTab, helpItemString, hs);
+ hb.enableHelp(tableTab, helpItemString, hs);
+ //CSH.setHelpIDString(helpBtn,helpItemString);
+ }
+ JPanel pSouth = new JPanel();
+ pSouth.add(btnExplanation);
+ tableTab.add(pSouth, BorderLayout.SOUTH);
+ btnExplanation.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ explanationFrame.set(selectedMaskeninfoElement);
+ explanationFrame.show();
+ }
+ });
+ tabPane.addTab("Tabelle", tableTab);
+ }
+
+ private void initMaskeTab() {
+ JPanel maskep = new JPanel(new BorderLayout());
+
+ // Control-Buttons
+ JPanel sxCMpanel = new JPanel();
+ sxCMpanel.setLayout(new FlowLayout());
+ sxCMpanel.setBorder(BorderFactory.createEtchedBorder());
+
+ searchBtn = new JButton("Suchen");
+ searchBtn.setMnemonic(KeyEvent.VK_S);
+ SearchListener searchl = new SearchListener();
+ searchBtn.addActionListener(searchl);
+ searchBtn.setFont(NORMAL_BOLD_FONT);
+ searchBtn.setEnabled(false);
+ //Hilfe
+ //helpItemString = "proj.paths";
+ helpItemString = "WeitereThemeneingren.htm";
+ sxCMpanel.add(searchBtn, 0);
+ resetBtn = new JButton("Reset");
+ ResetListener resetl = new ResetListener();
+ resetBtn.addActionListener(resetl);
+ resetBtn.setFont(NORMAL_BOLD_FONT);
+ resetBtn.setEnabled(true);
+ sxCMpanel.add(resetBtn, 1);
+
+ stopBtn = new JButton("Abbrechen");
+ stopBtn.setMnemonic(KeyEvent.VK_C);
+ StopListener stopl = new StopListener();
+ stopBtn.addActionListener(stopl);
+ stopBtn.setFont(NORMAL_BOLD_FONT);
+ stopBtn.setEnabled(false);
+ stopBtn.setVisible(false);
+ // Abbrechen bringt ConnectionPool durcheinander
+ sxCMpanel.add(stopBtn, 2);
+
+ // SxForm Maske
+ // ---------------------------------------------------------------------
+ maskeForm = new SxForm(0, 0, 0, 0);
+ selectedMaskeninfoElement.setMaskeForm(maskeForm);
+ maskeForm.setLogo(logo);
+
+ maskep.add(new JScrollPane(maskeForm), BorderLayout.CENTER);
+ maskep.add(sxCMpanel, BorderLayout.SOUTH);
+
+ //Hilfe für Maske
+ //helpItemString = "build.build";
+ if (helpsetfound) {
+ helpItemString = "WeitereThemeneingren.htm";
+ CSH.setHelpIDString(maskep, helpItemString);
+ hb.enableHelpKey(maskep, helpItemString, hs);
+ hb.enableHelp(maskep, helpItemString, hs);
+ //CSH.setHelpIDString(helpBtn,helpItemString);
+ }
+
+ tabPane.addTab("Maske", maskep);
+ }
+
+ private void initHelpSystem() {
+ ClassLoader loader = this.getClass().getClassLoader();
+ URL url = null;
+
+ try {
+ url = HelpSet.findHelpSet(loader, "superx_help/superx");
+ if (url == null) {
+ url = HelpSet.findHelpSet(loader, "superx_help/superx.hs");
+ //java.lang.String.debug("codeBase url=" + url);
+ }
+
+ hs = new HelpSet(loader, url);
+ } catch (NoClassDefFoundError e) {
+ JOptionPane.showMessageDialog(null,
+ "Java Hilfesystem nicht gefunden. ", "SuperX",
+ JOptionPane.WARNING_MESSAGE);
+
+ } catch (Exception ee) {
+ System.out.println("Hilfesystem nicht gefunden!");
+ }
+ if (url != null) {
+ //System.out.println("Hilfesystem gefunden: "+url.toString());
+ hb = hs.createHelpBroker();
+ helpsetfound = true;
+ }
+ }
+
+ //MB Maske Öffnen wird vom OpenListener und Doppelklick in Tree Aufgerufen
+ public void maskeOeffnen() {
+ //sxMask.terlaeuterung.setText("");
+ openBtn.setEnabled(false);
+
+ statusField.setText("Bitte warten ..");
+ SxWaitCursor.set(sxMask, true);
+
+ try {
+ //afterwards selectedMaskeninfoEntry is up to date
+ readMaskenFelderInfoFromDb();
+
+ // Neue Maske aufbauen
+ sxMask.createMask();
+ //activeMaskeName = (String) V_id.elementAt(1); //MB name
+ searchBtn.setEnabled(true);
+
+ JRootPane root = sxMask.getRootPane();
+ root.setDefaultButton(searchBtn); // DefaultButton setzen
+
+ tabPane.setSelectedIndex(1);
+
+ statusField.setText("");
+
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ String msg = ex.toString();
+ ClipboardUtils.setContents(msg, null);
+ System.out.println(msg);
+ statusField.setText("Maske konnte nicht aufgebaut werden :"
+ + msg.substring(msg.lastIndexOf(":") + 1) + "-"
+ + SxSQL.getErrorString());
+ } finally {
+ logo.stop();
+ openBtn.setEnabled(true);
+ SxWaitCursor.set(sxMask, false);
+ sxMask.repaint();
+ }
+ }
+
+ private void readMaskenFelderInfoFromDb() throws SQLException, IOException {
+ String sql = "select M.tid, M.select_stmt, M.xil_proplist, M.cleanup_stmt, "
+ + "M.breite, M.hoehe, S.datum, M.hinweis,M.erlaeuterung "
+ + "from maskeninfo M, maske_system_bez B, systeminfo S "
+ + "where M.tid = "
+ + selectedMaskeninfoElement.getTid()
+ + " and M.tid = B.maskeninfo_id"
+ + " and S.tid = B.systeminfo_id" + ";";
+ SxSQL.executeQuery(sql);
+
+ Vector vectorMaskeninfoEntries = SxSQL.getResultVector();
+ if (vectorMaskeninfoEntries.size() == 0) {
+ throw new SQLException("Keine Daten zu dieser Maske (Nr."
+ + selectedMaskeninfoElement.getTid()
+ + ") in der Datenbank gefunden");
+ }
+ //fieser Trick: es wird als letztes Element noch ein Vector mit
+ //Spaltenerläuterungen mitgeliefert
+ selectedMaskeninfoElement.init(vectorMaskeninfoEntries);
+
+ sql = "select F.tid, F.name, F.nummer, F.x, F.y, F.buttonbreite, "
+ + "F.feldbreite, F.zeilenanzahl, F.typ, F.laenge, "
+ + "F.obligatorisch, F.art, F.relation, F.attribut, F.defaultwert "
+ + "from felderinfo F, masken_felder_bez B "
+ + "where F.art!=999 and B.maskeninfo_id = "
+ + selectedMaskeninfoElement.getTid()
+ + " and F.tid = B.felderinfo_id " + "order by F.nummer;";
+
+ SxSQL.executeQuery(sql);
+ selectedMaskeninfoElement.setFelderinfos(SxSQL.getResultVector());
+
+ //captions_long für die Felder wird in addButtonField geholt
+ if (SuperX.isSachgebieteNeeded)
+ selectedMaskeninfoElement.readSachgebiete();
+
+ }
+
+ void setConnectPwBtnsSVisible(boolean vis) {
+ dbBtn.setVisible(vis);
+ passwdBtn.setVisible(vis);
+ }
+
+ public void open() {
+ sxFrame.setVisible(true);
+ JRootPane root = sxMask.getRootPane();
+ if (SuperX.isAuthentificationFound)
+ root.setDefaultButton(dbBtn); // DefaultButton setzen
+
+ if (isLogin == false) {
+ user.setPasswd("");
+ connectionDlg.setPassword("");
+ }
+ if (!SuperX.isAuthentificationFound && SuperX.remoteUser == null)
+ dbBtn.doClick();
+ passwdBtn.setVisible(SuperX.remoteUser == null);
+
+ }
+
+ public MaskeninfoElement getSelectedMaskeninfoElement() {
+ return selectedMaskeninfoElement;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxPasswdChangeDlg.java b/src/de/superx/applet/SxPasswdChangeDlg.java
new file mode 100644
index 0000000..0531a79
--- /dev/null
+++ b/src/de/superx/applet/SxPasswdChangeDlg.java
@@ -0,0 +1,35 @@
+package de.superx.applet;
+import java.awt.Frame;
+
+import de.memtext.baseobjects.User;
+import de.memtext.dlg.PasswdChangeDlg;
+
+public class SxPasswdChangeDlg extends PasswdChangeDlg {
+
+ public SxPasswdChangeDlg(Frame frame, String title) {
+ super(frame, title);
+ setInfoLabel("Früher bereits verwendete Passwörter sollten nicht benutzt werden");
+ this.pack();
+ }
+ /**
+ * this method is automatically called by the PasswdChangeDlg
+ */
+ protected boolean isOldPasswordOK(String username, String passwd) {
+ boolean result = false;
+ // if (!SxSQL.isAdmin()) {
+ try {
+ SxSQL.checkPwd(new User(username, passwd));
+ result=true;
+ } catch (Exception e) {
+ //WarningMessage.show(e.toString(),"Fehler");
+ result = false;
+ }
+ // }
+ return result;
+ }
+
+
+
+}
+
+//Created on 09.01.2004 at 17:40:10
\ No newline at end of file
diff --git a/src/de/superx/applet/SxPosLayout.java b/src/de/superx/applet/SxPosLayout.java
new file mode 100644
index 0000000..8b7136f
--- /dev/null
+++ b/src/de/superx/applet/SxPosLayout.java
@@ -0,0 +1,280 @@
+/*
+ * $Id: PosLayout.java,v 1.3 1998/01/22 12:45:30 bw Exp $
+ *
+ * (c)1997 IoS Gesellschaft für innovative Softwareentwicklung mbH
+ * http://www.IoS-Online.de mailto:info@IoS-Online.de
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package de.superx.applet;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.LayoutManager;
+import java.awt.Point;
+import java.util.Vector;
+
+/**
+ * Layout-Manager, den SxForm für die Darstellung der Maske benötigt.
+ * LayoutManager-Implementation fuer direkte Kontrolle ueber die Position
+ * der Components.
+ * Fuer jedes Element sollte die Methode setPosition aufgerufen werden.
+ * Ansonsten werden die Components linear untereinander angeordnet.
+ * @version 1.3 1998/01/22
+ * @author IoS
+ */
+
+
+public class SxPosLayout implements LayoutManager {
+
+ /**
+ * Name of this Class
+ */
+ public static final String CLASS = "SxPosLayout";
+
+ /**
+ * Standard Constructor
+ */
+ public SxPosLayout() {
+ super();
+ }
+
+
+ /**
+ * Extended Constructor, allows to define a Frame-Distance from the borders of the Container and
+ * a Min.-Distance between all automatically positioned Components
+ */
+ public SxPosLayout( int frameDistX, int frameDistY, int compDistX, int compDistY ) {
+ super();
+ }
+
+
+ /**
+ * Setzt die Position einer Komponente.
+ * Diese Methode muss fuer jedes Element aufrufen werden!
+ */
+ public void setPosition(Component comp, int x, int y, int w, int h) {
+ if (debug)
+ System.out.println(CLASS+".setPosition("+x+","+y+","+w+","+h+")");
+ int i=VComp.indexOf(comp);
+ Point p;
+ Dimension d;
+
+ if (i>=0) {
+ p=(Point)VPoint.elementAt(i);
+ d=(Dimension)VDimension.elementAt(i);
+ p.x = x;
+ p.y = y;
+ d.width =w;
+ d.height=h;
+ if (GD.width < (x+w))
+ GD.width = x+w;
+ if (GD.height < (y+h))
+ GD.height = y+h;
+ }
+ else
+ if (debug)
+ System.out.println(CLASS+".setPosition: WARNUNG: Component nicht gefunden");
+ }
+
+ /****************************************************************************************************
+ * Zu implementierende Methoden von LayoutManager
+ */
+
+ /**
+ * Komponente hinzufuegen.
+ * Diese Methode wird nur von Container.add(String,Component) aufgerufen.
+ * Alle anderen add-Funktionen rufen diese Funktion nicht auf!
+ * Daher werden bei einem Aufruf der Methode layoutContainer (s.u.) alle
+ * Components des Container ueberprueft und ggf. hinzugefuegt.
+ */
+ public void addLayoutComponent( String name, Component comp ) {
+ if (debug)
+ System.out.println(CLASS+".addLayoutComponent");
+ Dimension nD = new Dimension(0,0);
+ Point nP = new Point(0,0);
+
+ VComp.addElement(comp);
+ VPoint.addElement(nP);
+ VDimension.addElement(nD);
+ }
+
+
+ /**
+ * Entfernen einer Component.
+ */
+ public void removeLayoutComponent( Component comp ) {
+ if (debug)
+ System.out.println(CLASS+".removeLayoutComponent");
+ int i=VComp.indexOf(comp);
+ if (i>=0) {
+ VComp.removeElementAt(i);
+ VDimension.removeElementAt(i);
+ VPoint.removeElementAt(i);
+ }
+ else
+ if (debug)
+ System.out.println(CLASS+".removeLayoutCompoent: WARNUNG: Element nicht gefunden");
+ }
+
+
+ /**
+ * Miminale Groesse des Layouts
+ */
+ public Dimension minimumLayoutSize(Container parent) {
+ if (debug)
+ System.out.println(CLASS+".minimumLayoutSize");
+ if (minimumDim!=null)
+ return minimumDim;
+ else {
+ return GD;
+ }
+ }
+
+
+ /**
+ * Setzen der Miniumalgroesse des Layouts.
+ * Fuer Faelle, in denen die Komponenten verdeckt werden koennen.
+ */
+ public void setMinimumSize(int w, int h) {
+ minimumDim = new Dimension(w,h);
+ }
+
+
+ /**
+ * Gewuenschte Groesse.
+ * Wird bei jedem pack aufgerufen (bei der Initialisierung des Fensters
+ * sogar mehrfach).
+ */
+ public Dimension preferredLayoutSize(Container parent) {
+
+ if (debug)
+ System.out.println(CLASS+".preferredLayoutSize ["+GD+"]");
+ if (preferredDim!=null)
+ return preferredDim;
+ else {
+ return GD;
+ }
+ }
+
+ /**
+ * Setzen der gewuenschten Groesse des Layouts.
+ * Fuer Faelle, in denen die Komponenten verdeckt werden koennen.
+ */
+ public void setPreferredSize(int w, int h) {
+ preferredDim = new Dimension(w,h);
+ }
+
+
+ /**
+ * Neuberechnung des Layouts und Positionierung der Komponenten.
+ * (Diese Methode wird bei jedem Repaint aufgerufen.)
+ */
+ public void layoutContainer(Container parent) {
+ if (debug)
+ System.out.println(CLASS+".layoutContainer");
+
+ int i,n = parent.getComponentCount(),
+ cx,cy,cw,ch;
+ Component c;
+
+ if (debug) {
+ for (i=0; i 0)
+ prot_sql.replace(user_id_pos, user_id_pos + 1, "-1");
+ // if (!isClosed) execute(prot_sql.toString());
+ throw new SQLException(msg);
+ }
+ }
+
+ /**
+ * @deprecated macht der UserInitializer im Servlet
+ * @throws UnknownHostException
+ */
+ static private void initProtokolEntry() throws UnknownHostException {
+ client_addr = InetAddress.getLocalHost();
+ client_ip = client_addr.getHostAddress();
+ client_dns = InetAddress.getByName(client_ip);
+
+ // System.out.println("adrr:" + client_addr + " ip: " + client_ip + "
+ // client_name: " + client_dns.getHostName());
+ prot_sql.append("insert into protokoll (proto_fkt_id, userinfo_id, ");
+ prot_sql.append("ip_adresse, client_name, zeitpunkt) values (");
+ prot_sql.append("?, ");
+ prot_sql.append("% , '" + client_ip);
+ prot_sql.append("', '" + client_dns.getHostName() + "'");
+ if (sx_db.equals("Postgres")) {
+ prot_sql.append(", now());");
+ } else {
+ prot_sql.append(", current);");
+ }
+
+ // , date('"+SxDate.getNowString()+"'));");
+
+ proto_id_pos = prot_sql.toString().indexOf("?");
+ prot_sql.replace(proto_id_pos, proto_id_pos + 1, (new Integer(
+ proto_fkt_id)).toString());
+ }
+
+ static void readFMTemplates() throws SQLException {
+ // Spezielles Kommando, dass das SuperXDBServlet versteht und
+ // die templates im SuperX_el Objekt zurückschickt
+ executeQuery("readFMBasics");
+ if (gesamt.getRawFmTemplates() == null)
+ throw new SQLException(
+ "Servlet hat keine FreeMarker Templates geschickt");
+ templateProcessor.setTemplates(gesamt.getRawFmTemplates());
+ if (gesamt.getRepository() == null)
+ throw new SQLException(
+ "Servlet hat keine Sx_Repository Daten geschickt");
+
+ templateProcessor.setRepositoryMap(gesamt.getRepository());
+ // damit nicht immer hin-und her geschickt werden muss
+ gesamt.setRepository(null);
+ }
+
+ /**
+ * checkPwd initialisiert User setzt id des Users wird auch von
+ * SxPasswdChangeDlg aufgerufen
+ *
+ * @param user
+ * @throws Exception
+ */
+ static synchronized void checkPwd(User user) throws Exception {
+
+ boolean login_ok = false;
+ try {
+ String auth_sql = "Anmeldung|" + user.getName() + "|"
+ + user.getPasswd();
+ // der select auf userinfo wird automatisch im Servlet generiert
+ /*
+ * "|select tid, passwd_sha, administration,akt_versuch,max_versuch"
+ * + " from userinfo where benutzer = '" + user.getName() + "';";
+ */
+
+ executeQuery(auth_sql);
+
+ if (getRowCount() == 0) {
+ throw new Exception("Die Anmeldung des Users '"
+ + user.getName() + "' war nicht erfolgreich");
+ }
+ SxResultRow V_row = (SxResultRow) rows.first();
+
+ Short aktVersuch;
+ Short maxVersuch;
+ try {
+ // normal Informix
+ aktVersuch = (Short) V_row.get(3);
+ } catch (ClassCastException e) {
+ // Access / Postgres liefern Integer-Wrapper
+ Integer dummy = (Integer) V_row.get(3);
+ Short dummy2 = new Short((short) dummy.shortValue());
+ aktVersuch = dummy2;
+ }
+ try {
+ // normal Informix
+ maxVersuch = (Short) V_row.get(4);
+ } catch (ClassCastException e) {
+ // Access / Postgres liefern Integer-Wrapper
+ Integer dummy = (Integer) V_row.get(4);
+ Short dummy2 = new Short((short) dummy.shortValue());
+ maxVersuch = dummy2;
+ }
+
+ // Short aktVersuch = (Short) V_row.get(3);
+ // Short maxVersuch = (Short) V_row.get(4);
+ if (aktVersuch.shortValue() > maxVersuch.shortValue()
+ || aktVersuch.shortValue() <= (maxVersuch.shortValue() * -1)) {
+ throw new Exception(
+ "Die Zahl maximaler Login-Versuche für Benutzer '"
+ + user.getName() + "' ist überschritten.");
+ }
+
+ userID = (Integer) V_row.get(0);
+ user.setId(userID);
+ try {
+ // normal Informix
+ adminUserInt = (Short) V_row.get(2);
+ } catch (ClassCastException e) {
+ // Access / Postgres liefern Integer-Wrapper
+ Integer dummy = (Integer) V_row.get(2);
+ Short dummy2 = new Short((short) dummy.shortValue());
+ adminUserInt = dummy2;
+ }
+ user.setAdmin(isAdmin());
+
+ user_id_pos = prot_sql.toString().indexOf("%");
+ if (user_id_pos > 0)
+ prot_sql.replace(user_id_pos, user_id_pos + 1,
+ userID.toString());
+ String passwd_sha = (String) V_row.get(1);
+ Object kennwortSpalte = V_row.get(5);
+
+ /*
+ * executeQuery("select pw_gueltig_bis from user_pw where userinfo_id="
+ * +userID); if (rows.size()>0) { Vector zeile= (Vector)
+ * rows.get(0); java.util.Date datum=(java.util.Date)zeile.get(0);
+ * if (datum!=null&&!DateUtils.isDateInFuture(datum))
+ * kennwortSpalte="ändern"; }
+ */
+ if (kennwortSpalte != null
+ && kennwortSpalte.toString().trim().equals("ändern")) {
+ try {
+ login_ok = changePwd(user);
+ } catch (Exception e) {
+ String msg = e.toString();
+ msg = msg.substring(msg.lastIndexOf(":") + 1);
+ e.printStackTrace();
+
+ JOptionPane.showMessageDialog(null, msg, "Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ login_ok = false;
+ throw new RuntimeException("Fehler bei Passwortänderung:"
+ + e);
+ }
+
+ }
+ // DQ 6.10.2006 erstmal ins SuperxDBServlet (Methode doPost)
+ // verlagert
+ /*
+ * if (passwd_sha.equals(CryptUtils.encodeSHA(user.getPasswd()))) {
+ * if (aktVersuch.shortValue() >= 0) { login_ok = true; } else {
+ * login_ok = true; login_ok = changePwd(user); } }
+ */
+ login_ok = true;
+
+ if (login_ok) {
+ SxSQL.initParams();
+ // execute("update userinfo set akt_versuch=0 where benutzer =
+ // '" + user.getName() + "'");
+ } else {
+ String operator = "+";
+ if (aktVersuch.shortValue() < 0)
+ operator = "-";
+ /*
+ * String sql = "update userinfo set akt_versuch=akt_versuch" +
+ * operator + "1 " + " where benutzer = '" + user.getName() +
+ * "';"; execute(sql);
+ */
+ throw new Exception("Fehlerhaftes Kennwort für Benutzer '"
+ + user.getName() + "'");
+
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ String msg = "Datenbankverbindung konnte nicht aufgebaut werden. "
+ + e.toString();
+ msg = msg.replace(':', '-');
+ if (msg.indexOf("NichtAngemeldetException") > -1)
+ throw new IllegalStateException(
+ "Anmeldung fehlerhaft oder abgelaufen");
+ else
+ throw new Exception(msg);
+ }
+ }
+
+ /**
+ * @deprecated sollte das XMl-Frontend machen
+ * @param user
+ * @return
+ * @throws Exception
+ */
+ private static boolean changePwd(User user) throws Exception {
+ boolean login_ok;
+ SxPasswdChangeDlg dlg = new SxPasswdChangeDlg(null,
+ "Bitte ändern Sie Ihr Passwort ");
+ dlg.setUsername(user.getName());
+ dlg.setNewPasswordChecker(SxSQL.newPasswordChecker);
+ dlg.setOldPassword(user.getPasswd());
+ dlg.setUsernameFieldEnabled(false);
+ dlg.setCheckOldPasswdWanted(false);
+ dlg.show();
+ if (dlg.wasOkSelected()) {
+ storePwd(user, dlg.getNewPasswd(), false);
+ login_ok = true;
+ execute("update userinfo set kennwort=null where tid=" + userID);
+ } else {
+ login_ok = false;
+ WarningMessage
+ .show(null,
+ "Sie können mit SuperX nur arbeiten,wenn Sie Ihr Passwort ändern.\nBitte melden Sie dazu sich neu an.",
+ "SuperX");
+ throw new RuntimeException("Passwortänderung nötig");
+ }
+ return login_ok;
+ }
+
+ static public Integer getUserID() {
+ // kopieren damit keiner von außen aus Versehen überschreibt
+ if (userID != null)
+ return new Integer(userID.intValue());
+ else {
+ System.out
+ .println("Achtung! userID dürfte eigentlich nicht null sein!!");
+ return new Integer(-1);
+ }
+ }
+
+ static public final synchronized void storePwd(User user, String newpasswd,
+ boolean isCheckOldPasswdWanted) throws Exception {
+
+ if (isCheckOldPasswdWanted && !isAdmin())
+ checkPwd(user);
+
+ execute("userchange|" + NumberUtils.getRandomInt(9)
+ + CryptUtils.encodeSHA(newpasswd + CryptUtils.geheimnis1) + "|"
+ + user.getName());
+
+ if (gesamt.getUpdateCount() != 1)
+ throw new Exception("Benutzer '" + user.getName() + "'"
+ + " nicht gefunden !");
+
+ user.setPasswd(newpasswd);
+ proto_fkt_id = 6; // CH_PASSWD_NEW
+ // prot_sql.replace(proto_id_pos, proto_id_pos + 1, (new Integer(
+ // proto_fkt_id)).toString());
+
+ // execute(prot_sql.toString());
+ // damit sichergestellt wird, das kein erneues Ändern nötig
+
+ execute("update userinfo set akt_versuch=0 where benutzer = '"
+ + user.getName() + "'");
+ }
+
+ static public boolean isAdmin() {
+ if (adminUserInt.intValue() > 0)
+ return true;
+ else
+ return false;
+ }
+
+ public static synchronized void executeAll(String stmt) throws SQLException {
+
+ // String bleibt zusammen, aber Schleife wird durchlaufen, um
+ // Multi-Statement zu kennzeichnen
+
+ StringTokenizer st = new StringTokenizer(stmt, ";");
+ int n = 0;
+ while (st.hasMoreTokens()) {
+ n++;
+ String sqlstmt = st.nextToken().trim();
+ if (sqlstmt.length() < 10)
+ break;
+ // besser über String suchen!!
+ }
+ // execute (sqlstmt); Wint neu++
+ if (n < 2) {
+ executeQuery(stmt);
+ } else {
+
+ executeQuery("multi:" + stmt);
+ }
+ }
+
+ static private synchronized void execute(String stmt) throws SQLException {
+
+ applet_servlet_connection("single" + stmt);
+ }
+
+ static synchronized void executeQuery(String query) throws SQLException {
+ if (!query.trim().equals("") && !query.trim().equals("null"))
+ applet_servlet_connection(query);
+ }
+
+ static public int getUpdateCount() throws SQLException {
+ return updateCount;
+ }
+
+ static public String getAktuelleNachricht() {
+ return aktuelleNachricht;
+ }
+
+ static public int getColumnCount() {
+ return numberOfColumns;
+ }
+
+ /*
+ * static public String getColumnName(int column) { if (columnNames[column]
+ * != null) return columnNames[column]; else return ""; }
+ */
+ static public int getRowCount() {
+ return rows.size();
+ }
+
+ /**
+ * static public Object getObjectAt(int aRow, int aColumn) { ResultRow row =
+ * (ResultRow) rows.get(aRow); return row.get(aColumn); }
+ */
+
+ static public Vector getResultVector() {
+ Vector v = new Vector();
+ for (Iterator it = rows.iterator(); it.hasNext();) {
+ SxResultRow r = (SxResultRow) it.next();
+ Vector row = new Vector();
+ for (Iterator it2 = r.iterator(); it2.hasNext();)
+ row.add(it2.next());
+ v.add(row);
+ }
+ return v;
+ }
+
+ static public SxResultSet getResult() {
+ return rows;
+ }
+
+ static public SxSQLMetaData getResultSetMetaData() {
+ /*
+ * try { FileOutputStream ostream = new FileOutputStream("t.tmp");
+ * ObjectOutputStream p_out = new ObjectOutputStream(ostream);
+ *
+ * p_out.writeObject(metaData);
+ *
+ * p_out.flush(); ostream.close(); } catch (Exception ex) {
+ * System.err.println (ex); }
+ */
+ SxSQLMetaData meta = null;
+ /*
+ * try { FileInputStream istream = new FileInputStream("t.tmp");
+ * ObjectInputStream p_in = new ObjectInputStream(istream);
+ *
+ * meta = (SxSQLMetaData) p_in.readObject();
+ *
+ * istream.close(); } catch (Exception ex) { System.err.println (ex); }
+ */
+
+ return metaData;
+ }
+
+ /*
+ * public void cancel() throws Exception { try { System.err.println("SxSQL:
+ * Cancel statement"); statement.cancel(); } catch (Exception e) {
+ * System.err.println("SxSQL: Error canceling statement: " + e); } }
+ */
+
+ /*
+ * public void cancel(String url, String user, String passwd) throws
+ * Exception { try { System.err.println("SxSQL: Cancel statement");
+ * statement.cancel(); } catch (Exception e) { System.err.println("SxSQL:
+ * Error canceling statement: " + e); } }
+ */
+
+ static public void cancel() throws Exception {
+ try {
+ System.err.println("SxSQL: Cancel statement");
+ // statement.cancel();
+ ObjectInputStream inputFromServlet = null;
+ ObjectOutputStream outputToServlet = null;
+
+ servletConnection.disconnect();
+
+ } catch (Exception e) {
+ System.err.println("SxSQL: Error canceling statement: " + e);
+ }
+ }
+
+ static public synchronized void close() {
+ int proto_fkt_id = 4; // LOGOUT
+
+ // prot_sql.replace( proto_id_pos, proto_id_pos + 1, (new
+ // Integer(proto_fkt_id)).toString());
+ System.out.println("in close");
+
+ try {
+ System.err.println("SxSQL: Closing db connection");
+ if (!isClosed) {
+ // execute(prot_sql.toString());
+
+ if (resultSet != null)
+ resultSet.close();
+ if (statement != null)
+ statement.close();
+
+ ObjectInputStream inputFromServlet = null;
+ ObjectOutputStream outputToServlet = null;
+
+ servletConnection.disconnect();
+ // Alter Rechte Bug - userID wurde beim Schließen der Connection
+ // auf null gesetzt
+ // wenn danach ein Programmteil getUserID() aufruft, wird nicht
+ // null sondern
+ // -1 zurückgeliefert
+ // userID = null;
+ // System.out.println(" SxSQl close: userID auf null gesetzt");
+ isClosed = true;
+ }
+ } catch (SQLException e) {
+ System.err.println("SxSQL: Error closing db connection: " + e);
+ }
+ }
+
+ static public boolean isActive() {
+ return !isClosed;
+ }
+
+ /**
+ * auf diese Methode sollte man sich eh nicht verlassen static protected
+ * void finalize() throws Throwable { if (!isClosed) { close(); userID =
+ * null; System.out.println(" SxSQl finalize: userID auf null gesetzt");
+ * isClosed = true; servletConnection.disconnect(); } }
+ *
+ * @throws SQLException
+ */
+
+ /**
+ * für freemarker zeugs, query wird wie üblich zum Hashtable hinzugefügt
+ *
+ * @deprecated wegen Serialisierung doch nicht so gut ganzen Kram
+ * rüberzuschicken
+ */
+ static synchronized void specialExecute(String query, Hashtable htable)
+ throws SQLException {
+ PrintWriter outTest = null;
+ BufferedReader inTest = null;
+ Vector superX_elVector = new Vector();
+ htable.put("query", query);
+ try {
+
+ servletConnection = (HttpURLConnection) superXDbServletUrl
+ .openConnection();
+ servletConnection.setDoInput(true);
+ servletConnection.setDoOutput(true);
+
+ // Don't used a cached version of URL connection.
+ servletConnection.setUseCaches(false);
+
+ // Specify the content type that we will send binary data
+ servletConnection.setRequestProperty("Content-Type",
+ "application/octet-stream");
+
+ } catch (Exception e) {
+ System.out.println(e.toString());
+ throw new SQLException(e.toString());
+ }
+
+ rows_ret = new Vector();
+
+ // Query übergeben
+
+ try {
+ // send the SuperX_el object to the servlet using serialization
+
+ outputToServlet = new ObjectOutputStream(
+ servletConnection.getOutputStream());
+
+ outputToServlet.writeObject(htable);
+ outputToServlet.flush();
+ outputToServlet.close();
+
+ } catch (IOException e) {
+ System.out.println(e.toString());
+ throw new SQLException(e.toString());
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new SQLException(e.toString());
+ }
+
+ // Read the input from the servlet.
+ //
+ // The servlet will return a serialized vector containing
+ // SuperX_el entries.
+ //
+ // System.out.println("Getting input stream");
+
+ // output lesen
+ ObjectInputStream inputFromServlet = null;
+ try {
+ inputFromServlet = new ObjectInputStream(
+ servletConnection.getInputStream());
+ gesamt = (SuperX_el) inputFromServlet.readObject();
+ aktuelleNachricht = gesamt.getAktuelleNachricht();
+ // System.out.println("Nachricht:"+aktuelleNachricht);
+
+ // if (ErrorString.length()>1) System.out.println("Fehlermeld. vom
+ // Servlet:"+ErrorString);
+ numberOfColumns = gesamt.getColumnCount();
+ // columnNames = gesamt.getColumnNames();
+ rows = gesamt.getResultSet();
+ metaData = new SxSQLMetaData(gesamt);
+ inputFromServlet.close();
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ System.err.println(gesamt.getError_String()); // Wint
+ throw new SQLException(gesamt.getError_String());
+ }
+ // System.out.println( "nach Rueckgabe Vector in Applet!!" );
+ errorString = "" + gesamt.getError_String();
+ if (errorString != null && errorString.trim().length() > 1) {
+ if ((logToKonsole.equals("errors") || logToKonsole.equals("all"))
+ && aktuelleNachricht != null) {
+ System.out
+ .println("----------------------------------------------------");
+ System.out.println("Folgender Select ergab einen Fehler: ");
+ System.out.println(aktuelleNachricht);
+ // System.out.println(logquery);
+ System.out
+ .println("----------------------------------------------------");
+
+ }
+ // Bei Fehlern in der Abfrage wird die Verbindung beendet, um
+ // temporäre Tabellen zu löschen
+ servletConnection.disconnect();
+ throw new SQLException("im Servlet " + gesamt.getError_String());
+ }
+ }
+
+ static private synchronized void applet_servlet_connection(String query)
+ throws SQLException {
+ String logquery = query.trim();
+ if (logquery.substring(0, 6).equals("single"))
+ logquery = query.substring(6);
+ if (logquery.substring(0, 6).equals("multi:"))
+ logquery = query.substring(6);
+ // Anmeldedaten nicht im log zeigen
+ if (logquery.startsWith("Anmeldung"))
+ logquery = "Anmeldung";
+ if (logToKonsole.equals("all")) {
+ System.out.println("----------------Select-Stmt, gestartet am "
+ + SxDate.getNowString() + "-----------------");
+ System.out.println(logquery);
+ // System.out.println("----------------------------------------------------");
+ }
+ PrintWriter outTest = null;
+ BufferedReader inTest = null;
+ DataOutputStream printout;
+ Vector superX_elVector = new Vector();
+ rows_ret = new Vector();
+
+ // aus Anmeldung|superx|anfang12
+ // werden request param und query nur "Anmeldung"
+ if (query.startsWith("Anmeldung")) {
+ List l = StringUtils.getStringTokenizedList(query, "|");
+ try {
+ servletConnection =
+ // (HttpURLConnection) new
+ // URL(superXDbServletUrl.toString()+"?kennung="+l.get(1)+"&passwort="+l.get(2)).openConnection();
+ (HttpURLConnection) new URL(superXDbServletUrl.toString())
+ .openConnection();
+ query = "Anmeldung";
+ servletConnection.setRequestProperty("Content-Type",
+ "application/x-www-form-urlencoded");
+ servletConnection.setDoInput(true);
+ servletConnection.setDoOutput(true);
+
+ // Don't used a cached version of URL connection.
+ servletConnection.setUseCaches(false);
+
+ // Send POST output.
+ printout = new DataOutputStream(
+ servletConnection.getOutputStream());
+ // System.out.println("Anmeldung für User "+ l.get(1) );
+ String content = "kennung=" + l.get(1) + "&passwort="
+ + l.get(2) + "&MandantenID=" + mandantenID + "&query="
+ + query;
+ printout.writeBytes(content);
+ printout.flush();
+ printout.close();
+ // System.out.println("Anfrage für User "+ l.get(1)+ "
+ // gesendet");
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new SQLException(e.toString());
+ }
+ } else {
+ try {
+ servletConnection = (HttpURLConnection) new URL(
+ superXDbServletUrl.toString() + ";jsessionid="
+ + jsessionid).openConnection();
+ // Specify the content type that we will send binary data
+ servletConnection.setRequestProperty("Content-Type",
+ "application/octet-stream");
+ servletConnection.setDoInput(true);
+ servletConnection.setDoOutput(true);
+
+ // Don't used a cached version of URL connection.
+ servletConnection.setUseCaches(false);
+ // send the SuperX_el object to the servlet using serialization
+
+ outputToServlet = new ObjectOutputStream(
+ servletConnection.getOutputStream());
+
+ // serialize the object
+ // Hashtable htable=new Hashtable();
+ // htable.put("query",query);
+
+ outputToServlet.writeObject(mandantenID);
+ // 3/2016 Umlaut kodierung
+ query = encodeUmlauts(query);
+ String queryCode = de.memtext.util.CryptUtils
+ // .simpleEncryptString2(query);
+ .encryptStringDES(query);
+ outputToServlet.writeObject(queryCode);
+ String signature = null;
+ if (dsaHandler != null) {
+ signature = dsaHandler.sign(queryCode);
+ }
+ outputToServlet.writeObject(signature);
+ // outputToServlet.writeObject(htable);
+ outputToServlet.flush();
+ outputToServlet.close();
+ } catch (IOException e) {
+ System.out.println(e.toString());
+ throw new SQLException(e.toString());
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new SQLException(e.toString());
+ }
+ }
+
+ // Query übergeben
+
+ // Read the input from the servlet.
+ //
+ // The servlet will return a serialized vector containing
+ // SuperX_el entries.
+ //
+ // System.out.println("Getting input stream");
+
+ // output lesen
+ ObjectInputStream inputFromServlet = null;
+ // System.out.println("Response vom Server lesen" );
+
+ try {
+ inputFromServlet = new ObjectInputStream(
+ servletConnection.getInputStream());
+ // System.out.println("Response vom Server gelesen" );
+
+ gesamt = (SuperX_el) inputFromServlet.readObject();
+ decodeUmlauts();
+ jsessionid = gesamt.getJsessionid();
+
+ aktuelleNachricht = gesamt.getAktuelleNachricht();
+ // System.out.println("Nachricht:"+aktuelleNachricht);
+
+ // if (ErrorString.length()>1) System.out.println("Fehlermeld. vom
+ // Servlet:"+ErrorString);
+ numberOfColumns = gesamt.getColumnCount();
+ // columnNames = gesamt.getColumnNames();
+ rows = gesamt.getResultSet();
+ metaData = new SxSQLMetaData(gesamt);
+ inputFromServlet.close();
+
+ } catch (Exception e) {
+ String msg = gesamt.getError_String();
+ if (e instanceof java.io.StreamCorruptedException)
+ msg = "Anmeldefehler (falsche jsessionid?!) " + msg;
+ e.printStackTrace();
+ System.err.println(); // Wint
+ throw new SQLException(msg);
+ }
+ // System.out.println( "nach Rueckgabe Vector in Applet!!" );
+ errorString = "" + gesamt.getError_String();
+ if (errorString != null && errorString.trim().length() > 1) {
+ if ((logToKonsole.equals("errors") || logToKonsole.equals("all"))
+ && aktuelleNachricht != null) {
+ System.out
+ .println("----------------------------------------------------");
+ System.out.println("Folgender Select ergab einen Fehler: ");
+ System.out.println(aktuelleNachricht);
+ // System.out.println(logquery);
+ System.out
+ .println("----------------------------------------------------");
+
+ }
+ // Bei Fehlern in der Abfrage wird die Verbindung beendet, um
+ // temporäre Tabellen zu löschen
+ servletConnection.disconnect();
+ throw new SQLException("im Servlet " + gesamt.getError_String());
+ }
+
+ }
+
+ public static void decodeUmlauts() {
+ gesamt.setError_String(decodeUmlauts(gesamt.getError_String()));
+ gesamt.setAktuelleNachricht(decodeUmlauts(gesamt.getAktuelleNachricht()));
+ gesamt.setRuntimeMessage(decodeUmlauts(gesamt.getRuntimeMessage()));
+ String[] colLabels = gesamt.getColumnLabels();
+ for (int i = 0; i < colLabels.length; i++) {
+ colLabels[i] = decodeUmlauts(colLabels[i]);
+
+ }
+ gesamt.setColumnLabels(colLabels);
+ SxResultSet rs = gesamt.getResultSet();
+ for (Iterator it = rs.iterator(); it.hasNext();) {
+ SxResultRow row = (SxResultRow) it.next();
+ int i = 0;
+ for (Iterator it2 = row.iterator(); it2.hasNext();) {
+ Object o = it2.next();
+ if (o instanceof String)
+ { o = decodeUmlauts(o.toString());
+ row.set(i, o);
+ }
+ i++;
+
+ }
+
+ }
+ }
+
+ private static String decodeUmlauts(String txt) {
+ if (txt != null) {
+ txt = StringUtils.replace(txt, "///oe///", "ö");
+ txt = StringUtils.replace(txt, "///Oe///", "Ö");
+ txt = StringUtils.replace(txt, "///ae///", "ä");
+ txt = StringUtils.replace(txt, "///Ae///", "Ä");
+ txt = StringUtils.replace(txt, "///ue///", "ü");
+ txt = StringUtils.replace(txt, "///Ue///", "Ü");
+ txt = StringUtils.replace(txt, "///ss///", "ß");
+ }
+ return txt;
+ }
+
+ static String encodeUmlauts(String query) {
+ query = StringUtils.replace(query, "ö", "///oe///");
+ query = StringUtils.replace(query, "Ö", "///Oe///");
+ query = StringUtils.replace(query, "ä", "///ae///");
+ query = StringUtils.replace(query, "Ä", "///Ae///");
+ query = StringUtils.replace(query, "ü", "///ue///");
+ query = StringUtils.replace(query, "Ü", "///Ue///");
+ query = StringUtils.replace(query, "ß", "///ss///");
+ return query;
+ }
+
+ static void setUrl(String url) throws MalformedURLException {
+ superXDbServletUrl = new URL(url);
+ }
+
+ static public String getErrorString() {
+ return errorString;
+ }
+
+ /**
+ * nur von SuperX.start() aufgerufen
+ *
+ * @param userID
+ * The userID to set.
+ */
+ public static void setUserID(Integer userID) {
+ SxSQL.userID = userID;
+ }
+
+ public static void setLogMode(String logParam) {
+ logToKonsole = logParam;
+ }
+
+ public static String getUserFromServlet() throws SQLException {
+
+ executeQuery("get_user");
+ SxResultRow row = (SxResultRow) gesamt.getResultSet().first();
+ String user = (String) row.get(0);
+
+ return user;
+ }
+
+ /**
+ * Aufruf von SuperX.start und auch noch mal von SxSQL.checkPwd (am Ende) um
+ * auch bei Applicationstart dafür zu sorgen, dass privateKey geholt wird
+ *
+ * @throws Exception
+ */
+ public static void initParams() throws Exception {
+ executeQuery("get_params");
+ String privateKeyEncoded = gesamt.getCheckval();
+ if (privateKeyEncoded != null && !privateKeyEncoded.trim().equals("")) {
+ privateKeyEncoded = CryptUtils.decryptStringDES(privateKeyEncoded);
+ dsaHandler = new DSAHandler(privateKeyEncoded);
+ } else
+ dsaHandler = null;
+ newPasswordChecker = gesamt.newPasswordChecker;
+ }
+}
diff --git a/src/de/superx/applet/SxSQLMetaData.java b/src/de/superx/applet/SxSQLMetaData.java
new file mode 100644
index 0000000..df0e7ba
--- /dev/null
+++ b/src/de/superx/applet/SxSQLMetaData.java
@@ -0,0 +1,100 @@
+package de.superx.applet;
+import java.io.Serializable;
+import java.sql.SQLException;
+import java.util.Vector;
+
+import de.superx.common.SuperX_el;
+/**
+ * Ein Teil der Implementation des JDBC ResultSetMetaData interface.
+ * @author Rainer Behr (rainer@rbehr.de)
+ * @version 1.0
+ */
+
+
+
+public class SxSQLMetaData implements Serializable
+{
+ private Vector V_cols = new Vector ();;
+ private int numColumns = -1;
+
+
+ public SxSQLMetaData (SuperX_el gesamt)
+ throws SQLException
+ {
+ // used MetaData
+ // -------------
+ // String getColumnName(int column)
+ // String getColumnLabel(int column)
+ // int getColumnDisplaySize(int column)
+ // int getColumnType(int column)
+ // int getScale(int column)
+ // boolean isWritable(int column)
+
+ //ResultSetMetaData meta = resultset.getMetaData();
+ numColumns = gesamt.getColumnCount();
+
+ for (int i = 0; i < numColumns; i++)
+ {
+ Vector V_column = new Vector();
+ V_column.add (0, gesamt.getColumnNames() [i]);
+ V_column.add (1, gesamt.getColumnLabels() [i]);
+ V_column.add (2, new Integer (gesamt.getColumnDisplaySizes() [i]));
+ V_column.add (3, new Integer (gesamt.getColumnTypes() [i]));
+ V_column.add (4, new Integer (gesamt.getScales() [i]));
+ V_column.add (5, new Boolean (gesamt.getisWritable() [i]));
+
+ V_cols.add (V_column);
+ }
+ }
+
+ public int getColumnCount()
+ {
+ return numColumns;
+ }
+
+ /**
+ *
+ * @param column
+ * @return
+ * @deprecated not currently used
+ */
+ public String getColumnName (int column)
+ {
+ Vector V_column = (Vector) V_cols.elementAt (column - 1);
+ return (String) V_column.elementAt (0);
+ }
+
+ public String getColumnLabel (int column)
+ {
+ Vector V_column = (Vector) V_cols.elementAt (column - 1);
+ return (String) V_column.elementAt (1);
+ }
+
+ public int getColumnDisplaySize (int column)
+ {
+ Vector V_column = (Vector) V_cols.elementAt (column - 1);
+ return ((Integer) V_column.elementAt (2)).intValue();
+ }
+
+ public int getColumnType (int column)
+ {
+ Vector V_column = (Vector) V_cols.elementAt (column - 1);
+ return ((Integer) V_column.elementAt (3)).intValue();
+ }
+ public int getScale (int column)
+ {
+ Vector V_column = (Vector) V_cols.elementAt (column - 1);
+ return ((Integer) V_column.elementAt (4)).intValue();
+ }
+
+ public boolean isWritable (int column)
+ {
+ Vector V_column = (Vector) V_cols.elementAt (column - 1);
+ return ((Boolean) V_column.elementAt (5)).booleanValue();
+ }
+
+
+
+
+
+}
diff --git a/src/de/superx/applet/SxTableMap.java b/src/de/superx/applet/SxTableMap.java
new file mode 100644
index 0000000..252af19
--- /dev/null
+++ b/src/de/superx/applet/SxTableMap.java
@@ -0,0 +1,136 @@
+// Beispielklasse aus dem JavaTutorial (http://java.sun.com/docs/books/tutorial) für SuperX angepasst
+/*
+ * @(#)TableMap.java 1.4 97/12/17
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * This software is the confidential and proprietary information of Sun
+ * Microsystems, Inc. ("Confidential Information"). You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with Sun.
+ *
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
+ * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
+ * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
+ * THIS SOFTWARE OR ITS DERIVATIVES.
+ *
+ */
+
+/**
+ * In a chain of data manipulators some behaviour is common. TableMap
+ * provides most of this behavour and can be subclassed by filters
+ * that only need to override a handful of specific methods. TableMap
+ * implements TableModel by routing all requests to its model, and
+ * TableModelListener by routing all events to its listeners. Inserting
+ * a TableMap which has not been subclassed into a chain of table filters
+ * should have no effect.
+ *
+ * @version 1.4 12/17/97
+ * @author Philip Milne */
+
+package de.superx.applet;
+import java.util.Vector;
+
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.AbstractTableModel;
+
+/**
+ * Erweiterung des TabellenModells. Wird für SxTable benötigt.
+ *
+ * @version 1.4 12/17/97
+ * @author Philip Milne, erweitert von Rainer Behr
+ * @see SxTable
+ */
+
+
+public class SxTableMap extends AbstractTableModel implements TableModelListener, SxTableModel
+{
+ protected SxTableModel model;
+
+ public SxTableModel getModel()
+ {
+ return model;
+ }
+
+ public void setModel(SxTableModel model)
+ {
+ this.model = model;
+ model.addTableModelListener(this);
+ }
+
+ // By default, Implement TableModel by forwarding all messages
+ // to the model.
+
+ public Object getValueAt(int aRow, int aColumn)
+ {
+ return model.getValueAt(aRow, aColumn);
+ }
+ public Object getValueAt2(int aRow, int aColumn)
+ {
+ return model.getValueAt2(aRow, aColumn);
+ }
+ // r.b. extension for proper sorting
+ public Object getObjectAt(int aRow, int aColumn)
+ {
+ return model.getObjectAt(aRow, aColumn);
+ }
+
+ // r.b. extension for easy data setting
+ public void setDataVector(Vector Rows, Vector Header, Object Meta)
+ {
+ model.setDataVector(Rows, Header, Meta);
+ }
+
+ // r.b. extension for easy data setting
+ public void setDataVector(Vector Rows)
+ {
+ model.setDataVector(Rows);
+ }
+
+ public void setValueAt(Object aValue, int aRow, int aColumn)
+ {
+ model.setValueAt(aValue, aRow, aColumn);
+ }
+
+ public int getRowCount() {
+ return (model == null) ? 0 : model.getRowCount();
+ }
+
+ public int getColumnCount() {
+ return (model == null) ? 0 : model.getColumnCount();
+ }
+
+ public String getColumnName(int aColumn) {
+ return model.getColumnName(aColumn);
+ }
+
+ // r.b. extension for max. columnsize
+ public int getColumnSize(int aColumn) {
+ return model.getColumnSize(aColumn);
+ }
+
+ public Class getColumnClass(int aColumn) {
+ return model.getColumnClass(aColumn);
+ }
+
+ public void setEditable(boolean editable)
+ {
+ model.setEditable(editable);
+ }
+
+ public boolean isCellEditable(int row, int column) {
+ return model.isCellEditable(row, column);
+ }
+//
+// Implementation of the TableModelListener interface,
+//
+
+ // By default forward all events to all the listeners.
+ public void tableChanged(TableModelEvent e) {
+ fireTableChanged(e);
+ }
+}
diff --git a/src/de/superx/applet/SxTableModel.java b/src/de/superx/applet/SxTableModel.java
new file mode 100644
index 0000000..2edd86f
--- /dev/null
+++ b/src/de/superx/applet/SxTableModel.java
@@ -0,0 +1,27 @@
+
+package de.superx.applet;
+import java.util.Vector;
+
+import javax.swing.table.TableModel;
+/**
+ * Eine Erweiterung des TableModel-Interfaces.
+ * @autor Rainer Behr
+ * @version 1.0
+ * @see SxTableMap
+*/
+
+public interface SxTableModel extends TableModel
+{
+ public Object getObjectAt(int aRow, int aColumn);
+
+ public void setDataVector(Vector rows, Vector header, Object meta);
+
+ public void setDataVector(Vector rows);
+
+ public int getColumnSize(int aColumn);
+
+ public void setEditable(boolean editable);
+
+ public Object getValueAt2(int aRow, int aColumn);
+
+}
diff --git a/src/de/superx/applet/SxTablePanel.java b/src/de/superx/applet/SxTablePanel.java
new file mode 100644
index 0000000..e5b6c58
--- /dev/null
+++ b/src/de/superx/applet/SxTablePanel.java
@@ -0,0 +1,1839 @@
+// ursprünglich basierend auf einer Beispielklasse aus dem JavaTutorial (http://java.sun.com/docs/books/tutorial) für SuperX angepasst
+/*
+ * @(#)TableExample2.java 1.6 97/12/18
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * This software is the confidential and proprietary information of Sun
+ * Microsystems, Inc. ("Confidential Information"). You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with Sun.
+ *
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
+ * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
+ * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
+ * THIS SOFTWARE OR ITS DERIVATIVES.
+ *
+ * A a UI around the JDBCAdaptor, allowing database data to be interactively
+ * fetched, sorted and displayed using Swing.
+ *
+ * @version 1.6 12/18/97
+ * @author Philip Milne
+ */
+
+package de.superx.applet;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.InputEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionAdapter;
+import java.awt.print.PageFormat;
+import java.awt.print.Paper;
+import java.awt.print.Printable;
+import java.awt.print.PrinterException;
+import java.awt.print.PrinterJob;
+import java.util.Vector;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.DefaultCellEditor;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.SwingConstants;
+import javax.swing.border.BevelBorder;
+import javax.swing.event.CellEditorListener;
+import javax.swing.event.ChangeEvent;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.JTableHeader;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+
+import de.memtext.icons.MBStandardIcons;
+/**
+ * SuperX-Tabelle mit Funktionalität zum Sortieren, Drucken und Kopieren in die Zwischenablage
+ * @version 2.0 01-01-02
+ * @author Reiner Behr, erweitert von Meikel Bisping
+
+*/
+
+public class SxTablePanel extends JPanel implements Printable {
+
+ private static final int MAX_COLUMN_WIDTH = 400;
+ private static final Font HEADERFONT = new Font("SansSerif", Font.BOLD, 12);
+private SxLogoPanel logo = null;
+ //eigentlich wird nur das ParameterPanel benötigt
+ private SxMask sxMask;
+ private SxTableSorter sorter = null;
+ JTable rowheaderTable = null;
+ JTable table = null;
+ private MouseAdapter mouseToHeader = null;
+ private MouseAdapter mouseInTable = null;
+ private Vector V_header = new Vector();
+ private Vector V_width = new Vector();
+ private int fixedColumns = 0;
+ private int max_headerlines = 1;
+ //mb for selection aktuelle Zeile merken
+ private int aktuellrow = 0;
+
+ private JScrollPane tableScrollPane;
+ //MB print
+ private JScrollPane tmp_druck;
+ private SxTablePanel tmp_drucktab = null;
+
+ private JTextField statusField = null;
+
+ private String selectStmt = null;
+ private String hsName = null;
+ //MB Seiteneinstellungen merken
+ private PageFormat defaultFormat = null;
+
+ //wird nur für Reset gebraucht
+ private Vector datarows, headerVector, widthVector;
+ private Object metaObject;
+ public SxTablePanel() {
+ // Create the table.
+ tableScrollPane = createTable();
+ tableScrollPane.setBorder(new BevelBorder(BevelBorder.LOWERED));
+
+ // Add all the components to the panel.
+
+ this.setLayout(new BorderLayout());
+ this.setName("SxTable");
+ this.add(tableScrollPane, "Center");
+ }
+
+ public synchronized void setData(
+ Vector datarows,
+ Vector headerVector,
+ Vector widthVector,
+ // Vector spaltenExplanations,
+ Object metaObject) {
+ this.datarows = datarows;
+ this.headerVector = headerVector;
+ this.widthVector = widthVector;
+ this.metaObject = metaObject;
+ if (table != null) {
+ SxTableModel model = sorter.getModel();
+ if (model == null) {
+ sorter.setModel(new SxJDBCAdapter());
+ }
+ V_header.removeAllElements();
+ V_width.removeAllElements();
+ if (datarows.size() == 0 || headerVector.size() == 0) {
+ fixedColumns = 0;
+
+ } else {
+
+ if (headerVector != null)
+ V_header.addAll(headerVector);
+ if (widthVector != null)
+ V_width.addAll(widthVector);
+ }
+ sorter.setDataVector(datarows, V_header, metaObject);
+ setTableProperties(table);
+ setRowHeader(datarows);
+ for (int m = 0; m < fixedColumns; m++)
+ removeFixedColumns(table, 0);
+ }
+ }
+/**
+ * wird von SxMask.searchListener aufgerufen, wenn die selbe Maske wie beim
+ * letzten Aufruf und kein SQL im Header
+ * Wird von SxInsert/DeleteListener aufgerufen, wenn bei einer Mehrfachauswahl
+ * ein Element hinzukommt/wegfällt
+ * @param datarows
+ */
+ public synchronized void setData(Vector datarows) {
+ this.datarows = datarows;
+ if (table != null) {
+ SxTableModel model = sorter.getModel();
+ if (model == null)
+ sorter.setModel(new SxJDBCAdapter());
+
+ sorter.setDataVector(datarows);
+
+ setHeaderModel(datarows);
+ }
+ }
+ /**
+ * used to restore the original format of the table
+ *
+ */
+ private void restore() {
+ setData(datarows, headerVector, widthVector, metaObject);
+
+ }
+ public void setEditable(boolean editable) {
+ SxTableModel model = sorter.getModel();
+ if (model != null)
+ sorter.setEditable(editable);
+ }
+
+ public void setFixedColumns(int numberOfFixedColumns) {
+ fixedColumns = numberOfFixedColumns;
+ }
+
+ public int getFixedColumns() {
+ return fixedColumns;
+ }
+
+ //MB
+ public JScrollPane getScrollPane() {
+ return tableScrollPane;
+ }
+
+ public String getText() {
+ TableColumnModel r_columnModel = rowheaderTable.getColumnModel();
+ TableColumnModel t_columnModel = table.getColumnModel();
+ TableColumn tableColumn;
+ //MB selection
+ boolean areRowsSelected = false;
+ boolean areColsSelected = false;
+ int[] selectedRows;
+ int[] selectedCols;
+ if (table.getSelectedRowCount() > 0) {
+ areRowsSelected = true;
+ selectedRows = table.getSelectedRows();
+ } else
+ selectedRows = new int[1];
+ if (table.getSelectedColumnCount() > 0) {
+ areColsSelected = true;
+ selectedCols = table.getSelectedColumns();
+ } else
+ selectedCols = new int[1];
+
+ StringBuffer value = new StringBuffer();
+
+ String tab = "\t";
+ String nl = "\n";
+
+ //Rowheader z.B. Studiengang
+ if (rowheaderTable != null)
+ for (int i = 0; i < rowheaderTable.getColumnCount(); i++) {
+ tableColumn = r_columnModel.getColumn(i);
+ value.append(tableColumn.getHeaderValue().toString());
+ value.append(tab);
+ }
+
+ if (table == null)
+ return "";
+
+ // Spaltennamen
+ for (int i = 0; i < table.getColumnCount(); i++) {
+ tableColumn = t_columnModel.getColumn(i);
+ //MB selection if
+ if ((areColsSelected == false)
+ || (isRowOrColSelected(i, selectedCols))) {
+ value.append(tableColumn.getHeaderValue().toString());
+ if (i < table.getColumnCount() - 1)
+ value.append(tab);
+ }
+ }
+
+ value.append(nl);
+
+ //Zeilenweise Rowheader + Tablevalues
+ int n, m;
+ for (n = 0; n < table.getRowCount(); n++) {
+ if (rowheaderTable != null)
+ if ((areRowsSelected == false)
+ || (isRowOrColSelected(n, selectedRows))) {
+
+ for (m = 0; m < rowheaderTable.getColumnCount(); m++) {
+ value.append(
+ rowheaderTable.getValueAt(n, m).toString());
+ value.append(tab);
+ }
+
+ for (m = 0; m < table.getColumnCount(); m++) {
+
+ if ((areColsSelected == false)
+ || (isRowOrColSelected(m, selectedCols))) {
+ value.append(table.getValueAt(n, m).toString());
+ if (m < table.getColumnCount() - 1)
+ value.append(tab);
+ }
+ }
+
+ value.append(nl);
+ }
+ }
+
+ return value.toString();
+ }
+ // MB selection
+ private boolean isRowOrColSelected(int welche, int[] selektierte) {
+ boolean drin = false;
+ for (int i = 0; i < selektierte.length; i++)
+ if (welche == selektierte[i])
+ drin = true;
+ return drin;
+ }
+
+ /* not used any more
+ public void saveTable(File out_file, SxMask sxMask) {
+ FileOutputStream fos;
+ byte[] data_bytes;
+ String err_msg = null;
+
+ try {
+ if (out_file.exists()) {
+ String msg =
+ "Datei '" + out_file.getName() + "' überschreiben ?";
+ String[] options = { "Überschreiben", "Abbrechen" };
+
+ int rc =
+ JOptionPane.showOptionDialog(
+ this,
+ msg,
+ "Warnung",
+ JOptionPane.YES_NO_OPTION,
+ JOptionPane.WARNING_MESSAGE,
+ null,
+ options,
+ options[0]);
+ if (rc != JOptionPane.OK_OPTION)
+ return;
+ }
+
+ // Parameterliste holen
+ SxForm maskeForm = sxMask.getForm();
+ SxForm tabelleForm = sxMask.getTabelleForm();
+
+ StringBuffer data = new StringBuffer();
+ data.append(SxDefaults.getPropertyValue("SxTitle"));
+ data.append("\n\n");
+ data.append(((JLabel) maskeForm.getComp("M_headline")).getText());
+ data.append("\n");
+ data.append(((JLabel) tabelleForm.getComp("T_stand")).getText());
+ data.append("\n\n");
+ data.append(
+ ((JLabel) tabelleForm.getComp("L_parameter")).getText());
+ data.append("\n");
+ data.append(maskeForm.getParamListText());
+ data.append("\n\n");
+ data.append(this.getText());
+
+ data_bytes = data.toString().getBytes();
+
+ fos = new FileOutputStream(out_file);
+
+ fos.write(data_bytes, 0, data_bytes.length);
+
+ fos.close();
+
+ } catch (FileNotFoundException e) {
+ err_msg = e.toString();
+ System.err.println(e);
+ } catch (SecurityException e) {
+ err_msg = e.toString();
+ System.err.println(e);
+ } catch (IOException e) {
+ err_msg = e.toString();
+ System.err.println(e);
+ }
+
+ if (err_msg != null)
+ JOptionPane.showMessageDialog(
+ this,
+ err_msg,
+ "Fehler beim Sichern",
+ JOptionPane.ERROR_MESSAGE);
+
+ }
+ */
+ public void printTable(SxMask mask) {
+ this.sxMask = mask;
+ PrinterJob pj = PrinterJob.getPrinterJob();
+ //PageFormat pageFormat=null;
+ if (defaultFormat == null) {
+ defaultFormat = pj.defaultPage();
+ defaultFormat.setOrientation(java.awt.print.PageFormat.LANDSCAPE);
+
+ }
+ // Dialog zur Auswahl des Papierformats
+ PageFormat pageFormat = pj.pageDialog(defaultFormat);
+
+ if (pageFormat.equals(defaultFormat))
+ return;
+
+ // A4 festvorgeben.
+ // Papiergroesse DIN A4, Rand: O + U: 1/2 Inch, L + R: 1/2 Inch
+ // alle angaben in 1/72 Inch
+
+ Paper a4 = new Paper();
+ a4.setSize(21 / 2.54 * 72, 29.7 / 2.54 * 72);
+ a4.setImageableArea(
+ 36,
+ 36,
+ (21 / 2.54 * 72) - 72,
+ (29.7 / 2.54 * 72) - 72);
+
+ pageFormat.setPaper(a4);
+ defaultFormat = pageFormat;
+ // pageFormat.setOrientation (PageFormat.LANDSCAPE);
+
+ // System.err.println ("p_width: " + pageFormat.getImageableWidth());
+ // System.err.println ("p_height: " + pageFormat.getImageableHeight());
+
+ //MB printing
+ //tmp_druck=null;
+ //ggfs_nurMarkierterBereich(pj,pageFormat);
+
+ //if (tmp_druck==null)
+ pj.setPrintable(this, pageFormat);
+ //else
+ // pj.setPrintable(tmp_drucktab, pageFormat);
+
+ if (!pj.printDialog())
+ return;
+
+ logo = mask.getLogo();
+
+ statusField = mask.getStatusField();
+ // Hochschulname
+ try {
+ hsName = (String) SxDefaults.getPropertyValue("SxTitle");
+ } catch (Exception ex) {
+ JOptionPane.showMessageDialog(
+ this,
+ ex.toString(),
+ "Fehler",
+ JOptionPane.ERROR_MESSAGE);
+ }
+
+ try {
+ logo.start();
+ pj.print();
+ } catch (Exception PrintException) {
+ System.err.println(PrintException);
+ PrintException.printStackTrace();
+ }
+ //alter Stand wiederherstellen
+ /*if (tmp_druck!=null)
+ {
+ this.remove(tmp_druck);
+ this.add(tableAggregate,"Center");
+ this.validate();
+ }*/
+ statusField.setText("Drucken beendet");
+ logo.stop();
+
+ }
+
+ private void ggfs_nurMarkierterBereich(
+ PrinterJob pj,
+ PageFormat pageFormat) {
+ //noch nicht aktiv
+ int i;
+
+ if (table.getSelectedRowCount() > 0) {
+
+ DefaultTableModel tmodel = new DefaultTableModel();
+ DefaultTableModel rmodel = new DefaultTableModel();
+ //model=(DefaultTableModel) this.table.getModel();
+ //model= this.table.getModel();
+ //TableColumnModel mycolumnModel = this.table.getColumnModel();
+ JTable dummy = new JTable(tmodel); //,mycolumnModel);
+ JTable dummyr = new JTable(rmodel); //,mycolumnModel);
+ int spaltenzahlr = this.rowheaderTable.getColumnCount();
+ for (i = 0; i < spaltenzahlr; i++)
+ rmodel.addColumn(this.rowheaderTable.getColumnName(i));
+
+ int i2 = 0;
+ int zeilenzahl = this.table.getRowCount();
+ int spaltenzahl = this.table.getColumnCount();
+ for (i = 0; i < spaltenzahl; i++)
+ tmodel.addColumn(this.table.getColumnName(i));
+ //Object[] zeile=new Object[spaltenzahl];
+ Vector zeile = new Vector();
+ Vector rzeile = new Vector();
+ Object wert = new Object();
+ for (i = 0; i < zeilenzahl; i++) {
+ if (this.table.isRowSelected(i)) {
+ //model.addRow(zeile);
+ for (i2 = 0; i2 < spaltenzahlr; i2++) {
+ wert = this.rowheaderTable.getValueAt(i, i2);
+ rzeile.addElement(wert);
+ }
+ for (int i3 = 0; i3 < spaltenzahl; i3++) {
+
+ wert = this.table.getValueAt(i, i3);
+ zeile.addElement(wert);
+ //model.setValueAt(wert, i,i3);
+ //if (zeile[i3]==null) zeile[i3]="";
+ }
+ rmodel.addRow(rzeile);
+ tmodel.addRow(zeile);
+
+ }
+ }
+ /*tmp_drucktab=new SxTable();
+ tmp_drucktab=this;
+ tmp_drucktab.remove(tableAggregate);
+ tmp_drucktab.table=dummy;
+ tmp_drucktab.rowheader=dummyr;
+ //tmp_druck=new JScrollPane(dummy);
+ tmp_druck=new JScrollPane(tableAggregate);
+ //tmp_druck.setCorner (JScrollPane.UPPER_LEFT_CORNER, dummyr.getTableHeader());
+ //tmp_druck.setRowHeaderView (dummyr);
+ */
+ table = dummy;
+ rowheaderTable = dummyr;
+ table.addNotify();
+ rowheaderTable.addNotify();
+
+ this.remove(tableScrollPane);
+ this.add(tmp_druck, "Center");
+ this.validate();
+ this.table.repaint();
+ this.rowheaderTable.repaint();
+ this.repaint();
+
+ //tmp_druckt.add(aktuell,"Center");
+ //tmp_druck.add(tableAggregate,"Center");
+ //tmp_druck.validate();
+
+ }
+ if (table.getSelectedColumnCount() > 0) {
+ TableColumnModel mycolumnModel = this.table.getColumnModel();
+ TableColumn aCol = new TableColumn();
+ int i2 = 0;
+ int spaltenzahl = this.table.getColumnCount();
+ for (i = 0; i < spaltenzahl; i++) {
+ {
+ if (!this.table.isColumnSelected(i - i2)) {
+
+ aCol = mycolumnModel.getColumn(i - i2);
+ i2++;
+ this.table.removeColumn(aCol);
+ }
+ }
+ }
+
+ }
+ this.table.clearSelection();
+ //this.table.revalidate();
+ this.table.repaint();
+ //this.rowheader.revalidate();
+ this.rowheaderTable.repaint();
+
+ }
+
+ public int print(Graphics g, PageFormat pageFormat, int pageIndex)
+ throws PrinterException {
+ /**
+ * r.b. Hinweis: Parameter der Druckfunktion 'print':
+ * - Graphics = Graphikkontext (casten -> Graphics2D)
+ * - PageFormat = Seitenformat
+ * - int pageIndex = Seitenindex
+ * Allgemeine Vorgehensweise beim Drucken:
+ * - Seiten groesse bestimmen:
+ * (pageFormat.getImageableHeight()
+ * (pageFormat.getImageableWidth()
+ * - Skalierungsfaktor bestimmen (optional)
+ * - mit 'translate' Anfangspunkt jeder Druckoperation setzen
+ * - (optional) mit 'setClip' begrenzendes Rechteck setzen
+ */
+ Graphics2D g2 = (Graphics2D) g;
+
+ g2.setColor(Color.black);
+
+ int fontHeight = g2.getFontMetrics().getHeight();
+ int fontDesent = g2.getFontMetrics().getDescent();
+
+ //leave room for page number
+ double pageHeight =
+ pageFormat.getImageableHeight() - fontHeight - fontDesent;
+ double pageWidth = pageFormat.getImageableWidth();
+ double rowheaderWidth =
+ (double) rowheaderTable.getColumnModel().getTotalColumnWidth();
+ double tableWidth =
+ (double) table.getColumnModel().getTotalColumnWidth();
+
+ double headerHeight=30+sxMask.getParameterPanel().lblParams.getHeight();
+ double paramWidth = sxMask.getParameterPanel().lblEingabeparam.getWidth() + 10;
+ double paramAreaWidth = sxMask.getParameterPanel().lblParams.getWidth();
+
+ double scale = 1; //für die Tabelle etc
+ double scale2 = 1; //speziell für Parameterbereich MB
+
+ if (rowheaderWidth + tableWidth >= pageWidth) {
+ scale = pageWidth / (rowheaderWidth + tableWidth);
+ }
+
+ if (paramWidth + paramAreaWidth >= pageWidth)
+ scale2 = pageWidth / (paramWidth + paramAreaWidth);
+
+ paramWidth = paramWidth * scale2;
+
+ double scaledTableHeaderHeight = table.getTableHeader().getHeight() * scale;
+ double scaledRowheaderWidth = rowheaderWidth * scale;
+ double scaledTableWidth = tableWidth * scale;
+
+ double oneRowHeight = (table.getRowHeight()) * scale;
+ int numRowsOnAPage =
+ (int) ((pageHeight - headerHeight-scaledTableHeaderHeight) / oneRowHeight);
+ double pageHeightForTable = oneRowHeight * numRowsOnAPage;
+ int totalNumPages =
+ (int) Math.ceil(((double) table.getRowCount()) / numRowsOnAPage);
+
+ // System.err.println ("scale: " + scale);
+ // System.err.println ("numRowsOnAPage: " + numRowsOnAPage);
+ // System.err.println ("pageHeightForTable: " + pageHeightForTable);
+
+ if (pageIndex >= totalNumPages) {
+ return NO_SUCH_PAGE;
+ }
+
+ String msg = "Drucke Seite " + (pageIndex + 1);
+ statusField.setText(msg);
+
+ // scale fontsize
+ Font font = g2.getFont();
+ Font pr_font =
+ new Font(
+ font.getFontName(),
+ font.getStyle(),
+ (int) (font.getSize() * scale));
+ Font b_font =
+ new Font(
+ font.getFontName(),
+ Font.BOLD,
+ (int) (font.getSize() * scale));
+ Font h_font = sxMask.getParameterPanel().lblAbfragename.getFont();
+ font = sxMask.getParameterPanel().lblStand.getFont();
+ Font d_font =
+ new Font(
+ font.getFontName(),
+ font.getStyle(),
+ (int) (font.getSize() * scale));
+
+ g2.setFont(pr_font);
+
+
+
+ g2.translate(pageFormat.getImageableX(), pageFormat.getImageableY());
+
+ //Bottom
+ printBottomLine(
+ pageIndex,
+ g2,
+ fontHeight,
+ pageHeight,
+ pageWidth,
+ b_font,
+ d_font);
+
+ g2.setFont(pr_font);
+
+ g2.translate(0f, headerHeight+scaledTableHeaderHeight );
+ g2.translate(0f, -pageIndex * pageHeightForTable);
+
+ //If this piece of the rowheader is smaller than the size available,
+ //clip to the appropriate bounds.
+
+ if (fixedColumns > 0) {
+ if (pageIndex + 1 == totalNumPages) {
+ int lastRowPrinted = numRowsOnAPage * pageIndex;
+ int numRowsLeft = table.getRowCount() - lastRowPrinted;
+ g2.setClip(
+ 0,
+ (int) (pageHeightForTable * pageIndex),
+ (int) Math.ceil(scaledRowheaderWidth),
+ (int) Math.ceil(pageHeightForTable));
+ }
+ //else clip to the entire area available.
+ else {
+ g2.setClip(
+ 0,
+ (int) (pageHeightForTable * pageIndex),
+ (int) Math.ceil(scaledRowheaderWidth),
+ (int) Math.ceil(pageHeightForTable));
+ }
+ }
+
+ g2.scale(scale, scale);
+
+ if (fixedColumns > 0) {
+ try {
+ rowheaderTable.print(g2);
+ } catch (IllegalArgumentException h_ex) {
+ System.err.println(h_ex);
+ }
+ }
+
+ g2.scale(1 / scale, 1 / scale);
+ g2.translate(scaledRowheaderWidth, 0f);
+
+ //If this piece of the table is smaller than the size available,
+ //clip to the appropriate bounds.
+ if (pageIndex + 1 == totalNumPages) {
+ int lastRowPrinted = numRowsOnAPage * pageIndex;
+ int numRowsLeft = table.getRowCount() - lastRowPrinted;
+ g2.setClip(
+ 0,
+ (int) (pageHeightForTable * pageIndex),
+ (int) Math.ceil(scaledTableWidth),
+ (int) Math.ceil(pageHeightForTable));
+ }
+ //else clip to the entire area available.
+ else {
+ g2.setClip(
+ 0,
+ (int) (pageHeightForTable * pageIndex),
+ (int) Math.ceil(scaledTableWidth),
+ (int) Math.ceil(pageHeightForTable));
+ }
+
+ g2.scale(scale, scale);
+
+ try {
+ table.print(g2);
+ } catch (IllegalArgumentException t_ex) {
+ System.err.println(t_ex);
+ }
+
+ g2.scale(1 / scale, 1 / scale);
+ g2.translate(
+ -scaledRowheaderWidth,
+ pageIndex * pageHeightForTable - scaledTableHeaderHeight);
+ g2.setClip(
+ 0,
+ 0,
+ (int) Math.ceil(scaledRowheaderWidth + scaledTableWidth),
+ (int) Math.ceil(scaledTableHeaderHeight));
+ g2.scale(scale, scale);
+
+ rowheaderTable.getTableHeader().print(g2); //print header at top
+
+ g2.scale(1 / scale, 1 / scale);
+ g2.translate(scaledRowheaderWidth, 0f);
+ g2.scale(scale, scale);
+
+ table.getTableHeader().print(g2); //print header at top
+
+ // HEADER ----------------------------------------------
+
+ g2.scale(1 / scale, 1 / scale);
+ g2.translate(-scaledRowheaderWidth, -(headerHeight+2));
+ g2.setClip(0, 0, (int) Math.ceil(paramWidth), (int) headerHeight);
+ g2.scale(scale2, scale2);
+
+ sxMask.getParameterPanel().lblEingabeparam.print(g2);
+
+ // Parameter drucken (scale2 ist speziell für die Paramterzeile)
+
+ g2.scale(1 / scale2, 1 / scale2);
+ g2.translate(paramWidth, 0);
+ g2.setClip(
+ 0,
+ 0,
+ (int) Math.ceil(pageWidth - paramWidth),
+ (int) headerHeight);
+ g2.scale(scale2, scale2);
+
+ sxMask.getParameterPanel().lblParams.print(g2); //print parameter at top
+
+ g2.setFont(h_font);
+ int laengeUberschriftuHSname =
+ g2.getFontMetrics().stringWidth(sxMask.getParameterPanel().lblAbfragename.getText() + hsName + 10);
+ while (laengeUberschriftuHSname > pageWidth) {
+ h_font = h_font.deriveFont((float) (h_font.getSize() - 1));
+ g2.setFont(h_font);
+ laengeUberschriftuHSname =
+ g2.getFontMetrics().stringWidth(
+ sxMask.getParameterPanel().lblAbfragename.getText() + hsName + 10);
+ }
+
+ // Ueberschriften drucken
+
+ //g2.scale(1/scale,1/scale);
+ g2.translate(-paramWidth, -30);
+ g2.setClip(
+ 0,
+ 0,
+ (int) Math.ceil(scaledRowheaderWidth + scaledTableWidth),
+ (int) Math.ceil(scaledTableHeaderHeight));
+ //g2.scale(scale,scale);
+
+ g2.setFont(h_font);
+ //Font merk=sxMask.getParameterPanel().lblAbfragename.getFont();
+ //sxMask.getParameterPanel().lblAbfragename.setFont(h_font);
+ //sxMask.getParameterPanel().lblAbfragename.print(g2);//print headline at top
+ //sxMask.getParameterPanel().lblAbfragename.setFont(merk);
+ g2.drawString(sxMask.getParameterPanel().lblAbfragename.getText(), 0, g2.getFontMetrics().getHeight());
+ // Hochschulname
+ int hsNameWidth = g2.getFontMetrics().stringWidth(hsName);
+ //hsNameWidth = (int) (hsNameWidth * scale2);
+
+ //g2.scale(1/scale,1/scale);
+ g2.translate(pageWidth - hsNameWidth, 0);
+ g2.setClip(
+ 0,
+ 0,
+ (int) Math.ceil(pageWidth - hsNameWidth),
+ (int) Math.ceil(scaledTableHeaderHeight));
+ //g2.scale(scale,scale);
+
+ g2.setFont(h_font);
+ g2.drawString(hsName, 0, g2.getFontMetrics().getHeight());
+
+ g2.translate(-1*(pageWidth-hsNameWidth),0);
+
+ return Printable.PAGE_EXISTS;
+
+ }
+
+ private void printBottomLine(
+ int pageIndex,
+ Graphics2D g2,
+ int fontHeight,
+ double pageHeight,
+ double pageWidth,
+ Font b_font,
+ Font d_font) {
+ int footWidth = g2.getFontMetrics().stringWidth("Seite #");
+ g2.setFont(b_font);
+ g2.drawString("SuperX", (int) 0f, (int) (pageHeight + fontHeight));
+
+ g2.setFont(d_font);
+ g2.drawString(
+ "Seite " + (pageIndex + 1),
+ (int) (pageWidth / 2 - footWidth / 2),
+ (int) (pageHeight + fontHeight));
+
+ double dateWidthOnPage =
+ (double) g2.getFontMetrics().stringWidth(sxMask.getParameterPanel().lblStand.getText()) + 2;
+ g2.drawString(
+ sxMask.getParameterPanel().lblStand.getText(),
+ (int) (pageWidth - dateWidthOnPage),
+ (int) (pageHeight + fontHeight));
+ }
+
+ private JScrollPane createTable() {
+ sorter = new SxTableSorter();
+
+ // Create the table
+ table = new JTable(sorter);
+
+ table.setFont(new Font("SansSerif", Font.PLAIN, 12));
+ table.setBackground(Color.white);
+ table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+ table.setRowHeight((int) (table.getRowHeight() * 1.25));
+
+ // Add customized Actions
+ addActionsToTable(table);
+
+ // Install a mouse listener in the TableHeader as the sorter UI.
+ addMouseListenerToHeaderInTable(table);
+
+ addMouseListenerInTable(table); // for row selection
+
+ // Install a Renderer in the Table for numbers
+ addRendererInTable(table);
+ JScrollPane scrollpane = new JScrollPane(table);
+ return scrollpane;
+ }
+
+ JTable getTable() {
+ return table;
+ }
+
+ private void removeHeaderMouseListener() {
+ if (mouseToHeader != null) {
+ JTableHeader th = table.getTableHeader();
+ th.removeMouseListener(mouseToHeader);
+ }
+ }
+
+ private void removeTableMouseListener() {
+ if (mouseInTable != null) {
+ table.removeMouseListener(mouseInTable);
+ }
+ }
+
+ protected void setTableProperties(JTable jtable) {
+ if (jtable == null)
+ return;
+ jtable.setColumnSelectionAllowed(false);
+ jtable.setRowSelectionAllowed(true);
+ if (jtable.getRowCount() <= 0)
+ return;
+ int nr_col = jtable.getColumnCount();
+ if (nr_col <= 0)
+ return;
+
+ SxTableModel model = (SxTableModel) jtable.getModel();
+ TableColumnModel columnModel = jtable.getColumnModel();
+ TableColumn tableColumn;
+ FontMetrics metrics = jtable.getFontMetrics(jtable.getFont());
+ int advance = metrics.charWidth('m');
+ int width = -1;
+ int pref_width = -1;
+ int headerlines = 1;
+ Object value;
+ max_headerlines = 1;
+ for (int i = 0; i < nr_col; i++) {
+ tableColumn = columnModel.getColumn(i);
+
+ SxHeaderRenderer headerRenderer = new SxHeaderRenderer();
+ headerRenderer.setHeaderFont(HEADERFONT);
+ headerRenderer.setTextLines((String) tableColumn.getHeaderValue());
+ tableColumn.setHeaderRenderer(headerRenderer);
+ if (i >= fixedColumns)
+ if ((headerlines = headerRenderer.getNumLines())
+ > max_headerlines)
+ max_headerlines = headerlines;
+ if (V_width.isEmpty())
+ width = model.getColumnSize(i);
+ else {
+ width =
+ java
+ .lang
+ .Integer
+ .valueOf(V_width.elementAt(i).toString())
+ .intValue();
+ //System.out.println("Spalte: "+i+" Breite: "+width);
+
+ }
+ if (width > 0) {
+ pref_width = (int) (width * (int) (advance * 7 / 10));
+ if (pref_width > MAX_COLUMN_WIDTH)
+ pref_width = MAX_COLUMN_WIDTH;
+ tableColumn.setPreferredWidth(pref_width);
+ //System.err.println ("i=" + i + ", pref_width=" + pref_width);
+ } else
+ //Wint sonst werden die Leerspalten zu breit??
+ pref_width = 1 * (int) (advance * 3 / 10);
+ value = model.getObjectAt(0, i);
+ if (value instanceof java.lang.Integer) {
+ tableColumn.setMinWidth(30);
+ SxField numField = new SxField(SxField.TYPE_INTEGER, 11);
+ numField.setHorizontalAlignment(JTextField.RIGHT);
+ numField.setMargin(new Insets(0, 2, 0, 2));
+ numField.setJTable(jtable);
+ DefaultCellEditor numEditor = new DefaultCellEditor(numField);
+ numEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.lang.Integer.class, numEditor);
+ //System.out.println("integer");
+ continue;
+ }
+ if (value instanceof java.lang.Short) {
+ tableColumn.setMinWidth(30);
+ SxField numField = new SxField(SxField.TYPE_INTEGER, 6);
+ numField.setHorizontalAlignment(JTextField.RIGHT);
+ numField.setMargin(new Insets(0, 2, 0, 2));
+ numField.setJTable(jtable);
+ DefaultCellEditor numEditor = new DefaultCellEditor(numField);
+ numEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.lang.Short.class, numEditor);
+ //System.out.println("short");
+ continue;
+ }
+ if (value instanceof java.lang.Double) {
+ tableColumn.setMinWidth(50);
+ tableColumn.setMaxWidth(MAX_COLUMN_WIDTH);
+ SxField numField = new SxField(SxField.TYPE_DOUBLE, 20);
+ numField.setHorizontalAlignment(JTextField.RIGHT);
+ numField.setMargin(new Insets(0, 2, 0, 2));
+ numField.setJTable(jtable);
+ DefaultCellEditor numEditor = new DefaultCellEditor(numField);
+ numEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.lang.Double.class, numEditor);
+ //System.out.println("double");
+ continue;
+ }
+ if (value instanceof java.math.BigDecimal) {
+ tableColumn.setMinWidth(50);
+ tableColumn.setMaxWidth(MAX_COLUMN_WIDTH);
+ SxField numField = new SxField(SxField.TYPE_DOUBLE, 20);
+ numField.setHorizontalAlignment(JTextField.RIGHT);
+ numField.setMargin(new Insets(0, 2, 0, 2));
+ numField.setJTable(jtable);
+ DefaultCellEditor numEditor = new DefaultCellEditor(numField);
+ numEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.math.BigDecimal.class, numEditor);
+ DefaultTableCellRenderer decimalRenderer =
+ new DefaultTableCellRenderer();
+ decimalRenderer.setHorizontalAlignment(JTextField.RIGHT);
+ jtable.setDefaultRenderer(
+ java.math.BigDecimal.class,
+ decimalRenderer);
+ //tableView.setDefaultRenderer(java.lang.Double.class, decimalRenderer);
+ //tableView.setDefaultRenderer(java.lang.Float.class, decimalRenderer);
+ //tableView.setDefaultRenderer(java.lang.Object.class, decimalRenderer);
+ //System.out.println("BigDecimal");
+ continue;
+ }
+ if (value instanceof java.lang.Float) {
+ tableColumn.setMinWidth(50);
+ tableColumn.setMaxWidth(MAX_COLUMN_WIDTH);
+ SxField numField = new SxField(SxField.TYPE_DOUBLE, 20);
+ numField.setHorizontalAlignment(JTextField.RIGHT);
+ numField.setMargin(new Insets(0, 2, 0, 2));
+ numField.setJTable(jtable);
+ DefaultCellEditor numEditor = new DefaultCellEditor(numField);
+ numEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.lang.Float.class, numEditor);
+ //System.out.println("Float");
+ continue;
+ }
+ if (value instanceof java.lang.Number) {
+ tableColumn.setMinWidth(50);
+ tableColumn.setMaxWidth(MAX_COLUMN_WIDTH);
+ SxField numField = new SxField(SxField.TYPE_DOUBLE, 20);
+ numField.setHorizontalAlignment(JTextField.RIGHT);
+ numField.setMargin(new Insets(0, 2, 0, 2));
+ numField.setJTable(jtable);
+ DefaultCellEditor numEditor = new DefaultCellEditor(numField);
+ numEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.lang.Number.class, numEditor);
+ //System.out.println("Number");
+ continue;
+ }
+ if (value instanceof java.sql.Timestamp) {
+ SxField timeField = new SxField(SxField.TYPE_STRING, 22);
+ timeField.setMargin(new Insets(0, 2, 0, 2));
+ timeField.setJTable(jtable);
+ DefaultCellEditor timeEditor = new DefaultCellEditor(timeField);
+ timeEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.sql.Timestamp.class, timeEditor);
+ //System.out.println("Timestamp");
+ continue;
+ }
+ if (value instanceof java.sql.Date) {
+ tableColumn.setMinWidth(70);
+ tableColumn.setMaxWidth(100);
+ SxField dateField = new SxField(SxField.TYPE_DATE, 10);
+ dateField.setHorizontalAlignment(JTextField.RIGHT);
+ dateField.setMargin(new Insets(0, 2, 0, 2));
+ dateField.setJTable(jtable);
+ DefaultCellEditor dateEditor = new DefaultCellEditor(dateField);
+ dateEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.sql.Date.class, dateEditor);
+ //System.out.println("Date");
+ continue;
+ }
+ if (value instanceof java.lang.String) {
+ SxField textField = new SxField();
+ textField.setMargin(new Insets(0, 2, 0, 2));
+ textField.setJTable(jtable);
+ textField.setHorizontalAlignment(JTextField.RIGHT);
+ DefaultCellEditor textEditor = new DefaultCellEditor(textField);
+ textEditor.addCellEditorListener(new ChangeEditorListener());
+ jtable.setDefaultEditor(java.lang.String.class, textEditor);
+ //System.out.println("String");
+ continue;
+ }
+ } //Ende for-Schleife
+ }
+
+ private void removeFixedColumns(JTable jtable, int col) {
+ // Remove Column for RowHeader
+ SxTableModel model = (SxTableModel) jtable.getModel();
+ TableColumnModel columnModel = jtable.getColumnModel();
+ jtable.removeColumn(columnModel.getColumn(col));
+ }
+
+ private void setHeaderModel(Vector rows) {
+ final Vector V_rows = rows;
+ final int numberOfRows = V_rows.size();
+ final int[] indexes = sorter.getIndexes();
+
+ if (rowheaderTable == null)
+ return;
+
+ TableModel headerModel = new AbstractTableModel() {
+ public int getColumnCount() {
+ return fixedColumns;
+ }
+ public String getColumnName(int col) {
+ return (String) V_header.elementAt(col);
+ }
+ public int getRowCount() {
+ return numberOfRows;
+ }
+ public Object getValueAt(int row, int col) {
+ Vector n_row = (Vector) V_rows.elementAt(indexes[row]);
+ Object obj = n_row.elementAt(col);
+ //System.out.println(n_row.toString() + " "+ col);
+ //Wint 4.2001 eingefügt, da kompletter Absturz,
+ //wenn bei Rückgabe einer Leerzeile als erstes null kommt
+ if (obj != null) {
+ if (obj.toString().length() == 0)
+ return (" ");
+ } else
+ return (" ");
+ return obj;
+ }
+ };
+
+ TableColumnModel header_columnModel = rowheaderTable.getColumnModel();
+ TableColumn header_tableColumn;
+ int width = 0, header_width = 0;
+ int col = rowheaderTable.getColumnCount();
+ int[] arr_width = new int[col];
+
+ for (int i = 0; i < col; i++) {
+ header_tableColumn = header_columnModel.getColumn(i);
+ arr_width[i] = header_tableColumn.getPreferredWidth();
+ header_width += arr_width[i];
+ }
+
+ rowheaderTable.setModel(headerModel);
+
+ header_columnModel = rowheaderTable.getColumnModel();
+
+ for (int i = 0; i < arr_width.length; i++) {
+ header_tableColumn = header_columnModel.getColumn(i);
+ header_tableColumn.setPreferredWidth(arr_width[i]);
+ header_tableColumn.setWidth(arr_width[i]);
+
+ SxHeaderRenderer headerRenderer = new SxHeaderRenderer();
+ headerRenderer.setHeaderFont(new Font("SansSerif", Font.BOLD, 12));
+ headerRenderer.setTextLines(
+ (String) header_tableColumn.getHeaderValue());
+ header_tableColumn.setHeaderRenderer(headerRenderer);
+ }
+
+ Dimension dim = rowheaderTable.getPreferredSize();
+ dim.width = header_columnModel.getTotalColumnWidth();
+ rowheaderTable.setPreferredScrollableViewportSize(dim);
+ }
+
+ private void setRowHeader(Vector rows) {
+ rowheaderTable = new JTable();
+ rowheaderTable.setFont(new Font("SansSerif", Font.PLAIN, 12));
+ setHeaderModel(rows);
+
+ rowheaderTable.setRowHeight(
+ (int) (rowheaderTable.getRowHeight() * 1.25));
+ rowheaderTable.getTableHeader().setReorderingAllowed(false);
+
+ addActionsToTable(rowheaderTable);
+ addMouseListenerToHeaderInTable(rowheaderTable);
+ addResizeListenerToHeaderInTable(rowheaderTable);
+ addMouseListenerInTable(rowheaderTable);
+
+ TableColumnModel header_columnModel = rowheaderTable.getColumnModel();
+ TableColumn header_tableColumn;
+ TableColumnModel table_columnModel = table.getColumnModel();
+ TableColumn table_tableColumn;
+ int width, header_width = 0;
+ int headerlines = 1;
+ boolean adjustheader = false;
+ Dimension header_dim = null;
+
+ for (int i = 0; i < fixedColumns; i++) {
+ table_tableColumn = table_columnModel.getColumn(i);
+ header_tableColumn = header_columnModel.getColumn(i);
+
+ width = table_tableColumn.getPreferredWidth();
+ header_tableColumn.setPreferredWidth(width);
+ header_tableColumn.setWidth(width);
+ header_width += width;
+
+ SxHeaderRenderer headerRenderer = new SxHeaderRenderer();
+ headerRenderer.setHeaderFont(new Font("SansSerif", Font.BOLD, 12));
+ headerRenderer.setTextLines(
+ (String) header_tableColumn.getHeaderValue());
+ header_tableColumn.setHeaderRenderer(headerRenderer);
+ headerlines = headerRenderer.getNumLines();
+ if (headerlines > max_headerlines) {
+ max_headerlines = headerlines;
+ header_dim = headerRenderer.getPreferredSize();
+ adjustheader = true;
+ }
+ }
+
+ if (adjustheader) {
+ SxHeaderRenderer headerRenderer;
+ for (int i = fixedColumns;
+ i < table_columnModel.getColumnCount();
+ i++) {
+ table_tableColumn = table_columnModel.getColumn(i);
+ headerRenderer =
+ (SxHeaderRenderer) table_tableColumn.getHeaderRenderer();
+ headerRenderer.setPreferredSize(header_dim);
+ }
+ }
+
+ Dimension dim = rowheaderTable.getPreferredSize();
+ dim.width = header_width;
+ rowheaderTable.setPreferredScrollableViewportSize(dim);
+
+ tableScrollPane.setCorner(
+ JScrollPane.UPPER_LEFT_CORNER,
+ rowheaderTable.getTableHeader());
+ tableScrollPane.setRowHeaderView(rowheaderTable);
+ }
+
+ private void addResizeListenerToHeaderInTable(JTable aTable) {
+ final JTable jtable = aTable;
+
+ MouseMotionAdapter columnListener = new MouseMotionAdapter() {
+ public void mouseDragged(java.awt.event.MouseEvent e) {
+ int cursor_type = jtable.getTableHeader().getCursor().getType();
+ if (cursor_type != Cursor.E_RESIZE_CURSOR)
+ return;
+
+ int width = e.getX();
+ if (width < 10)
+ return;
+
+ TableColumnModel columnModel = jtable.getColumnModel();
+ TableColumn tableColumn;
+ int viewColumn = columnModel.getColumnIndexAtX(width);
+ int column = jtable.convertColumnIndexToModel(viewColumn);
+ tableColumn = columnModel.getColumn(column);
+ tableColumn.setPreferredWidth(width);
+
+ Dimension dim = jtable.getPreferredSize();
+ dim.width = columnModel.getTotalColumnWidth();
+ jtable.setPreferredScrollableViewportSize(dim);
+ jtable.revalidate();
+ }
+ };
+
+ jtable.getTableHeader().addMouseMotionListener(columnListener);
+ }
+
+ private void addRendererInTable(JTable table) {
+ final JTable jtable = table;
+
+ // set ToolTipManager
+ // ToolTipManager tooltip = ToolTipManager.sharedInstance();
+ // tooltip.setDismissDelay(500);
+
+ DefaultTableCellRenderer numRenderer = new DefaultTableCellRenderer();
+ numRenderer.setHorizontalAlignment(JLabel.RIGHT);
+ jtable.setDefaultRenderer(java.lang.Number.class, numRenderer);
+
+ DefaultTableCellRenderer intRenderer = new DefaultTableCellRenderer();
+ intRenderer.setHorizontalAlignment(JLabel.RIGHT);
+ jtable.setDefaultRenderer(java.lang.Integer.class, intRenderer);
+ jtable.setDefaultRenderer(java.lang.Short.class, intRenderer);
+ jtable.setDefaultRenderer(java.math.BigInteger.class, intRenderer);
+
+ DefaultTableCellRenderer decimalRenderer =
+ new DefaultTableCellRenderer();
+ decimalRenderer.setHorizontalAlignment(JLabel.RIGHT);
+ jtable.setDefaultRenderer(java.math.BigDecimal.class, decimalRenderer);
+ jtable.setDefaultRenderer(java.lang.Double.class, decimalRenderer);
+ jtable.setDefaultRenderer(java.lang.Float.class, decimalRenderer);
+ jtable.setDefaultRenderer(java.lang.Long.class, decimalRenderer);
+ jtable.setDefaultRenderer(java.lang.Math.class, decimalRenderer);
+ //Bisher gibt es bei Postgres und Dezimalstellen Probleme mit der Darstellung.
+ //Er erkennt hier nur "Object", nicht die anderen Typen.
+
+ jtable.setDefaultRenderer(java.lang.Object.class, decimalRenderer);
+
+ DefaultTableCellRenderer stringRenderer =
+ new DefaultTableCellRenderer();
+ stringRenderer.setHorizontalAlignment(JLabel.LEFT);
+ jtable.setDefaultRenderer(java.lang.String.class, stringRenderer);
+
+ DefaultTableCellRenderer dateRenderer = new DefaultTableCellRenderer();
+ dateRenderer.setHorizontalAlignment(JLabel.RIGHT);
+ jtable.setDefaultRenderer(java.sql.Date.class, dateRenderer);
+
+ DefaultTableCellRenderer timeRenderer = new DefaultTableCellRenderer();
+ timeRenderer.setHorizontalAlignment(JLabel.RIGHT);
+ jtable.setDefaultRenderer(java.sql.Timestamp.class, timeRenderer);
+ }
+
+ private void addMouseListenerToHeaderInTable(JTable aTable) {
+ final JTable jtable = aTable;
+
+ MouseAdapter listMouseListenerToHeader = new MouseAdapter() {
+ int columnSelected[];
+ int columnCount = -1;
+
+ public void mousePressed(MouseEvent e) {
+ int button1 = e.getModifiers() & InputEvent.BUTTON1_MASK;
+ //rechte Maustaste
+ int button3 = e.getModifiers() & InputEvent.BUTTON3_MASK;
+
+ int cursor_type = jtable.getTableHeader().getCursor().getType();
+ if (cursor_type == Cursor.E_RESIZE_CURSOR)
+ return;
+
+ final TableColumnModel columnModel = jtable.getColumnModel();
+
+ int viewColumn = columnModel.getColumnIndexAtX(e.getX());
+
+ final int column = jtable.convertColumnIndexToModel(viewColumn);
+ final TableColumn tcolumn = columnModel.getColumn(viewColumn);
+ if (button3 != 0) //rechte Maustaste sortieren
+ if (e.getClickCount() == 1 && column != -1) {
+ JPopupMenu menu = new JPopupMenu();
+ JMenuItem sort1 =
+ new JMenuItem("Sortieren aufsteigend");
+ sort1.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ sortTable(jtable, column, true);
+ }
+ });
+ JMenuItem sort2 = new JMenuItem("Sortieren absteigend");
+ sort2.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ sortTable(jtable, column, false);
+ }
+ });
+
+ JMenuItem remove =
+ new JMenuItem(
+ "Spalte löschen",
+ MBStandardIcons.getDelete());
+ remove.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ columnModel.removeColumn(tcolumn);
+ }
+ });
+
+ JMenuItem restore =
+ new JMenuItem("Alle Änderungen rückgängig");
+ restore.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent ae) {
+ restore();
+ }
+ });
+ menu.add(sort1);
+ menu.add(sort2);
+ menu.add(remove);
+ menu.add(restore);
+ menu.show(e.getComponent(), e.getX(), e.getY());
+
+ return;
+ }
+
+ if (button1 != 0 && jtable.equals(table))
+ if (e.getClickCount() == 1 && column != -1) {
+ //MB selection erstmal vorhandene Selection löschen
+ rowheaderTable.clearSelection();
+
+ jtable.setColumnSelectionAllowed(true);
+ jtable.setRowSelectionAllowed(false);
+
+ int ctrlPressed =
+ e.getModifiers() & InputEvent.CTRL_MASK;
+ if (ctrlPressed != 0) {
+ //erste Markierung auch mit CTRL -> alte Markierung löschen
+ if (table.getSelectedColumnCount() == 0)
+ table.clearSelection();
+
+ jtable.addColumnSelectionInterval(
+ viewColumn,
+ viewColumn);
+ } else {
+ //MB selection - sonst sind evtl. noch rows selektiert auch wenn nicht blau unterlegt
+ table.clearSelection();
+ jtable.setColumnSelectionInterval(
+ viewColumn,
+ viewColumn);
+ }
+
+ }
+
+ }
+
+ public void mouseReleased(MouseEvent e) {
+ if (jtable.equals(rowheaderTable))
+ return;
+
+ if (jtable.getRowCount() == 0)
+ return;
+
+ Point point = e.getPoint();
+ int row = jtable.rowAtPoint(point);
+
+ if (row == -1) {
+ TableColumnModel columnModel = jtable.getColumnModel();
+
+ int UIColumn = columnModel.getColumnIndexAtX(e.getX());
+ if (UIColumn == -1)
+ return;
+
+ TableColumn tableColumn = columnModel.getColumn(UIColumn);
+ // System.err.println("Removing .. " + UIColumn);
+ columnModel.removeColumn(tableColumn);
+ }
+ }
+ };
+
+ JTableHeader th = jtable.getTableHeader();
+ th.addMouseListener(listMouseListenerToHeader);
+
+ mouseToHeader = listMouseListenerToHeader;
+ }
+
+ private void addMouseListenerInTable(JTable aTable) {
+ final JTable tableView = aTable;
+
+ MouseAdapter listMouseListenerInTable = new MouseAdapter() {
+ public void mousePressed(MouseEvent e) {
+ int button1 = e.getModifiers() & InputEvent.BUTTON1_MASK;
+ if (button1 == 0)
+ return;
+
+ int ctrlPressed = e.getModifiers() & InputEvent.CTRL_MASK;
+ if (ctrlPressed != 0) {
+ table.setColumnSelectionAllowed(false);
+ rowheaderTable.setColumnSelectionAllowed(false);
+ table.setRowSelectionAllowed(true);
+ rowheaderTable.setRowSelectionAllowed(true);
+ int row = tableView.rowAtPoint(e.getPoint());
+
+ //erste Markierung auch mit CTRL -> alte Markierung löschen
+ if (table.getSelectedRowCount() == 0) {
+ table.clearSelection();
+ rowheaderTable.clearSelection();
+
+ } else {
+ table.addRowSelectionInterval(row, row);
+ rowheaderTable.addRowSelectionInterval(row, row);
+ }
+ return;
+ }
+
+ int shiftPressed = e.getModifiers() & InputEvent.SHIFT_MASK;
+ if (shiftPressed != 0)
+ return;
+
+ table.setColumnSelectionAllowed(false);
+ rowheaderTable.setColumnSelectionAllowed(false);
+ table.setRowSelectionAllowed(true);
+ rowheaderTable.setRowSelectionAllowed(true);
+ table.clearSelection();
+ rowheaderTable.clearSelection();
+ int row = tableView.rowAtPoint(e.getPoint());
+ //mb for selection
+ aktuellrow = row;
+
+ table.setRowSelectionInterval(row, row);
+ rowheaderTable.setRowSelectionInterval(row, row);
+ }
+
+ };
+ //MB for selection
+ MouseMotionAdapter listMouseMotionListenerInTable =
+ new MouseMotionAdapter() {
+ public void mouseDragged(MouseEvent e) {
+
+ // JOptionPane.showMessageDialog(null,"multiselect","SuperX",1) ;
+
+ int button1 = e.getModifiers() & InputEvent.BUTTON1_MASK;
+ if (button1 == 0)
+ return;
+
+ int ctrlPressed = e.getModifiers() & InputEvent.CTRL_MASK;
+ if (ctrlPressed != 0)
+ return;
+
+ int shiftPressed = e.getModifiers() & InputEvent.SHIFT_MASK;
+ if (shiftPressed != 0)
+ return;
+
+ table.setColumnSelectionAllowed(false);
+ rowheaderTable.setColumnSelectionAllowed(false);
+ table.setRowSelectionAllowed(true);
+ rowheaderTable.setRowSelectionAllowed(true);
+ table.clearSelection();
+ rowheaderTable.clearSelection();
+
+ int row2 = tableView.rowAtPoint(e.getPoint());
+
+ table.setRowSelectionInterval(aktuellrow, row2);
+ rowheaderTable.setRowSelectionInterval(aktuellrow, row2);
+
+ }
+ };
+
+ tableView.addMouseListener(listMouseListenerInTable);
+
+ tableView.addMouseMotionListener(listMouseMotionListenerInTable);
+
+ mouseInTable = listMouseListenerInTable;
+ }
+
+ private void sortTable(
+ final JTable tableView,
+ int column,
+ boolean ascending) {
+
+ SxWaitCursor.set(tableView, true);
+
+ sorter.sortByColumn(column, ascending);
+
+ SxWaitCursor.set(tableView, false);
+
+ rowheaderTable.revalidate();
+ rowheaderTable.repaint();
+ table.revalidate();
+ table.repaint();
+ }
+ private void addActionsToTable(JTable aTable) {
+ final JTable tableView = aTable;
+
+ /* für VisualAge auskommiert MB
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("UP"),
+ "UP");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("PAGE_UP"),
+ "PAGE_UP");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("DOWN"),
+ "DOWN");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("PAGE_DOWN"),
+ "PAGE_DOWN");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("LEFT"),
+ "LEFT");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("RIGHT"),
+ "RIGHT");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("ENTER"),
+ "ENTER");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke("TAB"),
+ "TAB");
+ tableView.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB,
+ Event.SHIFT_MASK),
+ "TAB");
+ */
+ Action Down = new AbstractAction("DOWN") {
+ Rectangle rect;
+ Rectangle rect_0_0;
+ Rectangle rect_vis;
+ int row, col_h, col_t;
+ int row_height, row_vis;
+
+ public void actionPerformed(ActionEvent e) {
+ row = tableView.getSelectedRow();
+ col_h = rowheaderTable.getSelectedColumn();
+ if (col_h == -1)
+ col_h = 0;
+ col_t = table.getSelectedColumn();
+ if (col_t == -1)
+ col_t = 0;
+
+ rect_0_0 = tableView.getCellRect(0, 0, true);
+ rect_vis = tableView.getVisibleRect();
+ row_height =
+ tableView.getScrollableBlockIncrement(
+ rect_0_0,
+ SwingConstants.VERTICAL,
+ 1);
+ row_vis = (int) rect_vis.height / row_height - 1;
+
+ if (row + 1 < tableView.getRowCount()) {
+ row++;
+ rowheaderTable.setRowSelectionInterval(row, row);
+ table.setRowSelectionInterval(row, row);
+ rect = tableView.getCellRect(row, col_h, true);
+ rowheaderTable.scrollRectToVisible(rect);
+ rect = table.getCellRect(row, col_t, true);
+ table.scrollRectToVisible(rect);
+ }
+ }
+ };
+
+ Action Up = new AbstractAction("UP") {
+ Rectangle rect;
+ Rectangle rect_0_0;
+ Rectangle rect_vis;
+ int row, col_h, col_t;
+ int row_height, row_vis;
+
+ public void actionPerformed(ActionEvent e) {
+ row = tableView.getSelectedRow();
+ col_h = rowheaderTable.getSelectedColumn();
+ if (col_h == -1)
+ col_h = 0;
+ col_t = table.getSelectedColumn();
+ if (col_t == -1)
+ col_t = 0;
+
+ rect_0_0 = tableView.getCellRect(0, 0, true);
+ rect_vis = tableView.getVisibleRect();
+ row_height =
+ tableView.getScrollableBlockIncrement(
+ rect_0_0,
+ SwingConstants.VERTICAL,
+ 1);
+ row_vis = (int) rect_vis.height / row_height - 1;
+
+ if (row > 0) {
+ row--;
+ rowheaderTable.setRowSelectionInterval(row, row);
+ table.setRowSelectionInterval(row, row);
+ rect = tableView.getCellRect(row, col_h, true);
+ rowheaderTable.scrollRectToVisible(rect);
+ rect = table.getCellRect(row, col_t, true);
+ table.scrollRectToVisible(rect);
+ }
+ }
+ };
+
+ Action Left = new AbstractAction("LEFT") {
+ Rectangle rect;
+ Rectangle rect_0_0;
+ Rectangle rect_vis;
+ int row, col_h, col_t;
+ int row_height, row_vis;
+
+ public void actionPerformed(ActionEvent e) {
+ row = tableView.getSelectedRow();
+ col_h = rowheaderTable.getSelectedColumn();
+ if (col_h == -1)
+ col_h = 0;
+ col_t = table.getSelectedColumn();
+ if (col_t == -1)
+ col_t = 0;
+
+ rect_0_0 = tableView.getCellRect(0, 0, true);
+ rect_vis = tableView.getVisibleRect();
+ row_height =
+ tableView.getScrollableBlockIncrement(
+ rect_0_0,
+ SwingConstants.VERTICAL,
+ 1);
+ row_vis = (int) rect_vis.height / row_height - 1;
+
+ if (tableView.equals(rowheaderTable)) {
+ if (col_h > 0) {
+ col_h--;
+ rowheaderTable.setColumnSelectionInterval(col_h, col_h);
+ rect = rowheaderTable.getCellRect(row, col_h, true);
+ rowheaderTable.scrollRectToVisible(rect);
+ }
+ return;
+ }
+ if (tableView.equals(table)) {
+ if (col_t == 0) {
+ rowheaderTable.requestFocus();
+
+ rect = rowheaderTable.getCellRect(row, col_h, true);
+ rowheaderTable.scrollRectToVisible(rect);
+ } else {
+ col_t--;
+ table.setColumnSelectionInterval(col_t, col_t);
+ rect = table.getCellRect(row, col_t, true);
+ table.scrollRectToVisible(rect);
+ }
+ return;
+ }
+ }
+ };
+
+ Action Right = new AbstractAction("RIGHT") {
+ Rectangle rect;
+ Rectangle rect_0_0;
+ Rectangle rect_vis;
+ int row, col_h, col_t;
+ int row_height, row_vis;
+
+ public void actionPerformed(ActionEvent e) {
+ row = tableView.getSelectedRow();
+ col_h = rowheaderTable.getSelectedColumn();
+ if (col_h == -1)
+ col_h = 0;
+ col_t = table.getSelectedColumn();
+ if (col_t == -1)
+ col_t = 0;
+
+ rect_0_0 = tableView.getCellRect(0, 0, true);
+ rect_vis = tableView.getVisibleRect();
+ row_height =
+ tableView.getScrollableBlockIncrement(
+ rect_0_0,
+ SwingConstants.VERTICAL,
+ 1);
+ row_vis = (int) rect_vis.height / row_height - 1;
+
+ if (tableView.equals(rowheaderTable)) {
+ if (col_h == rowheaderTable.getColumnCount() - 1) {
+ table.requestFocus();
+
+ rect = table.getCellRect(row, col_t, true);
+ table.scrollRectToVisible(rect);
+ } else {
+ col_h++;
+ rowheaderTable.setColumnSelectionInterval(col_h, col_h);
+ rect = rowheaderTable.getCellRect(row, col_h, true);
+ rowheaderTable.scrollRectToVisible(rect);
+ }
+ return;
+ }
+ if (tableView.equals(table)) {
+ if (col_t < table.getColumnCount() - 1) {
+ col_t++;
+ table.setColumnSelectionInterval(col_t, col_t);
+ rect = table.getCellRect(row, col_t, true);
+ table.scrollRectToVisible(rect);
+ }
+ return;
+ }
+ }
+ };
+
+ Action pageDown = new AbstractAction("PAGE_DOWN") {
+ Rectangle rect;
+ Rectangle rect_0_0;
+ Rectangle rect_vis;
+ int row, col_h, col_t;
+ int row_height, row_vis;
+
+ public void actionPerformed(ActionEvent e) {
+ row = tableView.getSelectedRow();
+ col_h = rowheaderTable.getSelectedColumn();
+ if (col_h == -1)
+ col_h = 0;
+ col_t = table.getSelectedColumn();
+ if (col_t == -1)
+ col_t = 0;
+
+ rect_0_0 = tableView.getCellRect(0, 0, true);
+ rect_vis = tableView.getVisibleRect();
+ row_height =
+ tableView.getScrollableBlockIncrement(
+ rect_0_0,
+ SwingConstants.VERTICAL,
+ 1);
+ row_vis = (int) rect_vis.height / row_height - 1;
+
+ if (row + row_vis < tableView.getRowCount()) {
+ row += row_vis;
+ rowheaderTable.setRowSelectionInterval(row, row);
+ table.setRowSelectionInterval(row, row);
+ rect = tableView.getCellRect(row, col_h, true);
+ rowheaderTable.scrollRectToVisible(rect);
+ rect = table.getCellRect(row, col_t, true);
+ table.scrollRectToVisible(rect);
+ }
+ }
+ };
+
+ Action pageUp = new AbstractAction("PAGE_UP") {
+ Rectangle rect;
+ Rectangle rect_0_0;
+ Rectangle rect_vis;
+ int row, col_h, col_t;
+ int row_height, row_vis;
+
+ public void actionPerformed(ActionEvent e) {
+ row = tableView.getSelectedRow();
+ col_h = rowheaderTable.getSelectedColumn();
+ if (col_h == -1)
+ col_h = 0;
+ col_t = table.getSelectedColumn();
+ if (col_t == -1)
+ col_t = 0;
+
+ rect_0_0 = tableView.getCellRect(0, 0, true);
+ rect_vis = tableView.getVisibleRect();
+ row_height =
+ tableView.getScrollableBlockIncrement(
+ rect_0_0,
+ SwingConstants.VERTICAL,
+ 1);
+ row_vis = (int) rect_vis.height / row_height - 1;
+
+ if (row - row_vis > 0) {
+ row -= row_vis;
+ rowheaderTable.setRowSelectionInterval(row, row);
+ table.setRowSelectionInterval(row, row);
+ rect = tableView.getCellRect(row, col_h, true);
+ rowheaderTable.scrollRectToVisible(rect);
+ rect = table.getCellRect(row, col_t, true);
+ table.scrollRectToVisible(rect);
+ }
+ }
+ };
+
+ Action Enter = new AbstractAction("ENTER") {
+ JButton defaultBtn;
+ Rectangle rect;
+ Rectangle rect_0_0;
+ Rectangle rect_vis;
+ int row, col_h, col_t;
+ int row_height, row_vis;
+
+ public void actionPerformed(ActionEvent e) {
+ row = tableView.getSelectedRow();
+ col_h = rowheaderTable.getSelectedColumn();
+ if (col_h == -1)
+ col_h = 0;
+ col_t = table.getSelectedColumn();
+ if (col_t == -1)
+ col_t = 0;
+
+ rect_0_0 = tableView.getCellRect(0, 0, true);
+ rect_vis = tableView.getVisibleRect();
+ row_height =
+ tableView.getScrollableBlockIncrement(
+ rect_0_0,
+ SwingConstants.VERTICAL,
+ 1);
+ row_vis = (int) rect_vis.height / row_height - 1;
+
+ JButton defaultBtn = tableView.getRootPane().getDefaultButton();
+ if (defaultBtn != null)
+ defaultBtn.doClick(); // DefaultButton aktivieren
+ }
+ };
+
+ Action Tab = new AbstractAction("TAB") {
+ JButton defaultBtn;
+
+ public void actionPerformed(ActionEvent e) {
+ defaultBtn = tableView.getRootPane().getDefaultButton();
+ if (defaultBtn != null)
+ defaultBtn.requestFocus(); // DefaultButton Focus
+ }
+ };
+ /* MB für VisualAge auskommentiert
+ tableView.getActionMap().put("UP", Up);
+ tableView.getActionMap().put("DOWN", Down);
+ tableView.getActionMap().put("LEFT", Left);
+ tableView.getActionMap().put("RIGHT", Right);
+ tableView.getActionMap().put("PAGE_UP", pageUp);
+ tableView.getActionMap().put("PAGE_DOWN", pageDown);
+ tableView.getActionMap().put("ENTER", Enter);
+ tableView.getActionMap().put("TAB", Tab);
+ */
+ }
+
+ class ChangeEditorListener implements CellEditorListener {
+ public void editingStopped(ChangeEvent e) {
+ System.err.println(
+ "ChangeEditorListener: Editing stopped .. Update ..");
+
+ }
+ public void editingCanceled(ChangeEvent e) {
+ System.err.println("ChangeEditorListener: Editing canceled ..");
+ }
+ }
+
+}
diff --git a/src/de/superx/applet/SxTableSorter.java b/src/de/superx/applet/SxTableSorter.java
new file mode 100644
index 0000000..88cee70
--- /dev/null
+++ b/src/de/superx/applet/SxTableSorter.java
@@ -0,0 +1,354 @@
+// Beispielklasse aus dem JavaTutorial (http://java.sun.com/docs/books/tutorial) für SuperX angepasst
+/*
+ * @(#)TableSorter.java 1.3 97/10/06
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * This software is the confidential and proprietary information of Sun
+ * Microsystems, Inc. ("Confidential Information"). You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with Sun.
+ *
+ * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
+ * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
+ * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
+ * THIS SOFTWARE OR ITS DERIVATIVES.
+ *
+ */
+
+/**
+ * A sorter for TableModels. The sorter has a model (conforming to TableModel)
+ * and itself implements TableModel. TableSorter does not store or copy
+ * the data in the TableModel, instead it maintains an array of
+ * integers which it keeps the same size as the number of rows in its
+ * model. When the model changes it notifies the sorter that something
+ * has changed eg. "rowsAdded" so that its internal array of integers
+ * can be reallocated. As requests are made of the sorter (like
+ * getValueAt(row, col) it redirects them to its model via the mapping
+ * array. That way the TableSorter appears to hold another copy of the table
+ * with the rows in a different order. The sorting algorthm used is stable
+ * which means that it does not move around rows when its comparison
+ * function returns 0 to denote that they are equivalent.
+ *
+ * @version 1.3 10/06/97
+ * @author Philip Milne
+ */
+
+package de.superx.applet;
+import java.util.Date;
+import java.util.Vector;
+
+import javax.swing.event.TableModelEvent;
+
+/**
+ * Ein Sortierer für Tabellenmodelle.
+ * @version 1.3 10/06/97
+ * @author Philip Milne
+ */
+
+public class SxTableSorter extends SxTableMap
+{
+ int indexes[];
+ Vector sortingColumns = new Vector();
+ boolean ascending = true;
+ int compares;
+
+ public SxTableSorter()
+ {
+ indexes = new int[0]; // For consistency.
+ }
+
+ public SxTableSorter(SxTableModel model)
+ {
+ setModel(model);
+ }
+
+ public void setModel(SxTableModel model) {
+ super.setModel(model);
+ reallocateIndexes();
+ }
+
+ public int [] getIndexes ()
+ {
+ return indexes;
+ }
+
+ public int compareRowsByColumn(int row1, int row2, int column)
+ {
+ Class type = model.getColumnClass(column);
+ SxTableModel data = model;
+
+ // Check for nulls
+
+ Object o1 = data.getObjectAt(row1, column);
+ Object o2 = data.getObjectAt(row2, column);
+
+ // If both values are null return 0
+ if (o1 == null && o2 == null) {
+ return 0;
+ }
+ else if (o1 == null) { // Define null less than everything.
+ return -1;
+ }
+ else if (o2 == null) {
+ return 1;
+ }
+
+/* We copy all returned values from the getValue call in case
+an optimised model is reusing one object to return many values.
+The Number subclasses in the JDK are immutable and so will not be used in
+this way but other subclasses of Number might want to do this to save
+space and avoid unnecessary heap allocation.
+*/
+ if (type.getSuperclass() == java.lang.Number.class)
+ {
+ Number n1 = (Number)data.getObjectAt(row1, column);
+ double d1 = n1.doubleValue();
+ Number n2 = (Number)data.getObjectAt(row2, column);
+ double d2 = n2.doubleValue();
+
+ if (d1 < d2)
+ return -1;
+ else if (d1 > d2)
+ return 1;
+ else
+ return 0;
+ }
+ else if (type == java.util.Date.class)
+ {
+ Date d1 = (Date)data.getObjectAt(row1, column);
+ long n1 = d1.getTime();
+ Date d2 = (Date)data.getObjectAt(row2, column);
+ long n2 = d2.getTime();
+
+ if (n1 < n2)
+ return -1;
+ else if (n1 > n2)
+ return 1;
+ else return 0;
+ }
+ else if (type == String.class)
+ {
+ String s1 = (String)data.getObjectAt(row1, column);
+ String s2 = (String)data.getObjectAt(row2, column);
+ int result = s1.compareTo(s2);
+
+ if (result < 0)
+ return -1;
+ else if (result > 0)
+ return 1;
+ else return 0;
+ }
+ else if (type == Boolean.class)
+ {
+ Boolean bool1 = (Boolean)data.getObjectAt(row1, column);
+ boolean b1 = bool1.booleanValue();
+ Boolean bool2 = (Boolean)data.getObjectAt(row2, column);
+ boolean b2 = bool2.booleanValue();
+
+ if (b1 == b2)
+ return 0;
+ else if (b1) // Define false < true
+ return 1;
+ else
+ return -1;
+ }
+ else
+ {
+ Object v1 = data.getObjectAt(row1, column);
+ String s1 = v1.toString();
+ Object v2 = data.getObjectAt(row2, column);
+ String s2 = v2.toString();
+ int result = s1.compareTo(s2);
+
+ if (result < 0)
+ return -1;
+ else if (result > 0)
+ return 1;
+ else return 0;
+ }
+ }
+
+ public int compare(int row1, int row2)
+ {
+ compares++;
+ for(int level = 0; level < sortingColumns.size(); level++)
+ {
+ Integer column = (Integer)sortingColumns.elementAt(level);
+ int result = compareRowsByColumn(row1, row2, column.intValue());
+ if (result != 0)
+ return ascending ? result : -result;
+ }
+ return 0;
+ }
+
+ public void reallocateIndexes()
+ {
+ int rowCount = model.getRowCount();
+
+ // Set up a new array of indexes with the right number of elements
+ // for the new data model.
+ indexes = new int[rowCount];
+
+ // Initialise with the identity mapping.
+ for(int row = 0; row < rowCount; row++)
+ indexes[row] = row;
+ }
+
+ public void tableChanged(TableModelEvent e)
+ {
+ // System.err.println("Sorter: tableChanged");
+ reallocateIndexes();
+
+ super.tableChanged(e);
+ }
+
+ public void dataChanged()
+ {
+ reallocateIndexes();
+ sort(this);
+ super.tableChanged(new TableModelEvent(this, 0, getRowCount()));
+ }
+
+ public void checkModel()
+ {
+ if (indexes.length != model.getRowCount()) {
+ // System.err.println("Sorter not informed of a change in model.");
+ }
+ }
+
+ public void sort(Object sender)
+ {
+ checkModel();
+
+ compares = 0;
+ // n2sort();
+ // qsort(0, indexes.length-1);
+ shuttlesort((int[])indexes.clone(), indexes, 0, indexes.length);
+ // System.err.println("Compares: "+compares);
+ }
+
+ public void n2sort() {
+ for(int i = 0; i < getRowCount(); i++) {
+ for(int j = i+1; j < getRowCount(); j++) {
+ if (compare(indexes[i], indexes[j]) == -1) {
+ swap(i, j);
+ }
+ }
+ }
+ }
+
+ // This is a home-grown implementation which we have not had time
+ // to research - it may perform poorly in some circumstances. It
+ // requires twice the space of an in-place algorithm and makes
+ // NlogN assigments shuttling the values between the two
+ // arrays. The number of compares appears to vary between N-1 and
+ // NlogN depending on the initial order but the main reason for
+ // using it here is that, unlike qsort, it is stable.
+ public void shuttlesort(int from[], int to[], int low, int high) {
+ if (high - low < 2) {
+ return;
+ }
+ int middle = (low + high)/2;
+ shuttlesort(to, from, low, middle);
+ shuttlesort(to, from, middle, high);
+
+ int p = low;
+ int q = middle;
+
+ /* This is an optional short-cut; at each recursive call,
+ check to see if the elements in this subset are already
+ ordered. If so, no further comparisons are needed; the
+ sub-array can just be copied. The array must be copied rather
+ than assigned otherwise sister calls in the recursion might
+ get out of sinc. When the number of elements is three they
+ are partitioned so that the first set, [low, mid), has one
+ element and and the second, [mid, high), has two. We skip the
+ optimisation when the number of elements is three or less as
+ the first compare in the normal merge will produce the same
+ sequence of steps. This optimisation seems to be worthwhile
+ for partially ordered lists but some analysis is needed to
+ find out how the performance drops to Nlog(N) as the initial
+ order diminishes - it may drop very quickly. */
+
+ if (high - low >= 4 && compare(from[middle-1], from[middle]) <= 0) {
+ for (int i = low; i < high; i++) {
+ to[i] = from[i];
+ }
+ return;
+ }
+
+ // A normal merge.
+
+ for(int i = low; i < high; i++) {
+ if (q >= high || (p < middle && compare(from[p], from[q]) <= 0)) {
+ to[i] = from[p++];
+ }
+ else {
+ to[i] = from[q++];
+ }
+ }
+ }
+
+ public void swap(int i, int j) {
+ int tmp = indexes[i];
+ indexes[i] = indexes[j];
+ indexes[j] = tmp;
+ }
+
+ // The mapping only affects the contents of the data rows.
+ // Pass all requests to these rows through the mapping array: "indexes".
+
+ public Object getValueAt(int aRow, int aColumn)
+ {
+ checkModel();
+ return model.getValueAt(indexes[aRow], aColumn);
+ }
+
+ // r.b. extension for proper sorting
+ public Object getObjectAt(int aRow, int aColumn)
+ {
+ checkModel();
+ return model.getObjectAt(indexes[aRow], aColumn);
+ }
+
+ public void setValueAt(Object aValue, int aRow, int aColumn)
+ {
+ checkModel();
+ model.setValueAt(aValue, indexes[aRow], aColumn);
+ }
+
+ // r.b. extension for easy data setting
+ public void setDataVector(Vector rows, Vector header, Object meta)
+ {
+ // System.err.println ("Sorter: Rows = " + Rows.size());
+ indexes = new int [rows.size()];
+
+ model.setDataVector(rows, header, meta);
+ }
+
+ // r.b. extension for easy data setting
+ public void setDataVector(Vector Rows)
+ {
+ // System.err.println ("Sorter: Rows = " + Rows.size());
+ indexes = new int [Rows.size()];
+
+ model.setDataVector(Rows);
+ }
+
+ public void sortByColumn(int column) {
+ sortByColumn(column, true);
+ }
+
+ public void sortByColumn(int column, boolean ascending) {
+ this.ascending = ascending;
+ sortingColumns.removeAllElements();
+ sortingColumns.addElement(new Integer(column));
+ sort(this);
+ super.tableChanged(new TableModelEvent(this, 0, getRowCount()));
+ }
+
+}
diff --git a/src/de/superx/applet/SxThemenEintrag.java b/src/de/superx/applet/SxThemenEintrag.java
new file mode 100644
index 0000000..5e6d3f3
--- /dev/null
+++ b/src/de/superx/applet/SxThemenEintrag.java
@@ -0,0 +1,71 @@
+package de.superx.applet;
+/**
+ *
+ * Ein Eintrag für den Themenbaum.
+ * Abgelegt wird tid in der Tabelle themenbaum, Name, ggfs. Tid in der Tabelle Maskeninfo, Nummer des Vaterknotens (parent) und Erläuterungstext.
+ *
+ * @version 2.0 01/01/02
+ * @author Meikel Bisping
+ */
+
+
+public class SxThemenEintrag {
+ private Integer tid;
+ private String name;
+ private Integer maskeninfo_id;
+ private Integer parent;
+ private String erlaeuterung;
+ private String cssClass;
+ SxThemenEintrag ()
+ {
+ tid=null;
+ name=null;
+ maskeninfo_id=null;
+ parent=null;
+ erlaeuterung=null;
+ cssClass=null;
+}
+
+SxThemenEintrag(Integer ltid, String lname, Integer lnr, Integer lparent, String lerlaeuterung, String lcssClass)
+{
+ tid=ltid;
+ name=lname;
+ maskeninfo_id=lnr;
+ parent=lparent;
+ erlaeuterung=lerlaeuterung;
+ cssClass=lcssClass;
+ }
+
+
+public Integer getTid()
+{
+ return tid;
+}
+public String getName()
+{
+ return name;
+}
+public Integer getMaskeninfo_id()
+{
+ return maskeninfo_id;
+}
+public Integer getParent()
+{
+ return parent;
+}
+
+public String getErlaeuterung()
+{
+ return erlaeuterung;
+}
+public String getCssClass()
+{
+ return cssClass;
+}
+
+public String toString()
+ {
+ return this.name;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxThemenbaum.java b/src/de/superx/applet/SxThemenbaum.java
new file mode 100644
index 0000000..e33bb73
--- /dev/null
+++ b/src/de/superx/applet/SxThemenbaum.java
@@ -0,0 +1,423 @@
+package de.superx.applet;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.sql.SQLException;
+import java.util.Enumeration;
+import java.util.Locale;
+import java.util.Vector;
+
+import javax.swing.ImageIcon;
+import javax.swing.JTree;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.TreePath;
+import javax.swing.tree.TreeSelectionModel;
+
+/**
+ * Beim ersten Aufruf wird der Themenbaum aus der Datenbank aufgebaut und in der statischen Variable tree abgelegt.
+ * Nur wenn ein anderer Benutzer/Stand angefordert wird, wird der Themenbaum neu aufgebaut.
+ * Die Darstellung wird von SxMask übernommen.
+ * @version 2.0 01/01/02
+ * @author Meikel Bisping
+ */
+
+public class SxThemenbaum extends MouseAdapter implements TreeSelectionListener{
+
+ private Vector themenbaum;
+ private JTree tree;
+
+ private SxThemenEintrag einEintrag;
+ static ImageIcon leaf = null;
+ private String standStr, lastuser;
+ private SxMask localmask;
+ private Vector rohform;
+
+ SxThemenbaum(SxMask lmask) {
+ localmask = lmask;
+ String aktuser = new String();
+ aktuser = SxSQL.getUserID().toString();
+
+ if (!aktuser.equals(lastuser)) {
+ tree = null;
+ standStr = null;
+ lastuser = aktuser;
+ }
+
+ if (leaf == null) {
+ ClassLoader cl = getClass().getClassLoader();
+ try { leaf = new ImageIcon(cl.getResource("images/leaf.gif"));
+ }
+ catch (Exception e)
+ {
+ System.out.println("Bild für Baum nicht verfügbar");
+ }
+ }
+ }
+
+ public JTree getTree(String lStand) throws SQLException {
+ // liefert Organigramm v. angegebenen Stand zurück
+ String name, erlaeuterung, cssClass;
+ Integer tid, maskeninfo_id, parent;
+ //Der folgende Parameter ist nur provisorisch drin, in Zkunft kommt hier
+ //Locale-Behandlung rein.
+ //neu erstellen nur beim 1.mal und anderem Stand
+
+ // if (Stand == null || (!Stand.equals(lStand))) {
+ standStr = lStand;
+
+ //tree erzeugen für Stand
+ //aus Datenbank auslesen
+ String userID = SxSQL.getUserID().toString();
+
+ //datum String in sql.Date umformen
+ java.sql.Date date = new java.sql.Date(1);
+ date = SxDate.getDate(standStr);
+ //rohform ist als Membervariable definiert, damit
+ //noch erlaubteKnoten hinzugefügt werden können
+ rohform = new Vector();
+
+ String query = "";
+
+ String sx_db = (String) SxDefaults.getPropertyValue("SxDB");
+ //default für andere Datenbanken
+ query =
+ "select tid, name, maskeninfo_id, parent, gueltig_seit, gueltig_bis,sort,css_class from themenbaum order by sort,name;drop table tmp_themenbaum;";
+ //Makroabfragen sollen nicht erscheinen
+ if (sx_db.equalsIgnoreCase("postgres")) {
+ query =
+ "select sp_user_themen("
+ + userID
+ + ",today(),0);"+ //,'"+currentLocale.getLanguage()+ "')
+ "select distinct tid,name,maskeninfo_id,parent,erlaeuterung,sort,css_class from tmp_themenbaum order by sort,name;drop table tmp_themenbaum;";
+ }
+ if (sx_db.equalsIgnoreCase("informix"))
+ {
+ query =
+ "execute procedure sp_user_themen("
+ + userID
+ + ",today,0);"+ //'"+currentLocale.getLanguage()+ "');" +
+ "select distinct tid,name,maskeninfo_id,parent,erlaeuterung,sort,css_class from tmp_themenbaum order by sort,name;drop table tmp_themenbaum;";
+ }
+
+
+ SxSQL.executeAll(query);
+ rohform = SxSQL.getResultVector();
+
+ if (rohform.size() < 1)
+ return null;
+ //Umformen in Vector of SxThemenEintrag
+ Vector dummy = new Vector();
+ themenbaum = new Vector();
+ Enumeration en1 = rohform.elements();
+
+ while (en1.hasMoreElements()) {
+ dummy = (Vector) en1.nextElement();
+ if (dummy.elementAt(0)==null||!(dummy.elementAt(0) instanceof Integer))
+ throw new IllegalArgumentException("Konnte Themenbaun nicht aufbauen, da Werte in tmp Tabelle fehlen oder falsch");
+ tid = (Integer) dummy.elementAt(0);
+ if (dummy.elementAt(1)==null)
+ throw new IllegalArgumentException("Konnte Themenbaun nicht aufbauen, da Werte in tmp Tabelle fehlen oder falsch");
+
+ name = dummy.elementAt(1).toString();
+ maskeninfo_id = (Integer) dummy.elementAt(2);
+ parent = (Integer) dummy.elementAt(3);
+ erlaeuterung = dummy.elementAt(4)==null?"":dummy.elementAt(4).toString();
+ cssClass= dummy.elementAt(5)==null?"":dummy.elementAt(5).toString();
+ einEintrag =
+ new SxThemenEintrag(
+ tid,
+ name,
+ maskeninfo_id,
+ parent,
+ erlaeuterung,
+ cssClass);
+ themenbaum.addElement(einEintrag);
+ }
+ rohform = null;
+ SxThemenEintrag ebene0 =
+ new SxThemenEintrag(
+ null,
+ "Abfragen/Berichte",
+ null,
+ null,
+ null,
+ null);
+ DefaultMutableTreeNode root =
+ new DefaultMutableTreeNode(ebene0);
+
+ //hier werden über eine rekursive Methode alle
+ //Institute in den Baum eingetragen
+ insertnodes(null, root);
+ themenbaum = null;
+
+ //Baum erzeugen
+ tree = new JTree(root);
+ de.memtext.util.TreeUtils.sort(root);
+ tree.setRootVisible(false);
+ //root Abfragen/Berichte sieht man sowieso nicht
+ //first child abfragen muss aufgeklappt sein
+ //da Mouselistener Doubleclick umfunktioniert
+ if (root.getChildCount() > 0) {
+ DefaultMutableTreeNode ebene1 =
+ (DefaultMutableTreeNode) root.getChildAt(0);
+ tree.expandPath(new TreePath(ebene1.getPath()));
+ }
+
+ //Einfachselektion
+ tree.getSelectionModel().setSelectionMode(
+ TreeSelectionModel.SINGLE_TREE_SELECTION);
+
+ //Markierungsrandfarbe grau nicht gelb
+ DefaultTreeCellRenderer renderer =
+ new DefaultTreeCellRenderer();
+ renderer.setBorderSelectionColor(java.awt.Color.darkGray);
+ //ImageIcon leaf=new ImageIcon("h:\\mb\\leaf.gif");
+ if (leaf != null)
+ renderer.setLeafIcon(leaf);
+ tree.setCellRenderer(renderer);
+
+ //TreeSelectionListener hinzufügen
+ //SxThemenDialogSecList sl = new SxThemenDialogSecList(localmask, tree);
+ tree.addTreeSelectionListener(this);
+
+
+
+ //MouseListener für Doppelklicks
+ //(wird immer neu hinzugefügt, klappte sonst nicht?!)
+ //SxThemenMouseListener ml = new SxThemenMouseListener(localmask);
+ tree.addMouseListener(this);
+ return tree;
+ }
+
+ private void insertnodes(
+ Integer theParent,
+ DefaultMutableTreeNode aktNode) {
+ //rekursive Methode, die Institutionen in den Baum einträgt
+ Vector result = new Vector();
+ result = mySelect(theParent);
+ Integer eintrag_tid;
+
+ for (Enumeration el = result.elements(); el.hasMoreElements();) {
+ einEintrag = (SxThemenEintrag) el.nextElement();
+ DefaultMutableTreeNode neuNode =
+ new DefaultMutableTreeNode(einEintrag);
+ aktNode.add(neuNode);
+
+ eintrag_tid = einEintrag.getTid();
+ //nervig null-Werte abfangen
+ if (eintrag_tid != null & theParent == null)
+ insertnodes(einEintrag.getTid(), neuNode);
+ if (eintrag_tid == null & theParent == null)
+ System.out.println(
+ "Achtung! Element hat fälschlicherweise sich selbst als parent:"
+ + einEintrag.getName());
+
+ if (eintrag_tid != null && theParent != null)
+ if (!theParent.equals(eintrag_tid))
+ insertnodes(einEintrag.getTid(), neuNode);
+ else
+ System.out.println(
+ "Achtung! Element hat fälschlicherweise sich selbst als parent:"
+ + einEintrag.getName()
+ + "tid:"
+ + einEintrag.getTid());
+ }
+
+ //wenn eine Kategorie (maskeninfo==null) keine Blätter (Abfragen)
+ //enthält, die Kategorie entfernen
+ einEintrag = (SxThemenEintrag) aktNode.getUserObject();
+ // if (einEintrag.getMaskeninfo_id()==null&&result.size()<1)
+ if (einEintrag.getMaskeninfo_id() == null && aktNode.isLeaf())
+ aktNode.removeFromParent();
+
+ }
+
+ private Vector mySelect(Integer pruefparent) {
+ //liefert alle Institute mit Parent =pruefparent zurück
+ Vector result = new Vector();
+ Integer eintrag_parent;
+ for (Enumeration el = themenbaum.elements();
+ el.hasMoreElements();
+ ) {
+ einEintrag = (SxThemenEintrag) el.nextElement();
+ eintrag_parent = einEintrag.getParent();
+ if (eintrag_parent == null && pruefparent == null)
+ result.addElement(einEintrag);
+ if (eintrag_parent != null && pruefparent != null)
+ if (eintrag_parent.intValue() == pruefparent.intValue())
+ result.addElement(einEintrag);
+
+ }
+ return result;
+ }
+
+ private void addKnotenUnique(Vector eineMaske) {
+ //Maske hinzufügen, falls unter dem Parent nicht schon vorhanden
+ boolean schonvorhanden = false;
+ Vector test;
+ Integer maskeninfo_tid, parent;
+ maskeninfo_tid = (Integer) eineMaske.elementAt(2);
+ parent = (Integer) eineMaske.elementAt(3);
+ for (Enumeration el = rohform.elements(); el.hasMoreElements();) {
+
+ test = (Vector) el.nextElement();
+ if (maskeninfo_tid.equals((Integer) test.elementAt(2))
+ && parent.equals((Integer) test.elementAt(3))) {
+ schonvorhanden = true;
+ break;
+ }
+ }
+ if (!schonvorhanden)
+ rohform.add(eineMaske); // rohform ist Membervariable
+ }
+
+ public void valueChanged(TreeSelectionEvent event) {
+ DefaultMutableTreeNode node =
+ (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
+
+ if (node != null) {
+ SxThemenEintrag themenEintrag=(SxThemenEintrag) node.getUserObject();
+ MaskeninfoElement selectedMaskeninfoElement=
+ localmask.getSelectedMaskeninfoElement();
+
+ selectedMaskeninfoElement.clear();
+ selectedMaskeninfoElement.setTid(themenEintrag.getMaskeninfo_id());
+ selectedMaskeninfoElement.setName(themenEintrag.getName());
+ localmask.terlaeuterung.setText(themenEintrag.getErlaeuterung());
+ //System.out.println("Erl:"+help.getErlaeuterung());
+
+ }
+ }
+ public void mousePressed(MouseEvent e) {
+ if (e.getClickCount() == 2) {
+ //ausgewählter Wert wurde durch SelectionListener schon festgestellt
+ if (localmask.getSelectedMaskeninfoElement().getTid()!=null) localmask.maskeOeffnen();
+ }
+ }
+ }
+
+// alternative Version, wird nicht genutzt
+ /* private void erlaubteKnotenHinzufügen(
+ String userid,
+ java.sql.Date date) {
+ String query;
+ Vector dummy, Knoten = null;
+ Integer tid;
+
+ try {
+ //Rechte, die dem User gegeben wurden
+ query =
+ "select U.id from user_themen U,themenbaum T where U.id=T.tid and U.maske=0 and U.userid="
+ + userid
+ + " and "
+ + " T.gueltig_seit<=date('"
+ + DateUtils.getTodayString()
+ + "') and T.gueltig_bis>=date('"
+ + DateUtils.getTodayString()
+ + "') "
+ + "union "
+ +
+ //Rechte, die der Grupper gegeben wurden
+ "select G.id from group_themen G,themenbaum T, user_group_bez B where G.id=T.tid"
+ + " and G.maske=0 and G.groupid=B.groupinfo_id and B.userinfo_id="
+ + userid
+ + " and "
+ + " T.gueltig_seit<=date('"
+ + DateUtils.getTodayString()
+ + "') and T.gueltig_bis>=date('"
+ + DateUtils.getTodayString()
+ + "') ";
+
+ SxSQL.executeQuery(query);
+ Knoten = SxSQL.getResultVector();
+
+ } catch (Exception ex) {
+ System.out.println(ex.toString());
+ ex.printStackTrace();
+ }
+
+ for (Enumeration el = Knoten.elements(); el.hasMoreElements();) {
+ dummy = (Vector) el.nextElement();
+ //SxSQL liefert immer Vector of Vectors zurück
+ tid = (Integer) dummy.elementAt(0);
+
+ erlaubteHinzufügenRekursion(tid, date);
+
+ }
+
+ }
+private void erlaubteHinzufügenRekursion(
+ Integer themenknoten,
+ java.sql.Date date) {
+ String query;
+ Vector dummy, Masken, Masken2, eineMaske, Knoten = null;
+ Integer tid;
+ try {
+ //Masken der Auflistung hinzufügen
+ query =
+ "select T.tid, M.name,M.tid,T.parent, M.erlaeuterung from maskeninfo M, themenbaum T where T.maskeninfo_id=M.tid and maskeninfo_id is not null and T.parent="
+ + themenknoten
+ + " and T.gueltig_seit<=date('"
+ + DateUtils.getTodayString()
+ + "') and T.gueltig_bis>=date('"
+ + DateUtils.getTodayString()
+ + "') ";
+
+ SxSQL.executeQuery(query);
+ Masken = SxSQL.getResultVector();
+ for (Enumeration el = Masken.elements();
+ el.hasMoreElements();
+ ) {
+ eineMaske = (Vector) el.nextElement();
+ addKnotenUnique(eineMaske);
+
+ //prüfen, ob die Maske noch unter anderen Knoten vorkommt, ggfs. hinzufügen
+ query =
+ "select T.tid, M.name,M.tid,T.parent, M.erlaeuterung from maskeninfo M, themenbaum T where "
+ + "T.maskeninfo_id=M.tid and maskeninfo_id="
+ + eineMaske.elementAt(2).toString()
+ + " and T.parent!="
+ + themenknoten
+ + " and T.gueltig_seit<=date('"
+ + DateUtils.getTodayString()
+ + "') and T.gueltig_bis>=date('"
+ + DateUtils.getTodayString()
+ + "') ";
+ SxSQL.executeQuery(query);
+ Masken2 = SxSQL.getResultVector();
+ for (Enumeration el2 = Masken2.elements();
+ el2.hasMoreElements();
+ ) {
+ eineMaske = (Vector) el2.nextElement();
+ addKnotenUnique(eineMaske);
+ }
+
+ }
+
+ //für weitere Knoten Prozedure rekursiv aufrufen
+ query =
+ "select T.tid from themenbaum T where T.parent="
+ + themenknoten
+ + " and T.maskeninfo_id is null "
+ + " and T.gueltig_seit<=date('"
+ + DateUtils.getTodayString()
+ + "') and T.gueltig_bis>=date('"
+ + DateUtils.getTodayString()
+ + "') ";
+ SxSQL.executeQuery(query);
+ Knoten = SxSQL.getResultVector();
+ } catch (Exception ex) {
+ System.out.println(ex.toString());
+ ex.printStackTrace();
+ }
+ for (Enumeration el = Knoten.elements(); el.hasMoreElements();) {
+ dummy = (Vector) el.nextElement();
+ //SxSQL liefert immer Vector of Vectors zurück
+ tid = (Integer) dummy.elementAt(0);
+
+ erlaubteHinzufügenRekursion(tid, date);
+ }
+ }
+*/
diff --git a/src/de/superx/applet/SxTreeDlg.java b/src/de/superx/applet/SxTreeDlg.java
new file mode 100644
index 0000000..2bc214f
--- /dev/null
+++ b/src/de/superx/applet/SxTreeDlg.java
@@ -0,0 +1,388 @@
+package de.superx.applet;
+
+import java.awt.Font;
+import java.awt.Frame;
+import java.awt.Point;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.sql.Date;
+import java.sql.SQLException;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.TimeZone;
+
+import javax.swing.JButton;
+import javax.swing.JEditorPane;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import de.memtext.dlg.OkCancelClearDlg;
+import de.memtext.tree.KeyParentEqualException;
+import de.memtext.tree.NoMainEntryException;
+import de.memtext.util.DateUtils;
+import de.memtext.util.WindowUtils;
+import de.memtext.widgets.LabeledComboBox;
+import de.memtext.widgets.TitlePanel;
+import de.memtext.widgets.VerticalBox;
+import de.memtext.widgets.WarningMessage;
+import de.superx.common.DBServletException;
+import de.superx.common.FieldContainer;
+import de.superx.common.SelectableItem;
+import de.superx.common.Sichtgruppe;
+
+/**
+ * Ein Baumdialog, bei dem ein Element ausgewählt werden kann. Falls in der
+ * Sichtgruppe mehrere Sichten enthalten sind, kann eine Sicht ausgewählt
+ * werden. Ggfs. kann auch der Stand geändert werden. Als gewähltes Ergebnis
+ * kann man mit der Methode getResult ein SelectableItem-Objekt kriegen.
+ *
+ * @author Meikel Bisping
+ */
+public class SxTreeDlg extends OkCancelClearDlg {
+ private JButton bStand;
+ private JEditorPane erlPane = new JEditorPane("text/html", "");
+ private JScrollPane erlScrollP;
+ private Font fontBtns = new Font("SansSerif", Font.PLAIN, 10);
+ boolean result, isStandChanged;
+ private LinkedList selections = new LinkedList();
+ JLabel lblStand;
+ private String standAmAnfang;
+ JScrollPane treeScroll = new JScrollPane();
+ private SxTreeDlgMouseListener mouseList = new SxTreeDlgMouseListener();
+ private LabeledComboBox cbSichten;
+ private Sichtgruppe sichtgruppe;
+ private JPanel auswahlPanel;
+ private SichtenChangeListener changeListener = new SichtenChangeListener();
+
+ public SxTreeDlg(Frame parent, String name, Sichtgruppe sichtgruppe,
+ String erläuterung) throws SQLException, DBServletException,
+ KeyParentEqualException, CloneNotSupportedException, NoMainEntryException {
+ super(parent, "Auswahl " + name);
+ selections.clear();
+ Point parloc = parent.getLocation();
+ setLocation(parloc.x + 30, parloc.y + 30);
+ // PlafUtils.setWindowsLook(this);
+ this.sichtgruppe = sichtgruppe;
+
+ setNorth(new TitlePanel("Auswahl " + name));
+ initCenter(erläuterung);
+
+ JButton btnSuchen = new JButton("Suchen");
+ btnSuchen.setFont(fontBtns);
+ btnSuchen.addActionListener(new SuchenListener());
+ addAboveOK(btnSuchen);
+
+ for (Iterator it = sichtgruppe.iterator(); it.hasNext();) {
+ SichtApplet aSicht = (SichtApplet) it.next();
+ aSicht.addMouseListener(mouseList);
+ }
+
+ this.setSize(700, 500);
+
+ }
+
+ private void initCenter(String erläuterung) throws SQLException, DBServletException, KeyParentEqualException, CloneNotSupportedException, NoMainEntryException {
+ JSplitPane jsp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+ erlScrollP = new JScrollPane(erlPane);
+ // erlScrollP.setMaximumSize(new Dimension(500,300));
+ jsp.add(erlScrollP);
+ erlPane.setText(erläuterung);
+ erlPane.setEditable(false);
+ if (erläuterung == null || erläuterung.trim().equals(""))
+ erlScrollP.setVisible(false);
+
+ jsp.setDividerLocation(250);
+
+ VerticalBox vbox = new VerticalBox();
+ auswahlPanel = new JPanel();
+ lblStand = new JLabel();
+
+ lblStand.setFont(fontBtns);
+ bStand = new JButton("anderer Stand");
+ bStand.setFont(fontBtns);
+ bStand.setDefaultCapable(false);
+ bStand.addActionListener(new StandListener());
+ auswahlPanel.add(lblStand);
+ auswahlPanel.add(bStand);
+ vbox.add(auswahlPanel);
+ cbSichten = new LabeledComboBox("Sicht", sichtgruppe.getSichtenlist());
+
+ cbSichten.addActionListener(changeListener);
+ if (sichtgruppe.getSelectedSicht() != null) {
+ cbSichten.setSelectedItem(sichtgruppe.getSelectedSicht());
+ } else {
+ cbSichten.setSelectedIndex(0);
+ sichtgruppe.setSelectedSicht((SichtApplet) cbSichten
+ .getSelectedItem());
+ try {
+ sichtgruppe.makeSureSelectedSichtIsOK(new Hashtable(),new HashMap(),new FieldContainer());
+ }
+ catch (Exception e)
+ {
+ throw new SQLException(e.toString());
+ }
+ }
+ auswahlPanel.add(cbSichten);
+ if (sichtgruppe.size() < 2)
+ cbSichten.setVisible(false);
+ lblStand.setText("Stand: "
+ + sichtgruppe.getSelectedSicht().getStand());
+ standAmAnfang = sichtgruppe.getSelectedSicht().getStand();
+ vbox.add(treeScroll);
+ jsp.add(vbox);
+ setCenter(jsp);
+
+ }
+
+ private void updateStandVisibility() {
+ if (sichtgruppe.getSelectedSicht().isStandbuttonWanted()) {
+ lblStand.setVisible(true);
+ bStand.setVisible(true);
+ } else {
+ lblStand.setVisible(false);
+ bStand.setVisible(false);
+ }
+
+ }
+
+ public void standAendern() throws SQLException, DBServletException,
+ KeyParentEqualException, CloneNotSupportedException, NoMainEntryException {
+ DateFormat df;
+ String neuerStand = JOptionPane
+ .showInputDialog(this, "Neues Datum eingeben:", "SuperX",
+ JOptionPane.QUESTION_MESSAGE);
+ if (neuerStand == null)
+ return;
+ df = DateFormat.getDateInstance(DateFormat.MEDIUM);
+ // r.b. default Jahr 4-stellig
+ df.setTimeZone(TimeZone.getDefault());
+ df.setLenient(false);
+ String geprueft = null;
+ java.sql.Date adate = null;
+ try {
+ if (neuerStand.endsWith("00")) {
+ switch (neuerStand.charAt(neuerStand.length() - 3)) {
+ case '-':
+ case '.':
+ case '/':
+ neuerStand = neuerStand.substring(0,
+ neuerStand.length() - 2)
+ + "2000";
+ break;
+ }
+ }
+
+ java.util.Date date = df.parse(neuerStand);
+ Calendar calendar = Calendar.getInstance();
+ calendar.setTime(date);
+ int year = calendar.get(Calendar.YEAR);
+ if (year >= 0 && year < 30)
+ calendar.add(Calendar.YEAR, 2000);
+ if (year >= 30 && year < 100)
+ calendar.add(Calendar.YEAR, 1900);
+
+ adate = new java.sql.Date(calendar.getTime().getTime());
+
+ // wenn Format nicht OK bleibt geprueft null
+ geprueft = df.format((java.util.Date) adate);
+
+ } catch (ParseException e_parse) {
+ // System.err.println ("SxDate: ERROR: parse: Date != " + value);
+ } catch (IllegalArgumentException e_arg) {
+ // System.err.println ("SxDate: ERROR: arg: Date != " + value);
+ }
+ if (geprueft != null && adate != null
+ && !SuperX.isZukünftigerStandErlaubt) {
+ if (DateUtils.isDateInFuture((Date) adate)) {
+ WarningMessage.show(this,
+ "Das Datum darf nicht in der Zukunft liegen", "SuperX");
+ geprueft = null;
+ }
+ }
+ if (geprueft != null) // Form Ok
+ {
+ WindowUtils.setWaitCursor(this, true);
+ lblStand.setText("Stand: " + neuerStand);
+ try {
+ sichtgruppe.setStand(new Hashtable(),new HashMap(),new FieldContainer(),neuerStand);
+ }
+ catch (Exception e)
+ {
+ throw new SQLException(e.toString());
+ }
+ WindowUtils.setWaitCursor(this, false);
+ isStandChanged = true;
+ } else
+ JOptionPane.showMessageDialog(null, "Ungültige Eingabe!", "SuperX",
+ JOptionPane.ERROR_MESSAGE);
+
+ }
+
+ public LinkedList getSelections() {
+ return selections;
+ }
+
+ private void suchen() {
+ String such = JOptionPane.showInputDialog(null, "Suche:", "SuperX",
+ JOptionPane.QUESTION_MESSAGE);
+ if (such == null || such.length() < 1)
+ return;
+ such = such.toLowerCase();
+ SichtApplet sicht = (SichtApplet) sichtgruppe.getSelectedSicht();
+ sicht.searchEntries(such);
+ }
+
+ protected void performOk() {
+
+ try {
+ removeMouseListener(sichtgruppe, mouseList);
+ SichtApplet sicht = (SichtApplet) sichtgruppe
+ .getSelectedSicht();
+ if (sicht.getSelectionCount() == 0) {
+ SelectableItem selectedItem = new SelectableItem("-1", "");
+ selectedItem.setAllowed(false);
+ selections.add(selectedItem);
+ } else
+
+ for (int i = 0; i < sicht.getSelectionCount(); i++) {
+ DefaultMutableTreeNode selNode = (DefaultMutableTreeNode) sicht
+ .getSelectionPaths()[i].getLastPathComponent();
+ if (!(selNode.getUserObject() instanceof SelectableItem)) {
+ performClear();
+ break;
+ } else {
+ SelectableItem selectedItem = (SelectableItem) selNode
+ .getUserObject();
+ selections.add(selectedItem);
+ }
+
+ }
+ } catch (Exception e) {
+ WarningMessage.show(this, "Fehler\n" + e, "SuperX");
+ e.printStackTrace();
+ }
+
+ this.setVisible(false);
+ this.dispose();
+ }
+
+ protected void performCancel() {
+ removeMouseListener(sichtgruppe, mouseList);
+ /*
+ * if (!sichtgruppe.getLastSelectedSicht().getStand()
+ * .equals(standAmAnfang)) { WindowUtils.setWaitCursor(this, true); try {
+ * sichtgruppe.setStand(standAmAnfang); } catch (Exception e) {
+ * WarningMessage.show(this, "Stand konnte nicht geändert werden.\n" +
+ * e, "SuperX"); e.printStackTrace(); } WindowUtils.setWaitCursor(this,
+ * false); }
+ */
+ selections.clear();
+ this.setVisible(false);
+ this.dispose();
+ }
+
+ protected void performClear() {
+ removeMouseListener(sichtgruppe, mouseList);
+ if (sichtgruppe != null)
+ sichtgruppe.getSelectedSicht().clearSelection();
+ SelectableItem selectedItem = new SelectableItem("null", "");
+ selectedItem.setAllowed(false);
+ selections.add(selectedItem);
+ this.setVisible(false);
+ this.dispose();
+ }
+
+ public void configure(String gewünschterStand) {
+ try {
+ sichtgruppe.setStand(new Hashtable(),new HashMap(),new FieldContainer(),gewünschterStand);
+ } catch (Exception e) {
+ WarningMessage.show(this, "Stand konnte nicht geändert werden.\n"
+ + e, "SuperX");
+ e.printStackTrace();
+ }
+
+ }
+
+ private void removeMouseListener(Sichtgruppe sichtgruppe,
+ MouseListener mouseList) {
+ for (Iterator it = sichtgruppe.iterator(); it.hasNext();) {
+ SichtApplet aSicht = (SichtApplet) it.next();
+ try {
+ aSicht.removeMouseListener(mouseList);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ private void setCursor(boolean b) {
+ WindowUtils.setWaitCursor(this, b);
+ }
+
+ class StandListener implements ActionListener {
+ public void actionPerformed(ActionEvent event) {
+ try {
+ standAendern();
+ } catch (Exception e) {
+ WarningMessage.show(null,
+ "Stand konnte nicht geändert werden.\n" + e, "SuperX");
+ e.printStackTrace();
+ }
+ }
+ }
+
+ class SuchenListener implements ActionListener {
+ public void actionPerformed(ActionEvent event) {
+ suchen();
+ }
+ }
+
+ class SichtenChangeListener implements ActionListener {
+ public void actionPerformed(ActionEvent e) {
+ setCursor(true);
+ SichtApplet newSicht = (SichtApplet) cbSichten.getSelectedItem();
+ sichtgruppe.setSelectedSicht(newSicht);
+
+ try {
+ sichtgruppe.makeSureSelectedSichtIsOK(new Hashtable(),new HashMap(),new FieldContainer());
+ treeScroll.setViewportView(newSicht);
+ } catch (Exception e1) {
+ WarningMessage.show(null, "Fehler.\n" + e, "SuperX");
+ e1.printStackTrace();
+ }
+ updateStandVisibility();
+ setCursor(false);
+ }
+ }
+
+ /*
+ * Ausgebaut wegen Alt.Hier Problemen
+ */
+ class SxTreeDlgMouseListener extends MouseAdapter {
+ SxTreeDlgMouseListener() {
+ }
+
+ public void mousePressed(MouseEvent e) {
+ if (e.getClickCount() == 2) {
+ // performOk();
+ }
+ }
+ }
+
+ public boolean isStandChanged() {
+ return isStandChanged;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/applet/SxUtils.java b/src/de/superx/applet/SxUtils.java
new file mode 100644
index 0000000..e6af13f
--- /dev/null
+++ b/src/de/superx/applet/SxUtils.java
@@ -0,0 +1,562 @@
+package de.superx.applet;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Properties;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.StringUtils;
+import de.memtext.widgets.WarningMessage;
+
+//SxNew mit superx.util.SqlStringUtils vergleichen und diese Klasse
+/**
+ * Die Klasse SxUtils führt String-Operationen zur Vorbereitung von
+ * Datenbank-Transaktionen durch
+ *
+ * @deprecated
+ * @author R.Behr modified by Marlies Winterstein
+ * @version 2.0, 5 Jan 1998 - 0.9, 31 July 1998 modified 01-2002
+ *
+ */
+public class SxUtils {
+ public final static int bufSize = 32 * 1024;
+ public final static String errString = "--ERROR--";
+
+ private static String COMM_START = "/*";
+ private static String COMM_END = "*/";
+
+ private static int COMM_START_LEN = COMM_START.length();
+ private static int COMM_END_LEN = COMM_END.length();
+
+ private static String COMMENT1_ANF = "{";
+ private static String COMMENT1_END = "}";
+ private static String COMMENT2_ANF = "--";
+ private static String COMMENT2_END = "\n";
+ private static String COMMENT3_ANF = "/*";
+ private static String COMMENT3_END = "*/";
+ private static String COMMENT1_ANF_MASK = "#K#";
+ private static String COMMENT1_END_MASK = "#/K";
+ private static String COMMENT2_ANF_MASK = "#S#";
+ private static String COMMENT2_END_MASK = "#/S#";
+ private static String COMMENT3_ANF_MASK = "#*A#";
+ private static String COMMENT3_END_MASK = "#*E#";
+ private static String PREV_POS = ">>";
+ private static String PREV_POS_MASK = ">#>";
+ private static String NEXT_POS = "<<";
+ private static String NEXT_POS_MASK = "<#<";
+ private static String SELECT_DELIMITER = ";";
+ private static String SELECT_DELIMITER_MASK = "^";
+ private static String STR_DELIMITER1 = "\"";
+ private static String STR_DELIMITER1_MASK = "#s1#";
+ private static String STR_DELIMITER2 = "'";
+ private static String STR_DELIMITER2_MASK = "#s2#";
+
+ private static StringBuffer buffer;
+ private static String prev_str;
+
+ static {
+ buffer = new StringBuffer(bufSize);
+ }
+
+ public synchronized static void setFieldDelimiter(String field_start,
+ String field_end) {
+ if (field_start != null) {
+ if (field_start.length() == 0)
+ NEXT_POS = "";
+ else
+ NEXT_POS = field_start.substring(0, field_start.length() - 1);
+ }
+
+ if (field_end != null) {
+ if (field_end.length() == 0)
+ PREV_POS = "";
+ else
+ PREV_POS = field_end.substring(0, field_end.length() - 1);
+ }
+ }
+
+ public static String getFieldPrefix() {
+ return new String(NEXT_POS);
+ }
+
+ public static String getFieldSuffix() {
+ return new String(PREV_POS);
+ }
+
+ public synchronized static void setComment(String comm_start,
+ String comm_end) {
+ if (comm_start != null) {
+ COMM_START = comm_start;
+ COMM_START_LEN = comm_start.length();
+ }
+ if (comm_end != null) {
+ COMM_END = comm_end;
+ COMM_END_LEN = comm_end.length();
+ }
+ }
+
+ private static String noappletout(String sql_str) {
+ while (sql_str != null && sql_str.indexOf("--notinapplet") > -1) {
+ int pos = sql_str.indexOf("--notinapplet");
+ String prev = sql_str.substring(0, pos);
+ if (prev.lastIndexOf("/*") == -1)
+ throw new IllegalStateException(
+ "--notinapplet muss eingeschlossen sein von /* */, nicht "
+ + sql_str);
+ prev = prev.substring(0, prev.lastIndexOf("/*") - 1);
+ if (sql_str.indexOf(("*/"), pos) == -1)
+ throw new IllegalStateException(
+ "--notinapplet muss eingeschlossen sein von /* */, nicht "
+ + sql_str);
+
+ String post = sql_str.substring(sql_str.indexOf(("*/"), pos) + 2);
+ sql_str = prev + "\n" + post;
+ }
+ return sql_str;
+ }
+
+ static synchronized String generateSQL(SxForm sxform, String sqlStatement) {
+ Object obj = null;
+ sqlStatement = noappletout(sqlStatement);
+ sqlStatement = replace(sqlStatement, "<>",
+ sxform.isErlaubt() ? "1" : "0");
+ Hashtable hashtable = sxform.getMap();
+ for (Enumeration enumeration = hashtable.keys(); enumeration
+ .hasMoreElements();) {
+ String fieldname = (String) enumeration.nextElement();
+ if (fieldname.startsWith("F_")) {
+ SxField sxField = sxform.getField(fieldname);
+ String fieldKey = sxform.getFieldKey("F_"
+ + fieldname.substring(2));
+ //kommt was anderes raus : //fieldKey =
+ // sxField.getKey().toString();
+ if (fieldKey != null) {
+ sqlStatement = replace(sqlStatement, getFieldPrefix()
+ + fieldname.substring(2) + getFieldSuffix(),
+ fieldKey);
+ }
+ if (sxField.hasSichten()) {
+ SichtApplet sicht = sxField.getSelectedSicht();
+ sqlStatement = replace(sqlStatement, "<<" + sicht.getArt()
+ + ">>", sicht.getId().toString());
+ //z.B. beim ersetzen von <>
+ // und <>
+ //wäre sonst beides <>
+ sqlStatement = replace(sqlStatement, "<<"
+ + sxField.getName().substring(2) + "-Sicht>>",
+ sicht.getId().toString());
+
+ String sx_db = (String) SxDefaults.getPropertyValue("SxDB");
+ java.util.Date date = null;
+ try {
+ date = DateUtils.parse(sicht.getStand());
+ } catch (ParseException e) {
+ e.printStackTrace();
+ WarningMessage
+ .show(
+ null,
+ "Datum "
+ + sicht.getStand()
+ + " der Sicht konnte nicht interpretiert werden",
+ "SuperX");
+ }
+ String replaceStr = null;
+ if (sx_db.equals("Postgres"))
+ replaceStr = "date_val('"
+ + DateUtils.formatGerman(date) + "')";
+ else
+ replaceStr = "date('" + DateUtils.formatGerman(date)
+ + "')";
+
+ String search = "<<" + sicht.getArt()
+
+ + "Stand>>";
+ sqlStatement = replace(sqlStatement, search, replaceStr);
+ if (sicht.getArt() != null
+ && sicht.getArt().endsWith("Sicht")) {
+ search = "<<"
+ + StringUtils.removeFromEnd(sicht.getArt(),
+ "Sicht", true) + "Stand>>";
+ sqlStatement = replace(sqlStatement, search, replaceStr);
+ }
+ search = "<<" + sxField.getName().substring(2) + "-Stand>>";
+ sqlStatement = replace(sqlStatement, search, replaceStr);
+
+ }
+ }
+ }
+
+ String sx_db = (String) SxDefaults.getPropertyValue("SxDB");
+ String replaceStr = "IDS";
+ if (sx_db.equals("Postgres"))
+ replaceStr = "PG";
+
+ sqlStatement = sqlStatement.replaceAll("<>", replaceStr);
+ // falls jetzt noch Organigramm-Stand übrig, nicht durch Sicht ersetzt,
+ // also today()
+ sqlStatement = sqlStatement.replaceAll("<>",
+ "today()");
+
+ //MB 07/2010 macht Probleme bei Freemarker hashes
+ // MB 10/2013 wieder aktiviert, bei {" drin lassen für Hashes
+ sqlStatement = deleteComment(sqlStatement, "{", "}");
+
+ sqlStatement = deleteComment(sqlStatement, "/*", "*/");
+ sqlStatement = deleteComment(sqlStatement, "--", "\n");
+ int i = 1;
+ return sqlStatement;
+ }
+
+ /**
+ * Kommentare werden gelöscht Für FreeMarker ist es problematisch dass {...}
+ * als Kommentar gelöscht wird, weil Variablen so definiert werden
+ * ${varname}. Änderung der Methode, dass {...} nur gelöscht wird, wenn das
+ * vorherige Zeichen kein $ ist
+ *
+ * @param str
+ * @param comm_start_str
+ * @param comm_end_str
+ * @deprecated original in SqlStringUtils
+ * @return
+ */
+ private static String deleteComment(String str, String comm_start_str,
+ String comm_end_str) {
+ String search_str = comm_start_str;
+
+ int comm_end = -1;
+ int pos = -1;
+ int offset = 0;
+ int len = str.length();
+ int search_len = search_str.length();
+
+ StringBuffer lbuffer = new StringBuffer();
+ while (offset < len) {
+ pos = str.indexOf(search_str, offset);
+ if (pos != -1) {
+ if (pos > 0 && comm_start_str.equals("{")
+ && (str.charAt(pos - 1) == '$'
+ //MB 16.10.13 folgendes Zeichen nicht " das sorgt dafür das Hashes erkannt bleiben
+ ||str.charAt(pos+1)=='"')
+ ) {
+ lbuffer.append(str.substring(offset, pos + 1));
+ offset = pos + 1;
+ continue;
+ }
+ prev_str = str.substring(offset, pos);
+ comm_end = str.indexOf(comm_end_str, pos + search_len);
+ //wenn kein Kommentar-Ende gefunden
+ //wird String Ende das Kommentar-Ende sein
+ if (comm_end == -1)
+ comm_end = str.length() - 1;
+ lbuffer.append(prev_str);
+ offset = comm_end + comm_end_str.length();
+ } else {
+ lbuffer.append(str.substring(offset, len));
+ offset = len;
+ }
+ }
+
+ return lbuffer.toString();
+ }
+
+ public synchronized static String replace(String str, String search_str,
+ String replace_str) {
+ String return_str;
+ boolean delete_comment = false;
+
+ int pos = -1;
+ int offset = 0;
+ int len = str.length();
+ int search_len = search_str.length();
+ int comm_start = -1;
+ int comm_end = -1;
+ int prev_pos = -1;
+ int next_pos = -1;
+ int mode = -1;
+
+ // mode: 0 = kein Kommentar,
+ // 1 = Kommentar loeschen mit Ersetzung,
+ // 2 = Loeschen von COMM_START bis COMM_END
+
+ try {
+ delete_comment = replace_str.equals("");
+
+ while (offset < len) {
+ mode = -1;
+
+ if ((pos = str.indexOf(search_str, offset)) != -1) {
+ prev_str = str.substring(offset, pos);
+ comm_start = prev_str.lastIndexOf(COMM_START);
+ prev_pos = prev_str.lastIndexOf(PREV_POS);
+ comm_end = str.indexOf(COMM_END, pos + search_len);
+ next_pos = str.indexOf(NEXT_POS, pos + search_len);
+
+ if (comm_start >= 0 && prev_pos >= 0) // kein Kommentar
+ if (comm_start < prev_pos)
+ comm_start = -1;
+ if (comm_end >= 0 && next_pos >= 0) // kein Kommentar
+ if (comm_end > next_pos)
+ comm_end = -1;
+
+ if (comm_start != -1 && comm_end != -1 && comm_start <= pos
+ && comm_end >= pos) {
+ if (delete_comment) // keine Ersetzung,
+ mode = 2; // Loeschen von '/*' - '*/'
+ else
+ mode = 1;
+ } else
+ mode = 0;
+
+ switch (mode) {
+ case 0: {
+ buffer.append(prev_str);
+ buffer.append(replace_str);
+ offset = pos + search_len;
+ break;
+ }
+ case 1: {
+ buffer.append(prev_str.substring(0, comm_start));
+ buffer.append(prev_str.substring(comm_start
+ + COMM_START_LEN));
+ buffer.append(replace_str);
+ buffer
+ .append(str.substring(pos + search_len,
+ comm_end));
+ offset = comm_end + COMM_END_LEN;
+ break;
+ }
+ case 2: {
+ buffer.append(prev_str.substring(0, comm_start));
+ offset = comm_end + COMM_END_LEN;
+ break;
+ }
+ default:
+ throw new Exception(errString);
+ }
+ } else {
+ buffer.append(str.substring(offset, len));
+ offset = len;
+ }
+ }
+
+ } catch (Exception e) {
+ buffer.append(errString);
+ buffer.append(search_str);
+ }
+
+ return_str = buffer.toString();
+ buffer.setLength(0);
+
+ return return_str;
+ }
+
+ public synchronized static String replaceString(String str,
+ String search_str, String replace_str) {
+ String zs = "";
+ int offset = 0;
+ int pos = str.indexOf(search_str, offset);
+ while (pos > -1) {
+ zs += str.substring(offset, pos);
+ zs += replace_str;
+ offset = pos + search_str.length();
+ pos = str.indexOf(search_str, offset);
+ }
+ zs += str.substring(offset, str.length());
+ return zs;
+ }
+
+ public synchronized static String escapeString(String str) {
+ String escapeString;
+ str = replaceString(str, PREV_POS, PREV_POS_MASK);
+ str = replaceString(str, NEXT_POS, NEXT_POS_MASK);
+ str = replaceString(str, SELECT_DELIMITER, SELECT_DELIMITER_MASK);
+ str = replaceString(str, STR_DELIMITER1, STR_DELIMITER1_MASK);
+ str = replaceString(str, STR_DELIMITER2, STR_DELIMITER2_MASK);
+ str = replaceString(str, COMMENT1_ANF, COMMENT1_ANF_MASK);
+ str = replaceString(str, COMMENT2_ANF, COMMENT2_ANF_MASK);
+ str = replaceString(str, COMMENT3_ANF, COMMENT3_ANF_MASK);
+ str = replaceString(str, COMMENT1_END, COMMENT1_END_MASK);
+ //str=replaceString(str,COMMENT2_END,COMMENT2_END_MASK);
+ str = replaceString(str, COMMENT3_END, COMMENT3_END_MASK);
+ escapeString = str;
+ return escapeString;
+ }
+
+ public synchronized static String unescapeString(String str) {
+ String unescapeString;
+ str = replaceString(str, PREV_POS_MASK, PREV_POS);
+ str = replaceString(str, NEXT_POS_MASK, NEXT_POS);
+ //str=replaceString(str,SELECT_DELIMITER_MASK, SELECT_DELIMITER);
+ str = replaceString(str, STR_DELIMITER1_MASK, STR_DELIMITER1);
+ str = replaceString(str, STR_DELIMITER2_MASK, "\\'");
+ //STR_DELIMITER2);
+ str = replaceString(str, COMMENT1_ANF_MASK, COMMENT1_ANF);
+ str = replaceString(str, COMMENT2_ANF_MASK, COMMENT2_ANF);
+ str = replaceString(str, COMMENT3_ANF_MASK, COMMENT3_ANF);
+ str = replaceString(str, COMMENT1_END_MASK, COMMENT1_END);
+ str = replaceString(str, COMMENT3_END_MASK, COMMENT3_END);
+ unescapeString = str;
+ return unescapeString;
+ }
+
+ public synchronized static String escapeSpecialChars(String str) {
+ String escapeSpecialChars;
+ str = replaceString(str, SELECT_DELIMITER, "\\" + SELECT_DELIMITER);
+ str = replaceString(str, STR_DELIMITER1, "\\" + STR_DELIMITER1);
+ str = replaceString(str, STR_DELIMITER2, "\\" + STR_DELIMITER2);
+ //str=replaceString(str,"\\","\\\\");
+ //str=replaceString(str,"%","\\%");
+ escapeSpecialChars = str;
+ return escapeSpecialChars;
+ }
+
+ public synchronized static String getValueAsString(Object value) {
+ String field_type = "";
+ String f_wert = "";
+ String fehler = "";
+ try {
+ if ((value instanceof java.sql.Date)) {
+ f_wert = ""
+ + DateFormat.getDateInstance(DateFormat.MEDIUM,
+ Locale.GERMANY).format(value);
+ //System.out.println(f_wert);
+ } else {
+ if (value instanceof java.sql.Timestamp) {
+ //System.out.println(value.toString());
+ f_wert = ""
+ + DateFormat.getDateTimeInstance(DateFormat.MEDIUM,
+ DateFormat.MEDIUM, Locale.GERMANY).format(
+ value);
+ } else {
+ if (value instanceof java.sql.Time)
+ f_wert = ""
+ + DateFormat.getTimeInstance(DateFormat.MEDIUM,
+ Locale.GERMANY).format(value);
+
+ else
+ //default:
+ f_wert = value.toString();
+ }
+ }
+ } catch (Exception e) {
+ fehler = e.toString();
+ if (fehler.equals("java.lang.NullPointerException"))
+ f_wert = "";
+ else
+ f_wert = "Feldtyp unbekannt:" + fehler;
+ }
+ return f_wert;
+ }
+
+ /*
+ * public synchronized static String getRelationString (String feldart,
+ * String relation, String attribut) { String stmt=relation; if
+ * (stmt.startsWith (" < >")) { stmt = stmt.substring (7); }
+ *
+ * if(attribut.trim().equals("")==false) { if (attribut.indexOf (',') == -1)
+ * attribut = "tid, " + attribut; stmt = "select " + attribut + " from " +
+ * relation + " order by 2"; }
+ *
+ * if (feldart.equals("4")) { //Hier fehlt noch userrechte und
+ * lehre-Einschränkung stmt = "SELECT organigramm.parent,
+ * organigramm.key_apnr, organigramm.name FROM organigramm WHERE
+ * gueltig_seit now() ORDER BY organigramm.name;"; }
+ * if (feldart.equals("6") ) { //6-Institutionsdialog für Lehreinheiten stmt =
+ * "SELECT organigramm.parent, organigramm.key_apnr, organigramm.name FROM
+ * organigramm WHERE gueltig_seit now() ORDER BY
+ * organigramm.name;"; } if (feldart.equals("7") ) { //7-Institutionsdialog
+ * für Lehreinheiten ohne Einschr. Userrechte stmt = "SELECT
+ * organigramm.parent, organigramm.key_apnr, organigramm.name FROM
+ * organigramm WHERE gueltig_seit now() ORDER BY
+ * organigramm.name;"; } String RelationString=stmt; return RelationString; }
+ */
+
+ public static void main(String args[]) {
+ System.out
+ .println(noappletout("11764^Projekt^4^0^0^100^300^1^char^4^0^1^<> /* execute procedure sp_user_orga_child(<>,mdy (1, 1,year(<>)),<>,<>, <>); --notinxmlfrontend */ /* execute procedure sp_user_orga(<>,mdy (1, 1,year<>)),<>); --notinapplet */ select distinct fb, fb || "
+ + " || ktobez from mbs_projekte_konto where 1=1 and inst_nr in (select ch110_institut from tmp_ch110_institut) /* and dr in (<>) */ /* and jahr = <> */ /* and kap in (<>) */ order by 2;^ ^^"));
+ System.exit(1);
+ String sql_str = null;
+ String search_str = null;
+ String replace_str = null;
+ Properties props = new Properties();
+
+ if (args.length != 2) {
+ System.err.println("Usage: ");
+ System.exit(1);
+ }
+
+ String filename = "/" + args[0];
+ String propname = "/" + args[1];
+
+ try {
+ byte[] buf = new byte[bufSize];
+ byte[] data = new byte[bufSize];
+ int read_len = 0, data_len = 0;
+
+ InputStream is = props.getClass().getResourceAsStream(filename);
+ if (is == null) {
+ System.err.println("Resource '" + filename + "' not found");
+ System.exit(1);
+ }
+
+ while (read_len != -1) {
+ read_len = is.read(buf, 0, buf.length);
+ if (read_len != -1)
+ data_len = read_len;
+ }
+
+ is.close();
+
+ data = new byte[data_len];
+ System.arraycopy(buf, 0, data, 0, data_len);
+
+ sql_str = new String(data);
+
+ is = props.getClass().getResourceAsStream(propname);
+ if (is == null) {
+ System.err.println("Resource '" + propname + "' not found");
+ System.exit(1);
+ }
+
+ props.load(is);
+ is.close();
+
+ Enumeration en = props.propertyNames();
+ String key;
+ String value;
+
+ System.err.println("sql ... ");
+
+ while (en.hasMoreElements()) {
+ key = (String) en.nextElement();
+ value = (String) props.getProperty(key);
+ key = "<<" + key + ">>";
+ System.err.println("Key: " + key + " = " + value);
+ sql_str = SxUtils.replace(sql_str, key, value);
+ }
+ //MB 07/2010 macht Probleme bei Freemarker hashes
+ // sql_str = SxUtils.deleteComment(sql_str, "{", "}");
+ sql_str = SxUtils.deleteComment(sql_str, "--", "\n");
+ sql_str = SxUtils.deleteComment(sql_str, "/*", "*/");
+ } catch (FileNotFoundException e) {
+ System.err.println(e);
+ System.exit(1);
+ } catch (SecurityException e) {
+ System.err.println(e);
+ System.exit(1);
+ } catch (IOException e) {
+ System.err.println(e);
+ System.exit(1);
+ }
+
+ System.err.println("done");
+ }
+
+}
diff --git a/src/de/superx/applet/SxWaitCursor.java b/src/de/superx/applet/SxWaitCursor.java
new file mode 100644
index 0000000..4c3a3be
--- /dev/null
+++ b/src/de/superx/applet/SxWaitCursor.java
@@ -0,0 +1,28 @@
+package de.superx.applet;
+import java.awt.Container;
+import java.awt.Cursor;
+
+import javax.swing.JComponent;
+/**
+ * Den Cursor einer Komponente auf WAIT bzw. DEFAULT setzen.
+ *
+ * @version 1.0
+ * @author Rainer Behr
+ */
+
+public class SxWaitCursor
+{
+
+ public static void set(JComponent comp, boolean isWait)
+ {
+ Container toplevel = comp.getTopLevelAncestor ();
+ if (toplevel != null)
+ {
+ if (isWait)
+ toplevel.setCursor (new Cursor (Cursor.WAIT_CURSOR));
+ else
+ toplevel.setCursor (new Cursor (Cursor.DEFAULT_CURSOR));
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/AbstractWebserviceClient.java b/src/de/superx/bin/AbstractWebserviceClient.java
new file mode 100644
index 0000000..17b98e2
--- /dev/null
+++ b/src/de/superx/bin/AbstractWebserviceClient.java
@@ -0,0 +1,257 @@
+package de.superx.bin;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.net.Authenticator.RequestorType;
+import java.nio.charset.Charset;
+import java.util.logging.Logger;
+
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.SOAPConnection;
+import javax.xml.soap.SOAPConnectionFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+
+public class AbstractWebserviceClient {
+ int pause = 0;
+ boolean isDeleteTmpXmlFileWanted = true;
+
+ public AbstractWebserviceClient() {
+
+ Authenticator.setDefault(new Authenticator() {
+ @Override
+ protected PasswordAuthentication getPasswordAuthentication() {
+ if (getRequestorType() == RequestorType.PROXY) {
+ String prot = getRequestingProtocol().toLowerCase();
+ String host = System.getProperty(prot + ".proxyHost", "");
+ String port = System.getProperty(prot + ".proxyPort", "");
+ String user = System.getProperty(prot + ".proxyUser", "");
+ String password = System.getProperty(prot
+ + ".proxyPassword", "");
+
+ if (getRequestingHost().toLowerCase().equals(
+ host.toLowerCase())) {
+ if (Integer.parseInt(port) == getRequestingPort()) {
+ // Seems to be OK.
+ return new PasswordAuthentication(user, password
+ .toCharArray());
+ }
+ }
+ }
+ return null;
+ }
+ });
+ }
+
+ /**
+ * macht bei Netzwerkproblemen vier Versuche
+ *
+ * @param soapxml
+ * @param url
+ * @return
+ * @throws Exception
+ */
+ protected StringBuffer readSOAP(String soapxml, String url)
+ throws Exception {
+ int attempt = 1;
+ boolean allDone = false;
+ StringWriter sw = null;
+ Exception exception = null;
+ while (allDone == false && attempt < 4) {
+ try {
+ sw = new StringWriter();
+ if (pause > 0) {
+ Thread.sleep(pause * 1000);
+ // System.out.println("pause "+pause);
+ }
+ SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory
+ .newInstance();
+ SOAPConnection soapConnection = soapConnectionFactory
+ .createConnection();
+
+ SOAPMessage sr = getSoapMessageFromString(soapxml);
+ sr.getMimeHeaders().addHeader("SOAPAction",
+ "http://sap.com/xi/WebService/soap1.1");
+
+ SOAPMessage soapResponse = soapConnection.call(sr, url);
+
+ // soapResponse.writeTo(System.out);
+
+ Transformer transformer = TransformerFactory.newInstance()
+ .newTransformer();
+ // optional indenting
+ transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+ transformer.setOutputProperty(
+ "{http://xml.apache.org/xslt}indent-amount", "2");
+
+ // File tmpF = File.createTempFile("soapdata", ".xml");
+ transformer.transform(
+ new DOMSource(soapResponse.getSOAPPart()),
+ new StreamResult(sw));
+
+ soapConnection.close();
+ System.gc();
+ // if (attempt < 3) throw new RuntimeException("RUntime");
+ // StringBuffer result=readFile(tmpF);
+ // if (isDeleteTmpXmlFileWanted) tmpF.delete();
+ // else System.out.println(" tmp File "+tmpF);
+ allDone = true;
+ } catch (Exception e) {
+ exception = e;
+ System.out
+ .println(DateUtils.getNowString()
+ + " Aufruf fehlgeschlagen (s. WebserviceLog) - versuche erneut");
+ StringWriter swException = new StringWriter();
+ PrintWriter pw = new PrintWriter(swException);
+ e.printStackTrace(pw);
+
+ Logger.getLogger("wc").severe(
+ " Problem bei Aufruf von " + url + "\n" + soapxml
+ + "\n" + swException.toString());
+ attempt++;
+
+ }
+ }
+ if (allDone == false)
+ throw exception;
+ StringBuffer result = new StringBuffer(sw.toString());
+ return result;
+ }
+
+ protected File createSoapFile(String soapxml, String url) throws Exception {
+ int attempt = 1;
+ boolean allDone = false;
+
+ Exception exception = null;
+ File tmpF = File.createTempFile("soapdata", ".xml");
+ while (allDone == false && attempt < 4) {
+ try {
+ if (tmpF.exists())
+ tmpF.delete();
+
+ if (pause > 0) {
+ Thread.sleep(pause * 1000);
+ // System.out.println("pause "+pause);
+ }
+ SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory
+ .newInstance();
+ SOAPConnection soapConnection = soapConnectionFactory
+ .createConnection();
+
+ SOAPMessage sr = getSoapMessageFromString(soapxml);
+ sr.getMimeHeaders().addHeader("SOAPAction",
+ "http://sap.com/xi/WebService/soap1.1");
+
+ SOAPMessage soapResponse = soapConnection.call(sr, url);
+
+ Transformer transformer = TransformerFactory.newInstance()
+ .newTransformer();
+ // optional indenting
+ transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+ transformer.setOutputProperty(
+ "{http://xml.apache.org/xslt}indent-amount", "2");
+
+ transformer.transform(
+ new DOMSource(soapResponse.getSOAPPart()),
+ new StreamResult(tmpF));
+
+ soapConnection.close();
+ System.gc();
+ // if (attempt<3) throw new RuntimeException("runtime");
+ allDone = true;
+ } catch (Exception e) {
+ exception = e;
+ System.out
+ .println("\n"
+ + DateUtils.getNowString()
+ + " Aufruf fehlgeschlagen (s. WebserviceLog) - versuche erneut");
+ StringWriter swException = new StringWriter();
+ PrintWriter pw = new PrintWriter(swException);
+ e.printStackTrace(pw);
+
+ Logger.getLogger("wc").severe(
+ " Problem bei Aufruf von " + url + "\n" + soapxml
+ + "\n" + swException.toString());
+ attempt++;
+
+ }
+ }
+ if (allDone == false)
+ throw exception;
+ return tmpF;
+ }
+
+ private SOAPMessage getSoapMessageFromString(String xml)
+ throws SOAPException, IOException {
+ MessageFactory factory = MessageFactory.newInstance();
+ SOAPMessage message = factory
+ .createMessage(
+ new MimeHeaders(),
+ new ByteArrayInputStream(xml.getBytes(Charset
+ .forName("UTF-8"))));
+ return message;
+ }
+
+ /**
+ * Entferne unnötige Zeichen und EX_JEST Block
+ *
+ * @param data
+ * @return
+ */
+ static String purge(String data) {
+ data = XMLUtils.removeTroublesomeCharacters(data);
+
+ data = data.replaceAll("\u20AC", "EUR");
+
+ data = data.replaceAll("\u2013", "-");// dash
+
+ data = data.replaceAll("\u2026", "...");// ...
+ data = data.replace('^', ' ');
+ data = data.replaceAll("(?s).*", "");
+ data = data.replaceAll("", "");
+ data = data.replaceAll("", "");
+ return data;
+ }
+
+ String adaptURL(String url) {
+ String result = url;
+ if (System.getProperty("WS_HOST") != null)
+ result = url.replaceAll("WS_HOST", System.getProperty("WS_HOST"));
+ return result;
+ }
+
+ private StringBuffer readFile(File f) throws IOException {
+ FileReader fr = new FileReader(f);
+ BufferedReader bfr = new BufferedReader(fr);
+ String line;
+ StringBuffer result = new StringBuffer();
+ while ((line = bfr.readLine()) != null) {
+ result.append(line + "\n");
+
+ }
+ bfr.close();
+ fr.close();
+ return result;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/DelEndChar.java b/src/de/superx/bin/DelEndChar.java
new file mode 100644
index 0000000..431037e
--- /dev/null
+++ b/src/de/superx/bin/DelEndChar.java
@@ -0,0 +1,308 @@
+package de.superx.bin;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+
+import de.memtext.util.GetOpts;
+
+public class DelEndChar {
+
+/* Klassenvariablen */
+private static String _dateiPfad = "";
+private static String DELIMITER = "^";
+private static String _outDateiPfad="";
+private static String _tabelle="";
+/**
+ * Diese Klasse bereinigt die Zeilen der angegebenen ASCII-Dateien
+ * Es wird der letzte Delimiter-Zeichen aus jeder Zeile entfernt.
+ * Parameter:
+ * 1. Eingabe-Dateiname mit Pfadangabe
+ * 2. Ausgabe-Dateiname mit Pfadangabe
+ * 3. Delimiter-Zeichen(optional).
+ * 4. Tabellenname in der Datenbank, der auf Übereistimmung der Felderanzahl geprüft werden soll (optional).
+ * Defaultwert für Delimiter ist ^.
+ * Aufruf: java -cp .:../lib/superx-db.jar:../lib/<>.jar delEndChar
+ * @version 0.1 4.7.2003
+ * @author Eugen Ermantraut */
+ public DelEndChar() {
+ }
+ public static void main(String[] args)
+ {
+ DelEndChar r = new DelEndChar();
+ GetOpts.setOpts(args);
+ String isdrin= GetOpts.isAllRequiredOptionsPresent("-IN");
+ if(isdrin != null)
+ {
+ System.err.println("Datei-Pfade werden als Parameter erwartet. Folgende Optionen fehlen: " + isdrin);
+ r.zeige_hilfe();
+ System.exit(1);
+ }
+
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-IN"))
+ _dateiPfad=GetOpts.getValue("-IN" );
+ if (GetOpts.isPresent("-OUT"))
+ _outDateiPfad=GetOpts.getValue("-OUT" );
+ if (GetOpts.isPresent("-delim"))
+ DELIMITER=GetOpts.getValue("-delim" );
+ if (GetOpts.isPresent("-table"))
+ _tabelle=GetOpts.getValue("-table" );
+ if (args[0].toString().equals("?") ||
+ args[0].toString().equals("/?") ||
+ args[0].toString().equals("\\?") ||
+ args[0].toString().toLowerCase().equals("-h") ||
+ args[0].toString().toLowerCase().equals("--h") )
+ {
+ r.zeige_hilfe();
+ System.exit(1);
+ }
+
+
+ //if (r.check_param_ok(args))
+ //{
+ try
+ {
+ r.updateFile(r._dateiPfad, r._outDateiPfad);
+ System.out.println("Datei: " + r._dateiPfad + " nach " + r._outDateiPfad+ " umgesetzt");
+ }
+ catch (Exception e)
+ { System.err.println(e.toString());
+ }
+ //}
+
+ } // Ende der Methode
+
+
+ private void updateFile(String inDateiPfad, String outDateiPfad) throws IOException, Exception
+ {
+ File f = new File(inDateiPfad);
+ if (!f.exists())
+ { throw new Exception("Datei nicht gefunden: " + inDateiPfad);
+ }
+ BufferedReader in;
+ BufferedWriter out;
+ //--- File-Instanz für temporäre Ergebnis-Datei anlegen ---//
+ File out_tmp;
+ out_tmp = new File(inDateiPfad+".tmp2");
+ //--- IputStream und OutputStream generieren ---//
+ in = new BufferedReader(new InputStreamReader(
+ new FileInputStream(f) ));
+ //--- Output-Stream der tämporere Datei erzeugen ---//
+ out = new BufferedWriter( new OutputStreamWriter(
+ new FileOutputStream(out_tmp) ));
+
+ //--- Verarbeiten der Datei ---//
+ String text;
+ String tt;
+ text = in.readLine();
+ if(text!=null)
+ { //Datei nicht leer
+ if(text.endsWith("\\"))
+ {
+
+ tt=in.readLine();
+ if(tt!=null)
+ {
+ text+=tt;
+ while(tt.endsWith( "\\"))
+ {
+ tt= in.readLine();
+ if(tt != null) text +=tt+"\n"; //(tt.substring(0,tt.length()));
+ }
+ }
+ }
+ if(!_tabelle.equals("") && !_tabelle.equals("null") )
+ {
+ //Die Datei ist eine entladene Tabelle
+ //int start=_dateiPfad.indexOf("_",_dateiPfad.length()-4);
+ //if(start <0 )
+ // start=0;
+ // String tabname=_dateiPfad.substring(start,_dateiPfad.length()-4);
+ int numFelder=0;
+ //System.out.println("Tabelle "+_tabelle+ " DELIM " + DELIMITER);
+ try {
+ numFelder= SxDBUtils.fieldCount(_tabelle);
+ //System.out.println("Felderanzahl:"+numFelder);
+ }
+ catch (Exception e)
+ {
+ System.err.println("Fehler beim Abfragen der Tabellen-Metadaten: " + e.toString());
+ }
+ int k=0;
+ int i=0;
+ int p=0;
+ do
+ {
+ p=text.indexOf(DELIMITER,i);
+ if(p>0)
+ {
+ k++;
+ i=p+1;
+ }
+
+ }
+ while (p>0);
+ if(k!=numFelder)
+ { throw new Exception("unl-Datei entspricht nicht der Tabelle in der Datenbank;\nDie Tabelle hat "+numFelder+" Felder, die unl-Datei hat "+k +" Felder ");
+ }
+
+ } //Wenn Tabelle gecheckt werden sollte
+ do
+ {
+ if (text == null)
+ break;
+ if(text.endsWith("\\"))
+ {
+
+ tt= in.readLine();
+ if(tt != null)
+ {
+ text += tt;
+ while(tt != null && tt.endsWith( "\\"))
+ { //Umbrüche aus Informix-Lognvarchars abfangen
+ tt= in.readLine();
+ if(tt != null) text +=tt+"\n"; //(tt.substring(0,tt.length()));
+ }
+ }
+ }
+
+ text = reorgString(text.trim());
+ if (text == "-0") // Rohdatendatei Formatfehler
+ { throw new Exception("Datei: " + inDateiPfad + " hat falsches Format: ");
+ }
+ out.write(text,0,text.length());
+ out.write("\n"); // muss NeuLine schreiben das die Zeile ohne eingelesen wird
+ out.flush();
+
+ text = in.readLine();
+
+ }while (text!=null);
+ } //Wenn Datei nicht leer war.
+ in.close(); out.close();
+ //--- Umbenennen Quell-Dateien ---//
+ /*String alt = inDateiPfad + ".in";
+ File altFile = new File(alt);
+ if (altFile.exists())
+ altFile.delete();
+
+ f.renameTo(altFile);*/
+
+ //--- Umformatierte temporäre Datei unter dem ursprünglichen Namen ablegen ---//
+ File neuFile = new File(outDateiPfad);
+ out_tmp.renameTo(neuFile);
+
+ //--- Berechtigung für die neu angelegete Datei neu Vergeben ---//
+ if (!chmode("u=rw,g=rw,o=rw", outDateiPfad))
+ { System.out.println("Kann Berechtigung nicht ändern " + outDateiPfad);
+ }
+ //--- Schliessen der Streams und Löschen der temporären Datei ---//
+ in.close(); out.close();
+ out_tmp.delete();
+
+ }//Ende der Methode
+
+ private boolean chmode(String inBerechtigung,String inDat)
+ {
+ String befehl = "chmod "+ inBerechtigung + " " + inDat;
+ try
+ {
+ Runtime r = Runtime.getRuntime();
+ Process p = r.exec(befehl);
+ int exitCode = p.waitFor();
+ }
+ catch(Exception e)
+ { System.out.println("Error: " + e.toString());
+ return false;
+ }
+
+ return true;
+ }//Ende der Methode
+
+/**
+ * Liefert den Teilsstring von 0 bis zu letzten Delimiterzeichen(Exclusive)
+ * @param inS
+ * @return String
+ */
+ private String reorgString(String inS) throws Exception
+ {
+ int ldPos = inS.lastIndexOf(DELIMITER);
+ //--- Wenn Delimiter-Zeichen nicht letztes Zeichen im String ist,
+ //--- muss die Verarbeitung abgebrochen werden---//
+
+ if ((ldPos + 1) < inS.length() || ldPos== -1)
+ //throw new Exception("Datei ist bereits umgesetzt!");
+ return inS;
+ else
+ return inS.substring(0,ldPos);
+
+ }//Ende der Methode
+
+ public boolean check_param_ok(String[] inTab)
+ { //--- Anzahl der übergebenen Parameter prüfen ---//
+ //System.out.println(inTab.length);
+ if (inTab.length < 2 )
+ { System.out.println("Mindestens 2 Parameter erwartet! Mit -h oder ? rufen sie Hilfe auf.");
+ return false;
+ }
+ //--- Dateinpfad übernehmen ---//
+ _dateiPfad = inTab[0].trim();
+ _outDateiPfad = inTab[1].trim();
+
+ if (inTab.length >=3 )
+ DELIMITER = inTab[2].trim();
+ //---Wenn Delimiter-Zeichen übergeben wurde dann übernehmen ---//
+ if (inTab.length >3 )
+ _tabelle = inTab[3].toString().trim();
+
+ return true;
+ }//Ende der Methode
+
+/**
+ * Prüfen der Datei auf Vorhandensein und Leseberechrigung
+ * @param inFile
+ */
+ private boolean check_Directory(File inFile)
+ {
+ if (inFile.exists())
+ { if (!inFile.isDirectory())
+ { System.out.println(inFile + " ist kein Verzeichnis!");
+ return false;
+ }
+ }
+ else
+ { System.out.println(inFile + " Verzeichniss nicht gefunden!");
+ return false;
+ }
+
+ return true;
+ }//Ende der Methode
+
+ private void progEnde()
+ {
+ System.runFinalization();
+ System.exit(0);
+ }//Ende der Methode
+
+
+ private void zeige_hilfe()
+ {
+ System.out.println("\n Diese Klasse bereinigt die Zeilen der angegebenen ASCII-Dateien.");
+ System.out.println(" Es wird der letzte Delimeter-Zeichen aus jeder Zeile entfernt.");
+ System.out.println("\n Parameter: ");
+ System.out.println("1. Eingabe-Dateiname mit Pfadangabe ");
+ System.out.println("2. Ausgabe-Dateiname mit Pfadangabe");
+ System.out.println("3. Delimiter-Zeichen(optional)");
+ System.out.println("4. Tabellenname in der Datenbank, der auf Übereistimmung der Felderanzahl geprüft werden soll (optional, wenn keine Überprüfung, dann 'none').");
+ //System.out.println(" Wenn in einer Zeile Zeichen hinter dem letzten Delimiter-Zeichen ");
+ //System.out.println(" wird die Bearbeitung abgebrochen, da es anzunehmen ist daß diese Datei");
+ //System.out.println(" bereits umgesetzt ist!");
+ System.out.println(" Defaultwert fuer Delimiter ist ^. \n" );
+ }// Ende der Methode
+
+
+}//Ende der Klasse
\ No newline at end of file
diff --git a/src/de/superx/bin/DialectCreator.java b/src/de/superx/bin/DialectCreator.java
new file mode 100644
index 0000000..ad1838b
--- /dev/null
+++ b/src/de/superx/bin/DialectCreator.java
@@ -0,0 +1,74 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.HashMap;
+
+import de.memtext.util.DateUtils;
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+import freemarker.template.TemplateException;
+
+public class DialectCreator {
+ private static String path, sourceFileName;
+ private static String source;
+ protected static Configuration cfg = new Configuration();
+ private static Template template;
+
+ public static void main(String[] args) {
+ checkArgs(args);
+ try {
+ cfg.setDirectoryForTemplateLoading(new File(path));
+ template = cfg.getTemplate(sourceFileName);
+ //source=StringUtils.readFile(f);
+ translate("Informix", "_ids");
+ translate("Postgres", "_pg");
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static void checkArgs(String[] args) {
+ if (args.length != 2) {
+ System.out
+ .println("Error: use: DialectCreator path sourcefilename");
+ System.exit(1);
+ }
+ path = args[0];
+ sourceFileName = args[1];
+ File f = new File(path + File.separator + sourceFileName);
+ if (!f.exists() || !f.canRead()) {
+ System.out.println("Error: can't read source file " + args[1]);
+ System.exit(1);
+ }
+ }
+
+ private static void translatePostgres() {
+ HashMap map = new HashMap();
+
+ map.put("SQLdialect", "Postgres");
+
+ }
+
+ private static void translate(String dialect, String fileAppendix)
+ throws TemplateException, IOException {
+ HashMap map = new HashMap();
+ map.put("SQLdialect", dialect);
+ map.put("current", DateUtils.getTodayString() + " um "
+ + DateUtils.getNowString());
+ String fname = sourceFileName.substring(0, sourceFileName.length() - 4)
+ + fileAppendix + ".sql";
+
+ Writer out = new FileWriter(path + File.separator + fname);
+
+ // Merge the data-model and the template
+ template.process(map, out);
+ out.close();
+ System.out.println(" " + dialect + " variant created:" + fname);
+ }
+}
+
+//Created on 19.04.2005 at 10:22:09
diff --git a/src/de/superx/bin/DoShutdown.java b/src/de/superx/bin/DoShutdown.java
new file mode 100644
index 0000000..a000c3c
--- /dev/null
+++ b/src/de/superx/bin/DoShutdown.java
@@ -0,0 +1,152 @@
+package de.superx.bin;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import de.memtext.util.ExceptionHandler;
+import de.memtext.util.GetOpts;
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * doquery.java
+ * @
+ * Dieses Javaprogramm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.
+ * Gebrauch:
java doquery (optional) (optional) (optional)
+ *
+ *
+ *
+ *
+ */
+
+public class DoShutdown {
+ Connection myDb;
+ Statement st; // Our statement to run queries with
+ DatabaseMetaData dbmd; // This defines the structure of the database
+ boolean done = false; // Added by CWJ to permit \q command
+ String delim = "\t";
+ String header = "false";
+ String outFormat = "txt";
+ String logfile = "../conf/logging.properties";
+ String tabelle = "";
+ String dbpropfile = "../conf/db.properties";
+ String outfile = "";
+ Logger logger = (Logger) Logger.getLogger(DoShutdown.class.toString());
+ private ExceptionHandler exceptionHandler = new ExceptionHandler(false);
+ private static String usage="-------------------------------------\n"+
+ "Gebrauch: java de.superx.bin DoShutdown -logger:<> -dbproperties:<> -cancel=<>(optional) \n"
+ +"drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties erforderlich"
+ +"---------------------------------------------------";
+
+ public DoShutdown(String args[])
+ throws
+ ClassNotFoundException,
+ FileNotFoundException,
+ IOException,
+ SQLException
+ {
+ String cancel="";
+ GetOpts.setOpts(args);
+ String isdrin= GetOpts.isAllRequiredOptionsPresent("-logger,-dbproperties");
+ if(isdrin != null)
+ {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-logger"))
+ logfile=GetOpts.getValue("-logger" );
+ if (GetOpts.isPresent("-dbproperties"))
+ dbpropfile=GetOpts.getValue("-dbproperties" );
+ if (GetOpts.isPresent("-cancel"))
+ cancel=GetOpts.getValue("-cancel" );
+
+ initLoggingSystem();
+
+
+ //dbpropfile = args[1].trim();
+ boolean systemExitWanted=true;
+ if (cancel.equalsIgnoreCase("false")) systemExitWanted=false;
+
+ SxJdbcClient myClient = new SxJdbcClient(logger, dbpropfile, "checkpoint;");
+ //SxJdbcClient myClient = new SxJdbcClient(logger, dbpropfile, "shutdown immediately;");
+ try {
+ myClient.execute();
+
+ } catch (SQLException e) {
+ logger.severe("Fehler beim sql-Script: " + e.toString());
+ exceptionHandler.handle(e);
+ }
+ exceptionHandler.setExitWanted(systemExitWanted);
+ myClient.sqlstmt = "shutdown immediately;";
+ try {
+ logger.info("shutdown erfolgreich");
+ myClient.execute();
+
+
+ } catch (SQLException e) {
+ if (systemExitWanted) logger.severe("Fehler beim sql-Script: " + e.toString());
+ exceptionHandler.handle(e);
+
+ }
+
+ }
+ private void initLoggingSystem()
+ throws IOException, FileNotFoundException {
+
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile = MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + logfile);
+ }
+
+ /*
+ * This processes a statement
+ */
+
+ /*
+ * Display some instructions on how to run the example
+ */
+ public static void instructions() {
+ System.out.println("SuperX @version@\n");
+ System.out.println(
+ "\nDieses Java-Programm beendet einen hsqldb-Datenbankserver\n");
+ System.exit(1);
+ }
+
+ /*
+ * This little lot starts the test
+ */
+ public static void main(String args[]) {
+ //System.out.println("PostgreSQL psql example v6.3 rev 1\n");
+
+ //if (args.length < 3)
+ // instructions();
+
+ // This line outputs debug information to stderr. To enable this, simply
+ // add an extra parameter to the command line
+ //if (args.length > 3)
+ // DriverManager.setLogStream(System.err);
+
+ // Now run the tests
+ try {
+ DoShutdown test = new DoShutdown(args);
+ } catch (Exception ex) {
+ System.err.println("Exception caught.\n" + ex);
+ ex.printStackTrace();
+ }
+ }
+}
diff --git a/src/de/superx/bin/Doquery.java b/src/de/superx/bin/Doquery.java
new file mode 100644
index 0000000..0ee6852
--- /dev/null
+++ b/src/de/superx/bin/Doquery.java
@@ -0,0 +1,326 @@
+package de.superx.bin;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import java.util.StringTokenizer;
+import de.superx.util.SqlStringUtils;
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * doquery.java
+ * @
+ * Dieses Javaprogramm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.
+ * Gebrauch:
java doquery (optional) (optional) (optional)
+ *
+
+ */
+//Änderungen
+/*
+ * 16.4.04 Wenn kein outfile angegeben, werden alle select results auf die Console geloggt
+ * 19.1.2006 dq: Unload großer Tabellen unter Postgres ermöglicht.
+ */
+public class Doquery {
+ private static Connection myDb;
+ private static Statement st; // Our statement to run queries with
+ private static DatabaseMetaData dbmd;
+ // This defines the structure of the database
+ private static boolean done = false; // Added by CWJ to permit \q command
+ private static String delim = "^";
+ private static String header = "false";
+ private static String outFormat = "txt";
+ private static String logfile = "../conf/logging.properties";
+ private static String tabelle = "";
+ private static String dbpropfile = "../conf/db.properties";
+ private static SxConnection myConnection = null;
+ private static String db_driver;
+private static String outfile = "";
+ private static Logger logger =
+ (Logger) Logger.getLogger(Doquery.class.toString());
+ private static String usage =
+ "-------------------------------------\nGebrauch: java de.superx.SimpleTransform -logger=<> -IN=<> -XSL=<> -method=<>(optional) -param=<>(optional) -OUT=<>(optional) \n---------------------------------------------------";
+
+ public static void go(String args[])
+ throws
+ ClassNotFoundException,
+ FileNotFoundException,
+ IOException,
+ SQLException {
+ if (args.length > 0) {
+ logfile = args[0].trim();
+ } else {
+ throw new IllegalArgumentException("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, sql-String) erfoderlich");
+
+ }
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile = MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + logfile);
+ String _sql = "";
+ if (args.length > 1) {
+ dbpropfile = args[1].trim();
+ } else {
+ logger.severe(
+ "Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, sql-String) erfoderlich");
+ System.exit(1);
+ }
+ if (args.length > 2) {
+ _sql = args[2].trim();
+ //DOS produces unnecessary ".." around the stmt
+ if (_sql.length() > 0) {
+
+ if (_sql.startsWith("\""))
+ _sql = _sql.substring(1, _sql.length());
+ if (_sql.endsWith("\""))
+ _sql = _sql.substring(0, _sql.length() - 1);
+ }
+
+ } else {
+ logger.severe(
+ "Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, sql-String) erfoderlich");
+ System.exit(1);
+ }
+ if (args.length > 3) {
+ outFormat = args[3].trim();
+ }
+
+ if (args.length > 4) {
+ delim = args[4].trim();
+ }
+ if (args.length > 5) {
+ header = args[5].trim();
+
+ }
+ if (args.length > 6) {
+ outfile = args[6].trim();
+
+ }
+ if (delim.equals(""))
+ delim = "^"; //default Delimiter
+ if (!outfile.equals(""))
+ {
+ try {
+ FileWriter f1 = new FileWriter(outfile);
+ f1.write("");
+ f1.close();
+ } catch (IOException e) {
+ logger.severe ("Fehler beim Erstellen der Datei "+outfile);
+ }
+ }
+ getConnection(logger, dbpropfile);
+ SxTransformer myTransformer = null;
+ if (myConnection.m_DriverClass.equals("org.postgresql.Driver")
+ && !outfile.equals("")
+ && outFormat.equals("txt")
+ && !header.equals("true"))
+ {
+ //Postgres-Boost-Mode
+ logger.info("Unload with Postgres Boost mode");
+ PreparedStatement l_stmt = null;
+ PreparedStatement l_stmtFetch = null;
+ PreparedStatement l_stmtClose = null;
+ ResultSet l_rset = null;
+ ResultSetMetaData l_mdat=null;
+ int l_rows;
+ try { //exception
+
+ st = myDb.createStatement();
+
+ if(_sql.indexOf(";")>0 )
+ {
+ String einzelsql="";
+ //mehrere Statements hintereinander
+ StringTokenizer tk = new StringTokenizer(_sql, ";");
+ for (; tk.hasMoreTokens();) {
+ einzelsql = tk.nextToken();
+ if(tk.hasMoreTokens())
+ //das letzte SQL wird unten ausgeführt:
+ st.execute(einzelsql);
+ }
+ _sql=einzelsql;
+ }
+ logger.info("Print Result of: " + _sql);
+
+ st.execute( "Begin;");
+ try { //finally
+ //open the cursor
+
+ l_stmt = myConnection.prepareStatement("DECLARE FOO CURSOR FOR "+_sql);
+ l_stmt.execute();
+
+ l_stmtFetch =myConnection.prepareStatement("FETCH FORWARD 10000 FROM FOO");
+ l_rset = l_stmtFetch.executeQuery();
+ l_mdat= l_rset.getMetaData();
+ while (true) {
+ //perform a fetch from the cursor (possibly multiple fetches will be done)
+
+ if(l_rset.next()==false)
+ break;
+ //l_rset.beforeFirst() ;
+
+ if (outfile.equals(""))
+ { myTransformer = new SxTransformer(logger, System.out);
+ //myClient.setLogAllResultSetsToConsole(true);
+ }
+ else
+ myTransformer = new SxTransformer(logger, new FileWriter(outfile,true));
+
+ myTransformer.setDelim(delim);
+ myTransformer.setHeader(header);
+
+ myTransformer.setOutrs(l_rset);
+ myTransformer.setOutrsmd(l_mdat);
+ myTransformer.printResult(outFormat);
+ l_rset = l_stmtFetch.executeQuery();
+
+ }
+
+
+ //don't forget to close the cursor
+ l_stmtClose = myConnection.prepareStatement("CLOSE FOO");
+ l_stmtClose.execute();
+ } finally {
+ if (l_rset != null) {
+ l_rset.close();
+ }
+ if (l_stmt != null) {
+ l_stmt.close();
+ }
+ if (l_stmtFetch != null) {
+ l_stmtFetch.close();
+ }
+ if (l_stmtClose != null) {
+ l_stmtClose.close();
+ }
+ }
+ } catch (SQLException l_se) {
+ //do something useful here
+ logger.severe("Fehler beim SQL "+_sql);
+ l_se.printStackTrace();
+ }
+ st = myDb.createStatement();
+ //if (myConnection.m_DriverClass.equals("org.postgresql.Driver"))
+ st.execute( "commit;");
+ myConnection.close() ;
+ }
+ else
+ {
+ //normaler Modus für IDS, Access und andere Exportformate ausser txt
+
+ SxJdbcClient myClient = new SxJdbcClient(logger, dbpropfile, _sql);
+
+
+ //logger.info("Executing sql: " + _sql);
+ myClient.Rs_executeALL();
+ logger.info("Getting resultset") ;
+ ResultSet myrs = myClient.getRs();
+ //logger.info("Starting output for: " + _sql);
+ if(myrs != null && myrs.next())
+ {
+ if (outfile.equals(""))
+ { myTransformer = new SxTransformer(logger, System.out);
+ myClient.setLogAllResultSetsToConsole(true);
+ }
+ else
+ myTransformer = new SxTransformer(logger, new FileWriter(outfile));
+
+ myTransformer.setDelim(delim);
+ myTransformer.setHeader(header);
+
+ myTransformer.setOutrs(myrs);
+ myTransformer.setOutrsmd(myClient.getRsmd());
+ logger.info("Print Result of: " + _sql);
+
+ myTransformer.printResult(outFormat);
+
+ }
+ else
+ {
+ if(outFormat.equals("xml"))
+ {
+ //create "empty" XML file
+ try {
+ FileWriter f1 = new FileWriter(outfile);
+ f1.write("");
+ f1.close();
+ } catch (IOException e) {
+ logger.severe ("Fehler beim Erstellen der Datei "+outfile);
+ }
+
+ }
+
+ }
+ myClient.close();
+ }
+ logger.info("doquery erfolgreich beendet");
+
+ }
+
+ /*
+ * Display some instructions on how to run the example
+ */
+ public static void instructions() {
+ System.out.println("SuperX @version@\n");
+ System.out.println(
+ "\nDieses Java-Programm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.\n");
+ System.out.println(
+ "Gebrauch:\n java doquery (optional) (optional) (optional)\n");
+ System.exit(1);
+ }
+
+ public static void main(String args[]) {
+//args=new String[7];
+//args[0]="e:\\superx\\logging.properties";
+//args[1]="e:/superx/db.properties";
+//args[2]="select * from sos_stud_allg_cube";; ;
+//args[3]="txt";
+//args[4]="^";
+//args[5]="false";
+//args[6]="e:/superx/test.unl";
+ try {
+ go(args);
+ } catch (Exception ex) {
+ System.err.println("Doquery Aufruf fehlgeschlagen.\n" + ex);
+ ex.printStackTrace();
+ System.exit(1);
+ }
+ }
+ public static void getConnection(Logger logger,String propFile) throws SQLException {
+ myConnection = new SxConnection();
+ myConnection.setPropfile(propFile);
+ logger.config("Starting Connection...");
+ try {
+ myDb = myConnection.getConnection();
+ st = myDb.createStatement();
+ //st = myDb.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
+ // java.sql.ResultSet.CONCUR_READ_ONLY);
+ //st.setFetchSize(100);
+ dbmd = myDb.getMetaData();
+ //st = myDb.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
+ //ResultSet.CONCUR_UPDATABLE);
+ } catch (Exception e) {
+ e.printStackTrace();
+ logger.severe("Keine DB-Verbindung: " + e.toString());
+ throw new SQLException("Keine DB-Verbindung: " + e.toString());
+ }
+ db_driver = myConnection.m_DriverClass;
+
+ }
+
+
+}
diff --git a/src/de/superx/bin/Doschema.java b/src/de/superx/bin/Doschema.java
new file mode 100644
index 0000000..6039fa1
--- /dev/null
+++ b/src/de/superx/bin/Doschema.java
@@ -0,0 +1,196 @@
+package de.superx.bin;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import javax.xml.transform.TransformerException;
+
+import de.memtext.util.ExceptionHandler;
+import de.memtext.util.GetOpts;
+import de.superx.util.SqlStringUtils;
+
+/*
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * doschema.java
+ * Dieses Javaprogramm gibt das Tabellenschema einer Tabelle aus.
+ * Gebrauch:
java de.superx.bin.Doschema (optional) (optional) (optional)
+ * Die Ausgabeformate:
+ * xml - Standard-JDBC-Format
+ * HIS - Spezielles Tabellenformat nach der HIS-DTD
+ * pg - sql-Script für PostgreSQL
+ * ids - sql-Script für Informix
+ * ansi- sql-Script nach ansi SGL 92
+ * Die xsl-Stylesheets für HIS (tabschema_his.xsl), Postgres (tabschema_sql_pg.xsl) und Informix (tabschema_sql_ids.xsl) müssen im gleichen Verzeichnis wie die logger-properties stehen
+ */
+
+public class Doschema
+{
+ Connection myDb;
+ Statement st;
+ Statement updateSt;
+ DatabaseMetaData dbmd;
+ boolean done = false;
+ String delim = "";
+ String header="false";
+ String logfile="../conf/logging.properties";
+ String dbpropfile="./conf/db.properties";
+ String tabelle="";
+ String outFormat="xml";
+
+ Logger logger= (Logger) Logger.getLogger(Doschema.class.toString());
+ private ExceptionHandler exceptionHandler = new ExceptionHandler(false);
+ private static String usage="-------------------------------------\n"+
+ "Gebrauch: java de.superx.bin.Doschema -logger:<> -dbproperties:<> " +
+ "-table: -outFormat:(optional) \n---------------------------------------------------";
+
+ public Doschema(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException
+ {
+ String outfile = "";
+ GetOpts.setOpts(args);
+ String isdrin= GetOpts.isAllRequiredOptionsPresent("-logger,-dbproperties");
+ if(isdrin != null)
+ {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-logger"))
+ logfile=GetOpts.getValue("-logger" );
+ if (GetOpts.isPresent("-dbproperties"))
+ dbpropfile=GetOpts.getValue("-dbproperties" );
+ if (GetOpts.isPresent("-table"))
+ tabelle=GetOpts.getValue("-table" );
+ if (GetOpts.isPresent("-outFormat"))
+ outFormat=GetOpts.getValue("-outFormat" );
+ if (GetOpts.isPresent("-outfile"))
+ outfile=GetOpts.getValue("-outfile" );
+
+ File f = new File(logfile);
+ String confPath=f.getParent() ;
+ if (!f.exists())
+ { throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile=MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + logfile);
+ logger.config("Getting Schema.");
+ SxJdbcClient myClient=new SxJdbcClient(logger, dbpropfile);
+ //OutputStream out=new OutputStream();
+ //OutputStreamWriter Outwriter=new OutputStreamWriter(out);
+ logger.config("Tabellenkatalog für " + tabelle);
+ String zs ="";
+ zs= ""+ "\n";
+ //zs+="\n";
+ zs += myClient.getTableSchema (tabelle) + "\n";
+ SxTransformer myTransformer=null;
+ if(outfile.equals(""))
+ myTransformer = new SxTransformer(logger,System.out);
+ else
+ myTransformer = new SxTransformer(logger,new FileWriter(outfile));
+
+ myTransformer.quellstring=zs;
+ if(outFormat.equals("his"))
+ {
+ myTransformer.stylesheet=confPath+System.getProperty("file.separator")+"tabschema_his.xsl";
+ try
+ {
+ myTransformer.transformString("xml") ;
+ }
+ catch (TransformerException e)
+ {
+ logger.severe("XSL-Transformation fehlgeschlagen:" + e.toString());
+ exceptionHandler.handle( e);
+ }
+ catch (Exception e)
+ {
+ logger.severe("XSL-Transformation fehlgeschlagen:" + e.toString());
+ exceptionHandler.handle( e);
+ }
+
+ }
+ else
+ {
+ if(outFormat.equals("pg") || outFormat.equals("ids") || outFormat.equals("ansi"))
+ {
+ myTransformer.stylesheet=confPath+System.getProperty("file.separator")+"tabschema_sql_"+outFormat+".xsl";
+ myTransformer.format=outFormat;
+ try
+ {
+ myTransformer.transformString("text") ;
+ }
+ catch (TransformerException e)
+ {
+ logger.severe("XSL-Transformation nach sql fehlgeschlagen:" + e.toString());
+ exceptionHandler.handle( e);
+ }
+ catch (Exception e)
+ {
+ logger.severe("XSL-Transformation nach sql fehlgeschlagen:" + e.toString());
+ exceptionHandler.handle( e);
+ }
+ }
+
+ else
+ {
+ //simple xml-Output
+ myTransformer.outputString();
+ }
+ }
+ logger.info("Now closing the connection");
+ //st.close();
+ myClient.close();
+
+ }
+
+
+
+ /*
+ * Display some instructions on how to run the example
+ */
+ public static void instructions()
+ {
+ System.out.println("SuperX @version@\n");
+ System.out.println("\nDieses Javaprogramm gibt des Schema einer Tabelle aus");
+ System.out.println("Im Classpath muss superx-db.jar,sowie der zugehörige jdbc-Treiber sein.");
+ System.out.println("Befehl:\n java doschema (optional) (optional) (optional)");
+ System.out.println("Der Logging-Level wird in ../conf/logging.properties konfiguriert, der DB-Zugriff in ../conf/db.properties ");
+
+ System.out.println("Default:\n java -cp .:$JDBC_CLASSPATH de.superx.bin.Doschema $LOGGER_PROPERTIES $DB_PROPERTIES $tabelle ansi");
+ System.exit(1);
+ }
+
+ /*
+ * This little lot starts the test
+ */
+ public static void main(String args[])
+ {
+ //System.out.println("SuperX-Tool DoSchema V.2.03\n");
+
+ if (args.length < 1)
+ instructions();
+
+
+ try
+ {
+ Doschema test = new Doschema(args);
+ }
+ catch (Exception ex)
+ {
+ System.err.println("Exception caught.\n" + ex);
+
+ ex.printStackTrace();
+ }
+ }
+}
diff --git a/src/de/superx/bin/Dosql.java b/src/de/superx/bin/Dosql.java
new file mode 100644
index 0000000..d3a6837
--- /dev/null
+++ b/src/de/superx/bin/Dosql.java
@@ -0,0 +1,236 @@
+package de.superx.bin;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.StringTokenizer;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import de.memtext.util.ExceptionHandler;
+import de.memtext.util.GetOpts;
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * Dosql.java
+ * @
+ * Dieses Javaprogramm führt einen oder mehrere SQL-Ausdrück in einer Datei aus und gibt das Ergebnis aus.
+ * Gebrauch:
java dosql (optional) (optional) (optional)
+ *
+ */
+
+/* Änderungen
+
+15.4.2004 MB wenn keine Ausgabedatei und Ausgabeformat txt, alle selects von SxJdbcClient
+ loggen lassen
+6.4.2004 MB Code static main verlegt - nach erfolgreicher Durchführung ein system.out
+
+**/
+public class Dosql {
+ private static Connection myDb;
+ private static Statement st; // Our statement to run queries with
+ private static boolean done = false; // Added by CWJ to permit \q command
+ private static String delim = "^";
+ private static String header = "false";
+ private static String logfile = "../conf/logging.properties";
+ private static String tabelle = "";
+ private static String dbpropfile = "../conf/db.properties";
+ private static String outfile = "";
+ private static String outFormat = "txt";
+ private static String _dateiPfad = "";
+ //LogUtils logger=null;
+ private static Logger logger =
+ (Logger) Logger.getLogger(Dosql.class.toString());
+ //static Logger logger = Logger.getLogger(dosql.class);
+ private static ExceptionHandler exceptionHandler =
+ new ExceptionHandler(false);
+ private static String usage =
+ "-------------------------------------\n"
+ + "Gebrauch: java de.superx.bin.Dosql -logger=<> -dbproperties=<> "
+ + "-sqlfile: -params: -outFormat:(optional) -delim: -header:(optional) -outfile:(optional) \n---------------------------------------------------";
+
+ /*
+ * Display some instructions on how to run the example
+ */
+ public static void instructions() {
+ System.out.println("SuperX @version@\n");
+ System.out.println(
+ "\nDieses Javaprogramm führt ein beliebiges sql-Script mit einer oder mehr sql-Anweisungen aus");
+ System.out.println(
+ "Im Classpath muss superx@version@.jar sowie der zugehörige jdbc-Treiber sein.");
+ System.out.println(
+ "Befehl:\n java dosql (optional) true");
+ System.exit(1);
+ }
+
+ public static void main(String args[]) {
+ try {
+ execute(args);
+ } catch (Exception e) {
+ logger.severe(
+ "Fehler beim sql-Script: " + _dateiPfad + " " + e.toString());
+ e.printStackTrace();
+ System.exit(1);
+ }
+
+ }
+
+ public static void execute(String[] args)
+ throws Exception {
+
+ String params = "";
+ GetOpts.setOpts(args);
+ String isdrin =
+ GetOpts.isAllRequiredOptionsPresent(
+ "-logger,-dbproperties,-sqlfile");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-logger"))
+ logfile = GetOpts.getValue("-logger");
+ if (GetOpts.isPresent("-dbproperties"))
+ dbpropfile = GetOpts.getValue("-dbproperties");
+ if (GetOpts.isPresent("-sqlfile"))
+ _dateiPfad = GetOpts.getValue("-sqlfile");
+ if (GetOpts.isPresent("-outFormat"))
+ outFormat = GetOpts.getValue("-outFormat");
+ if (GetOpts.isPresent("-delim"))
+ delim = GetOpts.getValue("-delim");
+ if (GetOpts.isPresent("-header"))
+ header = GetOpts.getValue("-header");
+ if (GetOpts.isPresent("-outfile"))
+ outfile = GetOpts.getValue("-outfile");
+ if (GetOpts.isPresent("-params"))
+ params = GetOpts.getValue("-params");
+
+ if (delim.equals(""))
+ delim = "^"; //default Delimiter
+
+ //logger.initRaw(dosql.class)
+ //PropertyConfigurator.configure(logfile);
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile = MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + logfile);
+
+ f = new File(_dateiPfad);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + _dateiPfad);
+ }
+ BufferedReader in;
+ //--- InputStream generieren ---//
+ in = new BufferedReader(new InputStreamReader(new FileInputStream(f)));
+
+ //--- Verarbeiten der Datei ---//
+ String sql = "";
+ String text = "";
+ while ((text = in.readLine()) != null) {
+ //MB auskommentiert 27.4.05
+ //löschte ( in
+ //insert into
+ //(
+ //tid,...
+ //if (text.length() > 1)
+ sql += System.getProperty("line.separator") + text.trim();
+ }
+ in.close();
+ if (sql.toLowerCase().indexOf("")>-1)
+ {
+ SxConnection myConnection = new SxConnection();
+ myConnection.setPropfile(dbpropfile);
+ Connection con = myConnection.getConnection();
+
+ new XUpdater().execute(con, myConnection.getDatabaseAbbr(), sql,logger);
+ }
+ else
+ {
+ if(sql.toLowerCase().indexOf("--freemarker template")>-1)
+ {
+
+ try {
+ sql=de.superx.bin.FMParser.simpleParser(dbpropfile, sql);
+ } catch (Exception e) {
+
+ e.printStackTrace();
+ }
+ }
+ sql = sql.trim();
+ if (sql.startsWith("\""))
+ sql = sql.substring(1, sql.length());
+ if (sql.endsWith("\""))
+ sql = sql.substring(0, sql.length() - 1);
+
+ logger.config("Inhalt der sql-Datei: \n--" + sql + "--");
+ //First the params are replaced:
+ if (!params.equals("")) {
+ if (!params.endsWith("|"))
+ params += "|";
+ StringTokenizer st = new StringTokenizer(params, "|");
+ for (; st.hasMoreTokens();) {
+ String param = st.nextToken();
+ if (!param.equals("")) {
+ String paramname = param.substring(0, param.indexOf("="));
+ String paramvalue =
+ param.substring(param.indexOf("=") + 1, param.length());
+ sql =
+ de.superx.bin.SxDBUtils.replaceString(
+ sql,
+ paramname,
+ paramvalue);
+ }
+ }
+ }
+ SxJdbcClient myClient = new SxJdbcClient(logger, dbpropfile, sql);
+ if (outfile.equals("")&&outFormat.equalsIgnoreCase("txt"))
+ myClient.setLogAllResultSetsToConsole(true);
+ SxTransformer myTransformer = null;
+
+ myClient.Rs_executeALL();
+ ResultSet myrs = myClient.getRs();
+
+ if (myrs != null) {
+ if (outfile.equals("")) {
+ myTransformer = new SxTransformer(logger, System.out);
+ } else
+ myTransformer =
+ new SxTransformer(logger, new FileWriter(outfile));
+
+ if (!outfile.equals("")||!outFormat.equalsIgnoreCase("txt"))
+ {
+
+ myTransformer.setDelim(delim);
+ myTransformer.setHeader(header);
+
+ myTransformer.setOutrs(myrs);
+ myTransformer.setOutrsmd(myClient.getRsmd());
+ myTransformer.printResult(outFormat);
+ }
+ } else
+ logger.info("Keine Rückgabewerte aus SQL-Script");
+ myClient.close();
+ }
+ System.out.println(
+ "Dosql hat das Script " + _dateiPfad + " erfolgreich durchgeführt");
+ logger.info("dosql erfolgreich beendet");
+
+ }
+}
+
diff --git a/src/de/superx/bin/Dostmt.java b/src/de/superx/bin/Dostmt.java
new file mode 100644
index 0000000..fcd3296
--- /dev/null
+++ b/src/de/superx/bin/Dostmt.java
@@ -0,0 +1,182 @@
+package de.superx.bin;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import de.memtext.util.ExceptionHandler;
+
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * dostmt.java
+ * @
+ * Dieses Javaprogramm führt einen SQL-Statement in einer Datei aus
+ * Gebrauch:
java dostmt
+ * Für mehrere SQL-Ausdrücke führen sie bitte dosql aus.
+ */
+public class Dostmt
+{
+ Connection myDb;
+ Statement st; // Our statement to run queries with
+ boolean done = false; // Added by CWJ to permit \q command
+ String delim = "\n";
+ String header="false";
+ String logfile="../conf/logging.properties";
+ String tabelle="";
+ String dbpropfile="../conf/db.properties";
+ String outfile="";
+ String outFormat="txt";
+ //LogUtils logger=null;
+ Logger logger= (Logger) Logger.getLogger(Dostmt.class.toString());
+ //static Logger logger = Logger.getLogger(dosql.class);
+ private ExceptionHandler exceptionHandler = new ExceptionHandler(false);
+
+ public Dostmt(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException
+ {
+
+ if (args.length > 0)
+ {
+ logfile=args[0].trim();
+ }
+ else
+ {
+ System.err.println("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, Pfad zur SQL-Datei) erfoderlich");
+ System.exit(1);
+ }
+ //logger.initRaw(dosql.class)
+ //PropertyConfigurator.configure(logfile);
+ File f = new File(logfile);
+ if (!f.exists())
+ { throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile=MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + logfile);
+
+ String _dateiPfad = "";
+ if (args.length > 1)
+ {
+ dbpropfile=args[1].trim();
+ }
+ else
+ {
+ logger.severe("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, Pfad zur SQL-Datei) erfoderlich");
+ System.exit(1);
+ }
+ if (args.length > 2)
+ {
+ _dateiPfad=args[2].trim();
+ }
+ else
+ {
+ logger.severe("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, Pfad zur SQL-Datei) erfoderlich");
+ System.exit(1);
+ }
+
+
+ f = new File(_dateiPfad);
+ if (!f.exists())
+ { throw new IOException("Datei nicht gefunden: " + _dateiPfad);
+ }
+ BufferedReader in;
+ //--- InputStream generieren ---//
+ in = new BufferedReader(new InputStreamReader(
+ new FileInputStream(f) ));
+
+ //--- Verarbeiten der Datei ---//
+ String sql="";
+ String text="";
+ while ((text = in.readLine()) != null)
+ {
+ if(text.length()>1)
+ sql+=System.getProperty("line.separator")+ text.trim();
+ }
+ in.close();
+ logger.config("Inhalt von sql-Datei: \n"+sql);
+ SxJdbcClient myClient=new SxJdbcClient(logger, dbpropfile,sql);
+ try
+ {
+ SxTransformer myTransformer=null;
+ myClient.execute();
+ ResultSet myrs=myClient.getRs();
+ if(myrs != null)
+ {
+ if(outfile.equals(""))
+ myTransformer = new SxTransformer(logger,System.out);
+ else
+ myTransformer = new SxTransformer(logger,new FileWriter(outfile));
+ myTransformer.setDelim(delim);
+ myTransformer.setHeader(header);
+
+ myTransformer.setOutrs( myrs);
+ myTransformer.setOutrsmd(myClient.getRsmd());
+ myTransformer.printResult(outFormat);
+
+ }
+ else
+ logger.info("Keine Rückgabewerte aus SQL-Script");
+ myClient.close();
+ }
+ catch (SQLException e)
+ {
+ logger.severe("Fehler beim sql-Script: "+e.toString());
+ exceptionHandler.handle(e);
+ }
+
+ logger.info("dosql erfolgreich beendet");
+
+ }
+
+
+
+ /*
+ * Display some instructions on how to run the example
+ */
+ public static void instructions()
+ {
+ System.out.println("\nDieses Javaprogramm führt ein beliebiges sql-Script mit einer oder mehr sql-Anweisungen aus");
+ System.out.println("Im Classpath muss superx-db.jar sowie der zugehörige jdbc-Treiber sein.");
+ System.out.println("Befehl:\n java dosql (optional) true");
+ System.exit(1);
+ }
+
+ /*
+ * This little lot starts the test
+ */
+ public static void main(String args[])
+ {
+ //System.out.println("PostgreSQL psql example v6.3 rev 1\n");
+
+ //if (args.length < 3)
+ // instructions();
+
+ // This line outputs debug information to stderr. To enable this, simply
+ // add an extra parameter to the command line
+ //if (args.length > 3)
+ // DriverManager.setLogStream(System.err);
+
+ // Now run the tests
+ try
+ {
+ Dostmt test = new Dostmt(args);
+ }
+ catch (Exception ex)
+ {
+ System.err.println("Exception caught.\n" + ex);
+ ex.printStackTrace();
+ }
+ }
+}
diff --git a/src/de/superx/bin/ExcelPdfCreator.java b/src/de/superx/bin/ExcelPdfCreator.java
new file mode 100644
index 0000000..79129a4
--- /dev/null
+++ b/src/de/superx/bin/ExcelPdfCreator.java
@@ -0,0 +1,55 @@
+package de.superx.bin;
+
+import java.io.File;
+
+import de.memtext.util.GetOpts;
+import de.memtext.util.StringUtils;
+import de.memtext.util.TransletUtils;
+import de.superx.servlet.XmlTransformer;
+
+public class ExcelPdfCreator {
+
+ /**
+ * @param args
+ */
+ public static void main(String[] args) {
+ try {
+System.out.println("Wenn Grafiken in PDF eingebunden werden sollen, muss in (tabelle_fo_pdf_kopffusszeile.xsl)\n"+
+ "Richtige Pfade für Standalonebetrieb eingestellt werden, beispielweise in eigener pageComponents_html_final.xsl");
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts.isAllRequiredOptionsPresent("-in,-xsl,-out");
+ if (isdrin != null) {
+
+ System.err.println("-fopxconf (Pfad dazu - optional) -in -xsl -out Endung auf .xsl=Excel .pdf=PDF");
+ System.exit(1);
+ }
+
+ System.out.println("Lokalisierung per sx_captions derzeit nicht unterstuetzt!");
+ String in = GetOpts.getValue("-in");
+ String xsl = GetOpts.getValue("-xsl");
+ String out = GetOpts.getValue("-out");
+
+ TransletUtils.initFactory("net.sf.saxon.TransformerFactoryImpl", "org.apache.xalan.xsltc.trax.TransformerFactoryImpl");
+
+
+
+
+ XmlTransformer xt = new XmlTransformer(null, null, null, null, null);
+ if (out.endsWith(".xls") || out.endsWith(".xlsx")) {
+ xt.createExcelStandalone(StringUtils.readFile(new File(in)), xsl, out);
+ System.out.println("Datei erzeugt");
+ }
+ if (out.endsWith(".pdf")) {
+ File conf=null;
+ if (GetOpts.isPresent("-fopxconf")) conf=new File(GetOpts.getOpt("-fopxconf").replaceAll("-fopxconf:", ""));
+ xt.createPdfStandalone(conf,StringUtils.readFile(new File(in)), xsl, out);
+ System.out.println("Datei erzeugt");
+ }
+ } catch (Exception e) {
+
+ System.out.println("Fehler : " + e);
+ e.printStackTrace();
+
+ }
+ }
+}
diff --git a/src/de/superx/bin/ExecuteMask.java b/src/de/superx/bin/ExecuteMask.java
new file mode 100644
index 0000000..9f68248
--- /dev/null
+++ b/src/de/superx/bin/ExecuteMask.java
@@ -0,0 +1,474 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.StringTokenizer;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.mock.web.MockServletConfig;
+
+import de.memtext.baseobjects.coll.NamedIdObjectList;
+import de.memtext.util.GetOpts;
+import de.memtext.util.ServletHelper;
+import de.memtext.util.StringUtils;
+import de.memtext.util.TimeUtils;
+import de.memtext.util.TransletUtils;
+import de.superx.common.FieldContainer;
+import de.superx.common.Maske;
+import de.superx.common.SxResultRow;
+import de.superx.common.SxResultSet;
+import de.superx.common.SxUser;
+import de.superx.servlet.ServletUtils;
+import de.superx.servlet.SuperXManager;
+import de.superx.servlet.SxPools;
+import de.superx.servlet.UserInitializer;
+import de.superx.servlet.XmlTransformer;
+import net.sf.jasperreports.engine.JRException;
+
+public class ExecuteMask {
+
+ /**
+ * Kommandozeilen-Interface für Ausführung von Masken und Export des Ergebnis
+ * als Datei
+ *
+ * @param args
+ * @param -logger:Pfad zu logging.properties, normalerweise
+ * $SUPERX_DIR/db/conf
+ * @param -tid:Nummer der Maske
+ * @param -out:Ausgabedatei
+ * @param -user:Benutzerkennung, unter der Maske laufen soll
+ * @param -locale:Locale (optional)
+ * @param -params:Parameter für die Maske, jeweils mit "&" getrennt in
+ * einem String
+ *
+ * Sollte im Arbeitsverzeichnis webapps/superx/WEB-INF laufen
+ *
+ * Beispiele: HTML Druckversion (Default): java
+ * de.superx.bin.ExecuteMask -tid:16000 -out:test.htm -user:admin
+ * "-params:Köpfe oder Fälle ?=1=1&Stichtag=1"
+ * -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties
+ * PDF Datei: java de.superx.bin.ExecuteMask -tid:16000
+ * -out:test.pdf -user:admin "-params:Köpfe oder Fälle
+ * ?=1=1&Stichtag=1&stylesheet=tabelle_fo_pdf.xsl&contenttype=application/pdf"
+ * -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties
+ * Excel-Datei java de.superx.bin.ExecuteMask -tid:16000
+ * -out:test.xls -user:admin "-params:Köpfe oder Fälle
+ * ?=1=1&Stichtag=1&stylesheet=tabelle_xls.xsl&contenttype=application/vnd.ms-excel"
+ * -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties
+ */
+ private static String mandantenID = "default";
+
+ private static TimeUtils tutil = new TimeUtils();
+
+ private static String myLocale;
+
+ private static String myParams = "";
+
+ private static Object adminUser;
+
+ private static Integer userid;
+
+ private static FieldContainer myFieldContainer;
+
+ private static String myWEBINFFilePath = System.getProperty("user.dir");
+
+ private static Logger log;
+
+ private static String usage = " Kommandozeilen-Interface für Ausführung von Masken und Export des Ergebnis als Datei\n"
+ + " Parameter:\n" + " -logger:Pfad zu logging.properties, normalerweise $SUPERX_DIR/db/conf\n"
+ + " -tid:Nummer der Maske\n" + " -out:Ausgabedatei\n"
+ + " -user:Benutzerkennung, unter der Maske laufen soll\n" + " -locale:Locale (optional)\n"
+ + " -params:Parameter für die Maske, jeweils mit \"&\" getrennt in einem String\n" + " \n"
+ + " Sollte im Arbeitsverzeichnis webapps/superx/WEB-INF laufen\n" + " \n" + " Beispiele:\n"
+ + " HTML Druckversion (Default): \n"
+ + " java de.superx.bin.ExecuteMask -tid:16000 -out:test.htm -user:admin \"-params:Köpfe oder Fälle ?=1=1&Stichtag=1\" -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties\n"
+ + " PDF Datei:\n"
+ + " java de.superx.bin.ExecuteMask -tid:16000 -out:test.pdf -user:admin \"-params:Köpfe oder Fälle ?=1=1&Stichtag=1&stylesheet=tabelle_fo_pdf.xsl&contenttype=application/pdf\" -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties\n"
+ + " Excel-Datei\n"
+ + " java de.superx.bin.ExecuteMask -tid:16000 -out:test.xls -user:admin \"-params:Köpfe oder Fälle ?=1=1&Stichtag=1&stylesheet=tabelle_xls.xsl&contenttype=application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\" -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties\n"
+ + " java de.superx.bin.ExecuteMask -tid:16000 -out:test.xls -user:admin \"-params:Köpfe oder Fälle ?=1=1&Stichtag=1&stylesheet=tabelle_xls.xsl&contenttype=application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\" -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties\n"
+ + " CSV-Datei\n"
+ + " java de.superx.bin.ExecuteMask -tid:16000 -out:test.csv -user:admin \"-params:Köpfe oder Fälle ?=1=1&Stichtag=1&contenttype=test/csv\" -logger:/home/superx/git/superx/superx/WEB-INF/conf/edustore/db/conf/logging.properties\n"
+ + " -fopxconf (Pfad dazu - optional)";
+
+ static MockHttpServletRequest mock ;
+
+ static MockHttpServletResponse mockResponse = new MockHttpServletResponse();
+
+ static MockServletConfig mockServletConfig = new MockServletConfig();
+
+ static SxUser user;
+ private static File fopxconfFile = null;
+
+ public static void main(String[] args) throws IllegalArgumentException, SecurityException {
+ SuperXManager.initKettleEnv();
+ // mock muss neu intialisiert werden, sonst Fehlschläge bei mehreren Aufrufen
+ // von ExecuteMaske in JUnitTest Batterie mittels ant
+ mock = new MockHttpServletRequest();
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts.isAllRequiredOptionsPresent("-logger,-tid,-out,-user");
+ if (isdrin != null) {
+ System.err.println(usage);
+ System.exit(1);
+ }
+ String userName = GetOpts.getValue("-user");
+ String loggingProperties = GetOpts.getValue("-logger");
+
+ if (GetOpts.isPresent("-fopxconf")) {
+ fopxconfFile = new File(GetOpts.getOpt("-fopxconf").replaceAll("-fopxconf:", ""));
+ } else {
+ fopxconfFile = null;
+ }
+
+ try {
+ FileInputStream ins;
+ ins = new FileInputStream(loggingProperties);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ log = Logger.getLogger(ExecuteMask.class.getName());
+ log.addHandler(new ConsoleHandler());
+ System.out.println("Using Loggging-Level " + log.getLevel());
+ } catch (FileNotFoundException e2) {
+ System.err.println("Datei " + loggingProperties + " nicht gefunden:" + e2.toString());
+ System.exit(1);
+ } catch (IOException e) {
+ System.err.println("Datei " + loggingProperties + " kann nicht gelesen werden:" + e.toString());
+ System.exit(1);
+ }
+ tutil.start();
+ try {
+ SuperXManager.initKettleEnv();
+ SxPools.init();
+ SxPools.get(mandantenID).init();
+ SxPools.get(mandantenID).initLogging(true);
+ SxPools.resetAllPools();
+ userid = getUserID(userName, mandantenID);
+ adminUser = getUserAdmin(userName, mandantenID);
+ user = UserInitializer.initUser(mandantenID, userName, userid, adminUser);
+ } catch (Exception e) {
+ log.severe("Fehler beim Aufbau der Connection: " + e.toString());
+ System.exit(1);
+ }
+ String tidString = GetOpts.getValue("-tid");
+ String outfile = GetOpts.getValue("-out");
+ if (GetOpts.isPresent("-locale"))
+ myLocale = GetOpts.getValue("-locale");
+ else
+ myLocale = de.superx.util.SqlStringUtils.getEncoding();
+ if (GetOpts.isPresent("-params"))
+ myParams = GetOpts.getValue("-params");
+ Locale desiredLocale = new Locale(myLocale);
+ SuperXManager.maxRows = 1000000;
+ Maske maske = null;
+ try {
+ maske = new Maske(mandantenID, user, new Integer(tidString), desiredLocale);
+ NamedIdObjectList fields = maske.readFelderFromDb(user);
+ myFieldContainer = maske.getIndividualFields();
+ myFieldContainer.addAll(fields);
+ setParams(mock, myParams);
+ maske.setFieldDefaults(user, mock, true);
+ exportTable(mock, mockResponse, maske, user, outfile, desiredLocale);
+ System.out.println("Datei " + outfile + " für Maske " + tidString + " erzeugt in " + tutil.getSinceStart());
+ } catch (Exception e) {
+ e.printStackTrace();
+
+ log.severe("Fehler beim Ausführen der Maske " + tidString + ": " + e.toString());
+ System.exit(1);
+ }
+ }
+
+ public static HttpServletResponse getHttpResponse() {
+ return mockResponse;
+ }
+
+ /**
+ * Ermittelt die user-id aus dem Login-Namen
+ *
+ *
+ * @param userName Login Kennung
+ * @param mandantenID_par Mandanten-ID
+ * @return userID
+ */
+ private static Integer getUserID(String userName, String mandantenID_par) {
+ String query = "select tid from userinfo where benutzer='" + userName + "';";
+ Integer userID = null;
+
+ SxResultSet rs = null;
+ try {
+ rs = ServletUtils.execute("Ermittle ID für " + userName, query, mandantenID_par);
+ } catch (Exception e) {
+ log.severe("Fehler beim Ermitteln der ID für " + userName + ": " + e.toString());
+ }
+ for (Iterator it = rs.iterator(); it.hasNext();) {
+ SxResultRow row = it.next();
+ userID = (Integer) row.get(0);
+ }
+ if (userID == null) {
+ System.err.println("User " + userName + "unbekannt");
+ System.exit(1);
+ }
+ return userID;
+ }
+
+ /**
+ * Ermittelt, ob ein user Admin-Rechte hat
+ *
+ *
+ * @param userName Login Kennung
+ * @param mandantenID_par Mandanten-ID
+ * @return admin ("1" oder "0")
+ */
+ private static String getUserAdmin(String userName, String mandantenID_par) {
+ String query = "select administration from userinfo where benutzer='" + userName + "';";
+ String admin = null;
+
+ SxResultSet rs = null;
+ try {
+ rs = ServletUtils.execute("Ermittle Admin-Flag für " + userName, query, mandantenID_par);
+ } catch (Exception e) {
+ log.severe("Fehler beim Ermitteln der Admin-Rechte für " + userName + ": " + e.toString());
+ }
+ if (rs == null) {
+ return admin;
+ }
+ for (Iterator it = rs.iterator(); it.hasNext();) {
+ SxResultRow row = it.next();
+ admin = row.get(0).toString();
+ }
+
+ return admin;
+ }
+
+ /**
+ * Überführt einen String mit Parametern ("&"-getrennt) ins request Objekt)
+ *
+ *
+ * @param mock Request Objekt
+ * @param paramsString String mit Parametern (Achtung: Umlaute und Sonderzeichen
+ * nicht encodiert)
+ *
+ */
+ private static void setParams(MockHttpServletRequest mock, String paramsString) {
+ StringTokenizer st = new StringTokenizer(paramsString, "&");
+ for (; st.hasMoreTokens();) {
+ String paramString = st.nextToken();
+ String paramName = paramString.substring(0, paramString.indexOf("="));
+ String paramVal = paramString.substring(paramString.indexOf("=") + 1);
+ mock.addParameter(paramName, paramVal);
+ //System.out.println(paramName+"-"+paramVal);
+ }
+ }
+
+ /**
+ * Führt eine Maske aus und speichert das Ergebnis in einer Datei
+ *
+ *
+ * @param mock_par Request Objekt
+ * @param maske Masken-Objekt
+ * @param user_par User-Objekt
+ * @param outfile Name Ausgabedatei
+ * @param desiredLocale Locale für Ausgabedatei
+ *
+ */
+ private static void exportTable(MockHttpServletRequest mock_par, MockHttpServletResponse mockResponse_par,
+ Maske maske, SxUser user_par, String outfile, Locale desiredLocale) {
+ String currentXml_local = null;
+ String method = "html";
+ String stylesheet = ServletHelper.getParameter(mock_par, "stylesheet");
+ // Default ist html Druckversion:
+ if (stylesheet == null || stylesheet.equals(""))
+ stylesheet = "tabelle_html_p.xsl";
+ log.info("Stylesheet " + stylesheet + " wird genutzt");
+ String contenttype = ServletHelper.getParameter(mock_par, "contenttype");
+ // Default ist html:
+ if (contenttype == null || contenttype.equals(""))
+ contenttype = "text/html";
+ if (contenttype.indexOf("pdf") > -1)
+ method = "pdf";
+ if (contenttype.indexOf("xml") > -1)
+ method = "xml";
+ if (contenttype.indexOf("excel") > -1)
+ method = "xls";
+ // if
+ // (contenttype.indexOf("vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+ // > -1) method = "xlsx";
+
+ log.info("Contenttype " + contenttype + " wird erzeugt");
+ maske.setMaxOffset(10000000);
+ maske.setReuseResult(false);
+ maske.resetTableStylesheet();
+ maske.setSelectedTableStylesheetFileAndContenttype(stylesheet);
+ maske.setDesiredContenttype(contenttype);
+ log.info("Start Maskengenerierung");
+ try {
+ currentXml_local = maske.runQuery(user_par, mock_par, null).toString();
+ System.out.println("Ausgabe Maskenprotokoll\n" + SuperXManager.activityLog.toString());
+ log.info("Maskenergebnis wird lokalisiert");
+ currentXml_local = SxPools.get(mandantenID).localize(currentXml_local, desiredLocale);
+
+ } catch (Exception e) {
+
+ log.severe("Fehler beim Erstellen des XML für Maske " + e.toString());
+ }
+ String ausgabedatei = "";
+ if (stylesheet.equals("tabelle_xml.xsl"))
+ ausgabedatei = writeTextFile(currentXml_local, outfile);
+ else if (contenttype.equals("text/csv"))
+ try {
+ ausgabedatei = writeTextFile(maske.getCSV(mandantenID).toString(), outfile);
+ } catch (IOException e) {
+ System.out.println("Fehler beim Erstellen der datei " + outfile);
+ e.printStackTrace();
+ }
+ else {
+ ausgabedatei = writeTextFile(currentXml_local, null);
+ if (stylesheet.endsWith(".jrxml"))
+ exportJR(mock_par, mockResponse_par, maske, user_par, outfile, stylesheet, contenttype, mandantenID,
+ myWEBINFFilePath + "/reports/", currentXml_local);
+ else
+ transformFile(maske, ausgabedatei, stylesheet, contenttype, outfile, mockResponse_par, method);
+
+ }
+ log.info("Datei " + ausgabedatei + " erzeugt");
+
+ }
+
+ private static void exportJR(MockHttpServletRequest mock_par, MockHttpServletResponse mockResponse_par, Maske maske,
+ SxUser user_par, String outfile, String stylesheet, String contentType, String mandantenID_par,
+ String reports_dir, String currentXml_par) {
+
+ if ((currentXml_par.indexOf("Insgesamt 0 Sätze gefunden") < 1
+ // im Makro immer ausführen:
+ || currentXml_par.indexOf("ergebnis ordnr=\"1\"") > -1)
+ && currentXml_par.indexOf("Zeilen liegen über max. Grenze") < 1) {
+ try {
+ de.superx.servlet.JasperCreator jc = new de.superx.servlet.JasperCreator(mock_par, mockResponse_par,
+ user_par, maske, stylesheet, contentType, reports_dir);
+
+ if (maske.getSelectedTableStylesheetFilename().indexOf("_xmlsource") > -1) {
+ jc.perform(mandantenID_par, currentXml_par, outfile);
+ } else {
+ jc.perform(mandantenID_par, maske, outfile);
+ }
+
+ } catch (JRException | IOException e) {
+ log.severe("Fehler bei JasperReport-Erzeugung " + e.toString());
+
+ }
+ } else
+ log.info("Keine Daten für JR verfügbar");
+ }
+
+ /**
+ * Erzeugt Text-Datei, bei temp. Datei wird der absolute Pfad zurückgegeben
+ *
+ *
+ * @param content Inhalt der Text-Datei
+ * @param filename Name Ausgabedatei
+ * @return targetfilename Aboluter Pfad zur Datei, die erzeugt wurde
+ */
+ private static String writeTextFile(String content, String filename) {
+ String targetfilename = "";
+ try {
+ File temp = File.createTempFile("tabelle", ".xml");
+ FileWriter f1 = new FileWriter(temp);
+ f1.write(content);
+ f1.flush();
+ f1.close();
+ targetfilename = temp.getAbsolutePath();
+ Path tmpPath = Paths.get(targetfilename);
+ if (filename != null) {
+ Path destPath = Paths.get(filename);
+ Path resultPath = Files.move(tmpPath, destPath, StandardCopyOption.REPLACE_EXISTING);
+ targetfilename = resultPath.toString(); // dest.getAbsolutePath();
+ }
+ } catch (IOException e) {
+ log.severe("Fehler beim Erstellen der Datei " + filename + " " + e.toString());
+
+ }
+ return targetfilename;
+
+ }
+
+ /**
+ * Erzeugt Excel- oder PDF aus XML-Datei
+ *
+ *
+ * @param xmlfile Pfad zur XML-Datei
+ * @param stylesheet Pfad zur XSL-Datei
+ * @param contenttype MIME Type
+ * @param filename Name Ausgabedatei
+ *
+ */
+ private static void transformFile(Maske maske, String xmlfile, String stylesheet, String contenttype,
+ String filename, MockHttpServletResponse mockResponse_par, String method) {
+ TransletUtils.initFactory("net.sf.saxon.TransformerFactoryImpl", null);
+ String stylesheetPath = getMyWEBINFFilePath() + File.separator + ".." + File.separator + "xml" + File.separator
+ + stylesheet;
+ if (method.equals("xls")) {
+ try {
+ XmlTransformer xt = new XmlTransformer(mockServletConfig, mock, mockResponse_par, null, null);
+
+ xt.setMandantenID(mandantenID);
+ xt.setMaske(maske);
+ String xml = StringUtils.readFile(new File(xmlfile));
+ if (contenttype.indexOf("excel") > -1) {
+ if (maske.isNewExcelExport()) {
+ xml = XmlTransformer.stripXml(xml);
+ }
+ xt.createExcelStandalone(xml, stylesheetPath, filename);
+ log.info("Datei " + filename + " erzeugt");
+ }
+ } catch (Exception e) {
+ log.severe("Fehler bei der Transformation:");
+ e.printStackTrace();
+ }
+ } else {
+
+ SxTransformer myTransformer = new SxTransformer(log);
+ try {
+ myTransformer.quellstring = xmlfile;
+ myTransformer.stylesheet = stylesheetPath;
+ myTransformer.outfile = filename;
+ if (fopxconfFile != null)
+ myTransformer.setFopxconfFile(fopxconfFile);
+ myTransformer.transformFile(method);
+ } catch (Exception e) {
+ log.severe("Fehler bei der Transformation:");
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public static String getMyWEBINFFilePath() {
+ return myWEBINFFilePath;
+ }
+
+ public static void setMyWEBINFFilePath(String myWEBINFFilePath) {
+ ExecuteMask.myWEBINFFilePath = myWEBINFFilePath;
+ }
+
+ public static String getMandantenID() {
+ return mandantenID;
+ }
+
+ public static void setMandantenID(String mandantenID) {
+ ExecuteMask.mandantenID = mandantenID;
+ }
+
+}
diff --git a/src/de/superx/bin/ExtractorForm.java b/src/de/superx/bin/ExtractorForm.java
new file mode 100644
index 0000000..e69de29
diff --git a/src/de/superx/bin/FMParser.java b/src/de/superx/bin/FMParser.java
new file mode 100644
index 0000000..2556099
--- /dev/null
+++ b/src/de/superx/bin/FMParser.java
@@ -0,0 +1,252 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.DatabaseMetaData;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.StringTokenizer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import de.memtext.db.ConnectionCreator;
+import de.memtext.util.DateUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.util.StringUtils;
+import de.superx.common.DBServletException;
+import de.superx.common.FieldContainer;
+import de.superx.common.Sichten;
+import de.superx.common.StandaloneSicht;
+import de.superx.common.SuperX_el;
+import de.superx.common.SxResultRow;
+import de.superx.common.SxResultSet;
+import de.superx.common.SxSqlHelper;
+import de.superx.common.SxUser;
+import de.superx.common.TableFieldExists;
+import de.superx.common.TemplateProcessor;
+import de.superx.servlet.SuperXManager;
+import de.superx.servlet.SxPools;
+import de.superx.servlet.SxSQL_Server;
+import de.superx.util.PropsReader;
+import de.superx.util.SqlStringUtils;
+
+public class FMParser extends TemplateProcessor {
+ private String dbprop, infile, outfile;
+ private Properties props;
+
+ private Statement stm;
+ private String isSimpleParser;
+ private static String sqlDialect;
+
+ FMParser() {
+ inServlet = true;
+
+ }
+
+ private void run() throws FileNotFoundException, IOException, Exception {
+ dbprop = GetOpts.getValue("-dbproperties:");
+ props = PropsReader.prepareProps(new File(dbprop));
+ infile = GetOpts.getValue("-in:");
+ outfile = GetOpts.getValue("-out:");
+ if (GetOpts.isPresent("-simpleParser"))
+ isSimpleParser = GetOpts.getValue("-simpleParser:");
+ String input = StringUtils.readFile(new File(infile));
+ String output = "";
+ if (isSimpleParser != null && isSimpleParser.equalsIgnoreCase("true")) {
+ output = simpleParser(dbprop, input);
+ } else {
+ initConAndParser();
+
+ sqlDialect = de.superx.util.SqlStringUtils.getSqlDialect(props
+ .getProperty("driverName"));
+
+ HashMap map = new HashMap();
+ map.put("TableFieldExists", new TableFieldExists(con));
+
+ output = "--automatically created by SuperX/Freemarker for "
+ + sqlDialect + " (" + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString() + ")\n"
+ + process("FM-Parsing " + infile, input, map, sqlDialect);
+ stm.close();
+ con.close();
+ }
+ StringUtils.write(new File(outfile), output);
+ }
+
+ private void initConAndParser() throws IOException, SQLException,
+ ClassNotFoundException {
+ super.con = ConnectionCreator.getConnectionCryptPassword(dbprop,
+ "driverName", "connectionURL", "connectionName",
+ "connectionPassword");
+
+ stm = con.createStatement();
+ if(SqlStringUtils.tableExists(con,"fm_templates",super.mandantid))
+ {
+ setTemplates(readFromDb("select trim(both from id),content from fm_templates"));
+ repositoryToMap(readFromDb(REPOSITORY_SELECT), repositoryMap);
+ }
+ if(SqlStringUtils.tableExists(con,"konstanten",super.mandantid))
+ {
+ SxResultSet rs = readFromDb("select trim(both from beschreibung),apnr from konstanten");
+ for (Iterator it = rs.iterator(); it.hasNext();) {
+ SxResultRow row = (SxResultRow) it.next();
+ String beschreibung = (String) row.get(0);
+
+ repositoryMap.put("K_" + beschreibung.trim(), row.get(1));
+ }
+ }
+ }
+
+
+
+ protected SxResultSet readFromDb(String sql) throws SQLException {
+ SuperX_el el = new SuperX_el();
+
+ SxSqlHelper sh=new SxSqlHelper();
+ sh.execute(sql, this.con, el);
+
+
+ if (el.getError_String() != null
+ && !el.getError_String().trim().equals(""))
+ throw new SQLException("\nProblem bei:" + "\n\n Meldung:"
+ + el.getError_String() + "\n sql:" + sql);
+
+ return el.getResultSet();
+
+
+ }
+
+
+
+
+
+ /**
+ * @deprecated
+ * @param sql
+ * @return
+ * @throws SQLException
+ */
+ protected SxResultSet readFromDbAlt(String sql) throws SQLException {
+ SxResultSet result = new SxResultSet();
+ ResultSet rs = stm.executeQuery(sql);
+
+ result.setColumnNames(rs.getMetaData());
+ int naturalOrder = 0;
+ while (rs.next()) {
+ SxResultRow row = new SxResultRow(
+ rs.getMetaData().getColumnCount(), naturalOrder++);
+ for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) {
+ if (rs.getMetaData().getColumnType(i) == java.sql.Types.LONGVARCHAR)
+ row.add(rs.getString(i));
+ else
+ row.add(rs.getObject(i));
+ }
+ result.add(row);
+ }
+ rs.close();
+ return result;
+ }
+
+ public static void main(String[] args) {
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-dbproperties,-in,-out");
+ if (isdrin != null) {
+ System.err.println("-dbproperties: -in: -out:");
+ System.exit(1);
+ }
+ try {
+ new FMParser().run();
+
+ } catch (Exception e) {
+ System.err.println("Fehler beim FM-Parsen ");
+ e.printStackTrace();
+ System.exit(1);
+ }
+
+ }
+
+ /*
+ * Einfacher Parser für Fremddatenbanken, nur sqlDialect wird übergeben wird
+ * von DOSQL direkt aufgerufen
+ */
+ public static String simpleParser(String dbprop, String input)
+ throws FileNotFoundException, IOException, Exception {
+ Properties props = PropsReader.prepareProps(new File(dbprop));
+ String output = "";
+ sqlDialect = de.superx.util.SqlStringUtils.getSqlDialect(props
+ .getProperty("driverName"));
+
+ HashMap map = new HashMap();
+ try {
+ output = "--automatically created by SuperX/Freemarker for "
+ + sqlDialect
+ + " ("
+ + DateUtils.getTodayString()
+ + " "
+ + DateUtils.getNowString()
+ + ")\n"
+ + new FMParser().process("FM-Parsing ", input, map,
+ sqlDialect);
+
+ } catch (Exception e) {
+ System.err.println("Fehler beim FM-Parsen ");
+ e.printStackTrace();
+ System.exit(1);
+ }
+ return output;
+
+ }
+/**
+ Methode war ursprünglich für direktes Einspielen einer einzelnen konkret mit name_intern benannten Sicht.
+ Jetzt erweitert, dass aufgebaute Sicht auch zurückgeliefert wird, damit eine sichtsequence aufgebaut werden kann
+ */
+ protected StandaloneSicht addSqlVarSicht(HashMap hmap, String varname, String name_intern,String gewuenschterStand)
+ throws SQLException {
+ String mandantenID="default"; // package de.superx.bin wird nur von Scripten gebraucht, MandantenID unerheblich
+ String sql = "select tid,name,label,'',beschreibung,quelle,standbutton,art \n"
+ + " ,type,alt_hier_id,treecfgtable,treecfgid,gueltig_seit,gueltig_bis,xmlmaxentries,name_intern,attribut1,attribut2,attribut3,cacheapplet,cachexml \n"
+ + "from sichten where name_intern='"
+ + name_intern
+ + "' and aktiv=1 order by type";
+ SxResultSet roh = new SxResultSet();
+ StandaloneSicht sicht=null;
+ roh = readFromDb(sql);
+ Sichten sichten = new Sichten();
+ SxUser user = new SxUser(mandantenID);
+ user.setAdmin(true); // Adminuser ok weil nur von DOSQL gebraucht
+ sichten.setUser(user);
+ for (Iterator iter = roh.iterator(); iter.hasNext();) {
+ SxResultRow row = (SxResultRow) iter.next();
+ Integer id = new Integer(1); // (Integer) row.get(0);
+
+ try {
+ sichten.initNonInternalSicht(mandantenID, StandaloneSicht.class,
+ row, id);
+ sicht = (StandaloneSicht) sichten.getById(id);
+ sicht.setConnection(con);
+ sicht.setSqlDialect(sqlDialect);
+
+ if (gewuenschterStand.trim().startsWith("today"))
+ gewuenschterStand = DateUtils.getTodayString();
+ sicht.setStand(new Hashtable(),hmap,new FieldContainer(),gewuenschterStand);
+ hmap.put(varname, sicht);
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new SQLException("Fehler beim Aufbau von Sicht "
+ + name_intern + " " + e);
+ }
+ }
+ return sicht;
+ }
+}
+
+// Created on 08.12.2006 at 18:03:46
+
diff --git a/src/de/superx/bin/Iso.java b/src/de/superx/bin/Iso.java
new file mode 100644
index 0000000..4ad0f43
--- /dev/null
+++ b/src/de/superx/bin/Iso.java
@@ -0,0 +1,7 @@
+package de.superx.bin;
+
+import javax.servlet.http.HttpServlet;
+
+public class Iso extends HttpServlet {
+
+}
diff --git a/src/de/superx/bin/KettleExecutor.java b/src/de/superx/bin/KettleExecutor.java
new file mode 100644
index 0000000..7e0d8be
--- /dev/null
+++ b/src/de/superx/bin/KettleExecutor.java
@@ -0,0 +1,199 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.pentaho.di.core.KettleEnvironment;
+import org.pentaho.di.core.exception.KettleException;
+
+import de.memtext.util.GetOpts;
+import de.superx.bin.fm.EtlStarter;
+import de.superx.common.DBServletException;
+import de.superx.common.SuperX_el;
+import de.superx.common.SxResultRow;
+import de.superx.common.SxResultSet;
+import de.superx.servlet.ServletUtils;
+import de.superx.servlet.SuperXManager;
+import de.superx.servlet.SxPools;
+
+public class KettleExecutor {
+ private String mandantenID;
+ private SxJob sxJob;
+ private boolean isPostgres = true;
+ private StringBuffer resultMessages=new StringBuffer("");
+ private Map jobParams = new HashMap();
+
+ public KettleExecutor(String mandantenID) {
+ this.mandantenID = mandantenID;
+ isPostgres = SxPools.get(mandantenID).getDatabaseAbbr().equals(("PG"));
+ }
+
+ public void setParams(Map jobParams) {
+ this.jobParams = jobParams;
+ }
+
+ public StringBuffer perform() throws IOException, SQLException, DBServletException {
+ try {
+ initSxJob();
+ EtlStarter es = new EtlStarter();
+ check_sql("vor");
+ resultMessages.append(es.kettleCallEmbedded(mandantenID, sxJob.getFilepath(), jobParams, isPostgres));
+ check_sql("nach");
+
+ } catch (Exception e) {
+ throw new IOException(e);
+ }
+ return resultMessages;
+ }
+
+ private void check_sql(String pos) throws SQLException, DBServletException {
+ if (sxJob.check_sql != null) {
+ SuperX_el el=ServletUtils.execute_el("check_sql "+pos+" Durchführung von Ladejob "+sxJob.getCaption(), sxJob.check_sql, false,mandantenID);
+ SxResultSet rs=el.getResultSet();
+ for (Iterator it = rs.iterator(); it.hasNext();) {
+ SxResultRow row = (SxResultRow) it.next();
+ Object erg = row.get(0);
+ if (erg!=null) {
+ resultMessages.append("Prüfselektion "+pos+" Durchführung von Ladejob "+sxJob.getCaption());
+ resultMessages.append("\n"+erg.toString()+"\n");
+ }
+ }
+ }
+
+ }
+
+
+ private void initSxJob() throws SQLException, DBServletException {
+ SxResultSet rs = ServletUtils.execute("Einlesen von SxJob)",
+ "select caption,filepath,params,check_sql from sx_jobs where tid=" + jobParams.get("Job"), mandantenID);
+ sxJob = new SxJob();
+ for (Iterator it = rs.iterator(); it.hasNext();) {
+ SxResultRow row = (SxResultRow) it.next();
+ sxJob.setCaption(row.get(0).toString());
+ sxJob.setFilepath("file://" + SuperXManager.getModuleDir() + File.separator + row.get(1).toString());
+ sxJob.setParams((String) row.get(2));
+ sxJob.setCheck_sql((String) row.get(3));
+ }
+ }
+
+ public static void main(String args[]) {
+ String usage="usage: -mandantenID:default -MODULE_PFAD:/home/superx/db/module -WEB_INF_PFAD:/home/superx/webserver/tomcat/webapps/superx/WEB-INF -job_uniquename:abc -path_to_uploadfile:/home/superx (optional)" ;
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts.isAllRequiredOptionsPresent("-mandantenID,-WEB_INF_PFAD,-MODULE_PFAD,-job_uniquename");
+ if (isdrin != null) {
+
+ System.err.println(usage);
+ System.exit(1);
+ }
+
+ String mandantenID = GetOpts.getValue("-mandantenID");
+ String job_uniquename=GetOpts.getValue("-job_uniquename");
+ SuperXManager.setWEB_INFPfad(GetOpts.getValue("-WEB_INF_PFAD"));
+ SuperXManager.setModuleDir(GetOpts.getValue("-MODULE_PFAD"));
+ String path_to_uploadfile="";
+ if (GetOpts.isPresent("-path_to_uploadfile"))
+ {
+ path_to_uploadfile=GetOpts.getValue("-path_to_uploadfile");
+ if (!new File(path_to_uploadfile).exists())
+ {
+ System.out.println("Fehler: Datei "+path_to_uploadfile+" nicht gefunden");
+ System.exit(-1);
+ }
+ }
+ try {
+ //muss vor SxPools init ausgeführt werden, sonst kann kein kettleDatabaseMeta-Objekt erzeugt werden java.lang.RuntimeException: Database type not found!
+ KettleEnvironment.init();
+
+ SxPools.init();
+ SxPools.get(mandantenID).init();
+ //SxPools.get(mandantenID).initLogging(true);
+ SxPools.resetAllPools();
+ } catch (Exception e) {
+ System.out.println("Fehler beim Datenbankverbindungsaufbau " + e);
+ e.printStackTrace();;
+
+ System.exit(-1);
+ }
+ try {
+ String jobtid=getJobTid(job_uniquename,mandantenID);
+ KettleExecutor ke = new KettleExecutor(mandantenID);
+ Map jobParams = new HashMap();
+ jobParams.put("Job", jobtid);
+ jobParams.put("PATH_TO_UPLOADFILE", path_to_uploadfile);
+ ke.setParams(jobParams);
+
+ ke.perform();
+ System.out.println("Keine Fehler aufgefallen");
+ } catch (Exception e) {
+
+ System.out.println("Fehler bei Verarbeitung " + e);
+ e.printStackTrace();
+ System.exit(-1);
+
+ }
+ }
+
+ private static String getJobTid(String job_uniquename,String mandantenID) throws SQLException, DBServletException {
+ String tid="";
+ String sql="select tid from sx_jobs where uniquename='"+job_uniquename+"'";
+ SxResultSet rs=ServletUtils.execute("Suche tid für sx_job mit uniquename "+job_uniquename, sql, mandantenID);
+ if (rs.size()==0)
+ throw new RuntimeException("Kein sx_job mit uniquename "+job_uniquename+" gefunden");
+ if (rs.size()>1)
+ throw new RuntimeException("Mehrere sx_jobs mit uniquename "+job_uniquename+" gefunden");
+
+ for (Iterator it = rs.iterator(); it.hasNext();) {
+ SxResultRow row = (SxResultRow) it.next();
+ Object erg = row.get(0);
+ if (erg!=null) tid=erg.toString();
+ }
+ return tid;
+ }
+
+ private class SxJob {
+ private String filepath;
+ private String params;
+ private String check_sql;
+ private String caption;
+ public String getCaption() {
+ return caption;
+ }
+
+ public void setCaption(String caption) {
+ this.caption = caption;
+ }
+
+ public String getFilepath() {
+ return filepath;
+ }
+
+ public void setFilepath(String filepath) {
+ this.filepath = filepath;
+ }
+
+ public String getParams() {
+ return params;
+ }
+
+ public void setParams(String params) {
+ this.params = params;
+ }
+
+ public String getCheck_sql() {
+ return check_sql;
+ }
+
+ public void setCheck_sql(String check_sql) {
+ this.check_sql = check_sql;
+ }
+
+
+
+ }
+
+}
diff --git a/src/de/superx/bin/MaskenSqlUpdater.java b/src/de/superx/bin/MaskenSqlUpdater.java
new file mode 100644
index 0000000..e7dc73c
--- /dev/null
+++ b/src/de/superx/bin/MaskenSqlUpdater.java
@@ -0,0 +1,54 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.Statement;
+
+import de.memtext.db.ConnectionCreator;
+import de.memtext.util.DateUtils;
+import de.memtext.util.StringUtils;
+
+public class MaskenSqlUpdater {
+
+ public static void main(String[] args) {
+ if (args.length != 3) {
+ System.out
+ .println("usage: MaskenSqlUpdater DB_PROPERTIES maskennummer sourcefile");
+ System.exit(1);
+ }
+ Connection con = null;
+ int tid = Integer.parseInt(args[1]);
+ try {
+ con = ConnectionCreator.getConnectionCryptPassword(args[0],
+ "driverName", "connectionURL", "connectionName",
+ "connectionPassword");
+ } catch (Exception e) {
+ System.out
+ .println("ERROR: Verbindung konnte nicht aufgebaut werden.\n"
+ + e);
+ System.exit(1);
+ }
+ try {
+ String sql = StringUtils.readFile(new File(args[2]));
+
+ Statement stm = con.createStatement();
+ PreparedStatement pst = con
+ .prepareStatement("update maskeninfo set select_stmt=? where tid=?");
+ pst.setString(1, sql);
+ pst.setInt(2, tid);
+ int rows=pst.executeUpdate();
+
+
+ if (rows==0) throw new IllegalArgumentException("Wahrscheinlich gibt es keine Maske mit der tid "+tid);
+ System.out.println("update erfolgreich auf "+con.getMetaData().getURL() +" um "+DateUtils.getNowString());
+ stm.close();
+ con.close();
+ } catch (Exception e) {
+ System.out.println("ERROR:"+e);
+
+ }
+ }
+}
+
+//Created on 12.04.2005 at 11:14:26
diff --git a/src/de/superx/bin/PasswdUpdater.java b/src/de/superx/bin/PasswdUpdater.java
new file mode 100644
index 0000000..c168681
--- /dev/null
+++ b/src/de/superx/bin/PasswdUpdater.java
@@ -0,0 +1,91 @@
+package de.superx.bin;
+
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+import de.memtext.util.CryptUtils;
+/**
+ * Alte Kennwortverschlüsselung auf neue mit Geheimnis umsetzten, wird nicht mehr verwenden
+ * @deprecated
+ * @author superx
+ *
+ */
+public class PasswdUpdater {
+ public static void main(String[] args) throws IOException {
+ if (args.length != 1) {
+ System.out.println("PasswdUpdater /path/to/db.properties");
+ System.exit(1);
+
+ }
+ String dbpropfile = args[0];
+ try {
+ passwdUpdate(dbpropfile);
+ System.out.println("Passwortaktualisierung erfolgreich");
+ } catch (Exception e) {
+ System.out.println("Fehler : " + e);
+ e.printStackTrace();
+
+ }
+
+ }
+
+ private static void passwdUpdate(String dbpropfile) throws Exception {
+ SxConnection myConnection = new SxConnection();
+ myConnection.setPropfile(dbpropfile);
+ Connection con = myConnection.getConnection();
+ Statement stm = con.createStatement();
+ PreparedStatement pst = con.prepareStatement("update userinfo set passwd_sha=? where tid=?");
+ ResultSet rs = stm.executeQuery("select tid,benutzer,kennwort from userinfo");
+ while (rs.next()) {
+ int tid = rs.getInt(1);
+ // String benutzer = rs.getString(2).trim();
+ String kennwortspalte = rs.getString(3);
+ if (kennwortspalte == null)
+ continue;
+ else
+ kennwortspalte = kennwortspalte.trim();
+ String kennwort = new String(base64decode(kennwortspalte));
+ // System.out.println(kennwort);
+ String sha = CryptUtils.encodeSHA(kennwort + CryptUtils.geheimnis1);
+ // System.out.println(sha);
+ pst.setString(1, sha);
+ pst.setInt(2, tid);
+ pst.execute();
+ // System.out.println("User tid "+tid+" ("+benutzer+") Inhalt von Kennwortspalte ist nicht base64 codiert");
+
+ }
+ rs.close();
+ stm.close();
+ pst.close();
+ con.close();
+ }
+
+ /**
+ *
+ * @param s
+ * @return
+ * @throws IOException
+ */
+ public static String base64decode(String s) throws IOException {
+ // String s = new BASE64Encoder().encode( test.getBytes() );
+ // System.out.println( s );
+ // anfang12 String test="YW5mYW5nMTI=";
+ // Zum Beispiel:
+ // QFgwDyiQ28/4GsF75fqLMj/bAIWNwOuBmE/SCl3H2XQFpSsSz0jtyR0LU+kLiwWsnSUZljJr97Hy
+ // LA3YUbf96Ym2zx9F9Y1N7P5lsOCb/vr2crTQ/gXs757qaJF9E3szMN+E0CSSslDrrzcNBrlcQg==
+ // String in byte[]
+
+
+ //Mthode von Sun nicht mehr unterstützt
+ //byte[] bytes2 = new sun.misc.BASE64Decoder().decodeBuffer(s);
+
+
+
+ // System.out.println( Arrays.equals(bytes1, bytes2) ); // true
+ // System.out.println(new String(bytes2).trim());
+ return "ERROR" ; //new String(bytes2);
+ }
+}
diff --git a/src/de/superx/bin/Pgcheck.java b/src/de/superx/bin/Pgcheck.java
new file mode 100644
index 0000000..0ace29e
--- /dev/null
+++ b/src/de/superx/bin/Pgcheck.java
@@ -0,0 +1,34 @@
+package de.superx.bin;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.Statement;
+
+public class Pgcheck {
+
+ /**
+ * @param args
+ */
+ public static void main(String[] args) {
+System.out.println("INFO: argumente connectionURL username [passwd]");
+if (args.length>=2)
+{
+try {
+ System.out.println("Teste Verbindung ...");
+ Class.forName("org.postgresql.Driver");
+ String passwd="dummy";
+ if (args.length>2) passwd=args[2];
+ Connection conn = DriverManager.getConnection(args[0],args[1], passwd);
+ Statement st=conn.createStatement();
+ System.out.println("Verbindung erfolgreich");
+ st.close();
+ conn.close();
+ }
+catch (Exception e)
+{
+ System.out.println(e);
+}}
+
+ }}
+
+//Created on 19.02.2009 at 11:34:00
\ No newline at end of file
diff --git a/src/de/superx/bin/PropAdmin.java b/src/de/superx/bin/PropAdmin.java
new file mode 100644
index 0000000..77d0cd5
--- /dev/null
+++ b/src/de/superx/bin/PropAdmin.java
@@ -0,0 +1,620 @@
+package de.superx.bin;
+
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.LinkedList;
+import java.util.Properties;
+
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPasswordField;
+import javax.swing.JTextField;
+
+import de.memtext.util.CryptUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.widgets.LabeledComboBox;
+import de.memtext.widgets.LabeledTextField;
+import de.memtext.widgets.RadioButtonGroup;
+import de.memtext.widgets.VerticalBox;
+import de.memtext.widgets.WarningMessage;
+import de.superx.util.ConnectionDialogCommon;
+import de.superx.util.SqlStringUtils;
+
+public class PropAdmin extends JFrame implements ActionListener, ItemListener {
+ static Container cp;
+ static LinkedList logLevels = new LinkedList();
+ static JTextField tAdminPasswd, tdriver, turl, tadminUser, tRestrictedUser,
+ tRestrictedPassword;
+ static LabeledTextField ltfMaskCache;
+ static LabeledTextField ltfUserCache;
+ static JComboBox tname;
+ static LabeledComboBox sqlLogLevel, xmlLogLevel;
+ static LabeledTextField maxActive;
+
+ static LabeledTextField minIdle;
+ static LabeledTextField maxIdle;
+ static RadioButtonGroup rbEntwicklungsmodus = new RadioButtonGroup();
+ static private String defaultDBDriver = "com.informix.jdbc.IfxDriver";
+
+ static private String defaultConnection = "jdbc:informix-sqli://<>:<>:informixserver=<>;database=superx";
+
+ static private String defaultUser = "superx";
+
+ private static String dbpropfile = "db.properties";
+
+ static private String connTypes[][];
+
+ private static boolean isGuiWanted = true;
+
+ static Properties props = new Properties();
+
+ static byte key[] = { (byte) 255, (byte) 221, (byte) 127, (byte) 109,
+ (byte) 129 };
+
+ static int keyLength = key.length;
+
+ private static String usage = "-------------------------------------\nGebrauch: java de.superx.bin.PropAdmin -dbproperties:<>(optional) \n---------------------------------------------------";
+
+ // private static String newAdminPassword;
+
+ public PropAdmin() {
+ super("DB-Properties Admin @version@");
+ ltfMaskCache = new LabeledTextField("Masken, die im Cache sein sollen",
+ "select tid from maskeninfo where 1=0", 50);
+ ltfUserCache = new LabeledTextField("User, die im Cache sein sollen",
+ "select tid from userinfo where 1=0", 50);
+ maxActive = new LabeledTextField("maxActive", 3);
+ minIdle = new LabeledTextField("minIdle", 3);
+ maxIdle = new LabeledTextField("maxIdle", 3);
+
+ sqlLogLevel = new LabeledComboBox("Log Level SQL", logLevels);
+ xmlLogLevel = new LabeledComboBox("Log Level XML", logLevels);
+ sqlLogLevel.setSelectedIndex(1);
+ xmlLogLevel.setSelectedIndex(1);
+ rbEntwicklungsmodus.add(new JLabel("Entwicklungsmodus "));
+ rbEntwicklungsmodus.add("an");
+ rbEntwicklungsmodus.add("aus");
+ rbEntwicklungsmodus.setSelection("an");
+ JButton btnTestAdmin = new JButton("Verbindung testen");
+ btnTestAdmin.addActionListener(this);
+
+ cp = this.getContentPane();
+ cp.setLayout(new BorderLayout());
+ JPanel titel = new JPanel();
+ JLabel ltitel = new JLabel("DB-Properties Admin für " + dbpropfile);
+ ltitel.setFont(new Font("Courier", Font.BOLD, 14));
+ titel.add(ltitel);
+ cp.add(titel, "North");
+ VerticalBox center = new VerticalBox();
+ JPanel p0 = new JPanel(new FlowLayout(FlowLayout.LEFT));
+
+ tname = new JComboBox();
+
+ connTypes = ConnectionDialogCommon.getTypes();
+
+ for (int i = 0; i < connTypes.length; i++) {
+ tname.addItem(connTypes[i][0]);
+ }
+ // controls.add(types);
+
+ JLabel lname = new JLabel(" Driver :");
+ lname.setFont(new Font("Courier", Font.BOLD, 12));
+ // tname=new JTextField(30);
+ JLabel c_name = new JLabel("(mögliche Datenbanksysteme für SuperX)");
+ p0.add(lname);
+ p0.add(tname);
+ p0.add(c_name);
+ center.add(p0);
+ // JPanel center=new JPanel(new GridLayout(0,1));
+ JPanel p1 = new JPanel(new FlowLayout(FlowLayout.LEFT));
+ JLabel ldriver = new JLabel(" Driver Class:");
+ ldriver.setFont(new Font("Courier", Font.BOLD, 12));
+ tdriver = new JTextField(30);
+ JLabel c_driver = new JLabel("(muss im CLASSPATH stehen!)");
+ p1.add(ldriver);
+ p1.add(tdriver);
+ p1.add(c_driver);
+ center.add(p1);
+
+ JPanel p1b = new JPanel(new FlowLayout(FlowLayout.LEFT));
+ JLabel lurl = new JLabel(" Connection URL:");
+ lurl.setFont(new Font("Courier", Font.BOLD, 12));
+ turl = new JTextField(50);
+ p1b.add(lurl);
+ p1b.add(turl);
+ center.add(p1b);
+
+ JPanel p3 = new JPanel(new FlowLayout(FlowLayout.LEFT));
+ JLabel luser = new JLabel(" Username:");
+ luser.setFont(new Font("Courier", Font.BOLD, 12));
+ tadminUser = new JTextField(10);
+ JLabel lpasswd = new JLabel(" Password:");
+ lpasswd.setFont(new Font("Courier", Font.BOLD, 12));
+ tAdminPasswd = new JPasswordField(10);
+ p3.add(luser);
+ p3.add(tadminUser);
+ p3.add(lpasswd);
+ p3.add(tAdminPasswd);
+ p3.add(btnTestAdmin);
+ center.add(p3);
+ JPanel p3b = new JPanel(new FlowLayout(FlowLayout.LEFT));
+ JLabel lbl33 = new JLabel(" Eingeschränkter User:");
+ lbl33.setFont(new Font("Courier", Font.BOLD, 12));
+ p3b.add(lbl33);
+
+ tRestrictedUser = new JTextField(10);
+ p3b.add(tRestrictedUser);
+ tRestrictedPassword = new JPasswordField(10);
+ p3b.add(new JLabel("Passwort"));
+ p3b.add(tRestrictedPassword);
+ JButton btnTest2 = new JButton("Verb.testen");
+ btnTest2.addActionListener(this);
+ JButton btnSelectRights = new JButton("select-Rechte auf alle Tabellen");
+ btnSelectRights.addActionListener(this);
+
+ p3b.add(btnTest2);
+ p3b.add(btnSelectRights);
+ center.add(p3b);
+ center.add(sqlLogLevel);
+ center.add(xmlLogLevel);
+ center.addWithLeftAlignment(rbEntwicklungsmodus);
+ center
+ .addWithLeftAlignment(new JLabel(
+ "(Im Entwicklungsmodus werden alle SQL-Befehle von Abfragen einzeln an die Datenbank geschickt.
Das dauert etwas länger, ermöglicht aber bessere Fehlermeldungen.)
"));
+
+ center.add(ltfMaskCache);
+ center.add(ltfUserCache);
+
+ JPanel p4 = new JPanel();
+ p4
+ .add(new JLabel(
+ "Der Apache ConnectionPool verwaltet die Anzahl benötigter Verbindungen dynamisch.
min/max idle gibt an wieviele Connections ständig bereit gehalten werden sollen.
maxActive gibt an wieviele Connections maximal gleichzeitig aktiv sein sollen."));
+ center.add(p4);
+ JPanel p5 = new JPanel();
+ p5.add(minIdle);
+ p5.add(maxIdle);
+ p5.add(maxActive);
+ center.add(p5);
+ cp.add(center, "Center");
+ JButton OK = new JButton("Speichern");
+ OK.addActionListener(this);
+ JPanel unten = new JPanel();
+
+ unten.add(OK);
+ cp.add(unten, "South");
+ addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent e) {
+ System.exit(0);
+ }
+ });
+
+ tname.addItemListener(this);
+
+ this.pack();
+ }
+
+ private static void properties_einlesen() throws IOException {
+ if (!isGuiWanted)
+ System.out.println("Lese ein: " + dbpropfile);
+ props = new Properties();
+ FileInputStream is = new FileInputStream(dbpropfile);
+
+ if (is != null) {
+ props.load(is);
+ is.close();
+ } else {
+ if (isGuiWanted)
+ JOptionPane.showMessageDialog(null,
+ "Kann Properties nicht einlesen.", "DB-Prop Admin",
+ JOptionPane.INFORMATION_MESSAGE);
+ System.out.println("kann properties nicht einlesen");
+ }
+ // System.out.println(CryptUtils.decryptSimple(props.getProperty(
+ // "connectionPassword")));
+ }
+
+ private static void initFormFromProps() {
+ String tdriverclass = props.getProperty("driverName");
+ tdriver.setText(tdriverclass);
+
+ // if(props.getProperty( "connectionURL" ).equals(""))
+ // {
+ // Default-Url:
+ for (int i = 0; i < connTypes.length; i++) {
+ if (tdriverclass.equals(connTypes[i][1])) {
+ tname.setSelectedIndex(i);
+ }
+ }
+ if (props.getProperty("connectionURL") != null)
+ turl.setText(props.getProperty("connectionURL"));
+ // }
+ tadminUser.setText(props.getProperty("connectionName"));
+ tRestrictedUser.setText(props.getProperty("restrictedConnectionName"));
+
+ if (props.getProperty("logLevelSQL") != null)
+ sqlLogLevel.setSelectedItem(props.getProperty("logLevelSQL"));
+ if (props.getProperty("logLevelXML") != null)
+ xmlLogLevel.setSelectedItem(props.getProperty("logLevelXML"));
+ if (props.getProperty("maskCache") != null)
+ ltfMaskCache.setValue(props.getProperty("maskCache"));
+ if (props.getProperty("userCache") != null)
+ ltfUserCache.setValue(props.getProperty("userCache"));
+ if (props.getProperty("minIdle") != null)
+ minIdle.setValue(props.getProperty("minIdle"));
+ else
+ minIdle.setValue("5");
+ if (props.getProperty("maxIdle") != null)
+ maxIdle.setValue(props.getProperty("maxIdle"));
+ if (props.getProperty("maxActive") != null)
+ maxActive.setValue(props.getProperty("maxActive"));
+ if (props.getProperty("developmentMode") == null
+ || props.getProperty("developmentMode").equals("true"))
+ rbEntwicklungsmodus.setSelection("an");
+ else
+ rbEntwicklungsmodus.setSelection("aus");
+ }
+
+ public void actionPerformed(ActionEvent event) {
+ String cmd = event.getActionCommand();
+ if (cmd.equals("Speichern"))
+
+ {
+ try {
+ formValuesToProps();
+ saveProps();
+ System.exit(0);
+ } catch (Exception e) {
+ System.out.println("Es ist ein Fehler aufgetreten.");
+ e.printStackTrace();
+ WarningMessage.show(null, "Fehler: " + e, "SuperX");
+ }
+
+ }
+ if (cmd.equals("Verbindung testen")) {
+ try {
+ formValuesToProps();
+ boolean isOk = testConnection(props
+ .getProperty("connectionName"), tAdminPasswd.getText());
+
+ } catch (Exception e) {
+ WarningMessage.show(null, "Fehler:" + e, "PropAdmin");
+ }
+ }
+ if (cmd.equals("Verb.testen")) {
+ try {
+ formValuesToProps();
+ testConnection(props.getProperty("restrictedConnectionName"),
+ tRestrictedPassword.getText());
+
+ } catch (Exception e) {
+ WarningMessage.show(null, "Fehler:" + e, "PropAdmin");
+ }
+ }
+ if (cmd.equals("select-Rechte auf alle Tabellen")) {
+ try {
+ if (tRestrictedUser.getText() == null
+ || tRestrictedUser.getText().trim().equals(""))
+ throw new IllegalArgumentException(
+ "Eingeschränkter user muss angegeben sein");
+ if (tadminUser.getText() == null
+ || tadminUser.getText().trim().equals(""))
+ throw new IllegalArgumentException(
+ "User muss angegeben sein");
+ if (tAdminPasswd.getText() == null
+ || tAdminPasswd.getText().trim().equals(""))
+ throw new IllegalArgumentException(
+ "Userpassword muss angegeben sein");
+ // int result=JOptionPane.showConfirmDialog(this,
+ // "Wollen Sie dem eingeschränktem User select-Rechte auf alle Tabellen geben?"
+ // ,"PropAdmin",JOptionPane.YES_NO_OPTION);
+ // if (result==JOptionPane.YES_OPTION)
+ grantSelectToRestrictedUser();
+
+ } catch (Exception e) {
+ WarningMessage.show(null, "Fehler:" + e, "PropAdmin");
+ }
+ }
+
+ }
+
+ private void grantSelectToRestrictedUser() throws Exception {
+ Class.forName(props.getProperty("driverName"));
+
+ Connection conn = DriverManager.getConnection(props
+ .getProperty("connectionURL"), tadminUser.getText(),
+ tAdminPasswd.getText());
+ Statement stm = conn.createStatement();
+ ResultSet rs = null;
+ if (props.getProperty("driverName").indexOf("postgres") > -1)
+ rs = conn.getMetaData().getTables(null, null, null, null);
+ else
+ rs = conn.getMetaData().getTables("superx", "superx", null, null);
+ while (rs.next()) {
+ System.out.println(rs.getObject(3).toString());
+ if (rs.getString(4) != null
+ && (rs.getString(4).equals("TABLE") || rs.getString(4)
+ .equals("VIEW")))
+ stm.execute("grant select on " + rs.getObject(3).toString()
+ + " to " + tRestrictedUser.getText() + ";");
+ }
+ rs.close();
+ stm.close();
+ conn.close();
+ }
+
+ private static boolean testConnection(String username, String password) {
+ boolean result = false;
+ try {
+ Class.forName(props.getProperty("driverName"));
+ if (props.getProperty("driverName").indexOf("postgres") > -1) {
+ props.put("charSet", SqlStringUtils.getEncoding().equals(
+ "xUTF-8") ? "UTF-8" : "Latin-1");
+ props.put("DateStyle", "German, DMY");
+ } else // Informix
+ {
+ props.put("GL_DATETIME", "%d.%m.%Y %T");
+ props.put("CLIENT_LOCALE", SqlStringUtils.getEncoding().equals(
+ "xUTF-8") ? "UTF-8" : "de_de.8859-1");
+ }
+ Connection conn = DriverManager.getConnection(props
+ .getProperty("connectionURL"), username, password);
+ DatabaseMetaData dbmd = conn.getMetaData();
+
+ /*
+ * am 19.1.2006 auskommentiert, weil propadmin auch für DBen ausser
+ * superx genutzt wird. dq Statement stm=conn.createStatement(); if
+ * (props.getProperty("driverName").indexOf("postgres")>-1)
+ *
+ * stm.executeQuery("select date('1.1.2005');"); else
+ * stm.executeQuery("select 'xx' from xdummy");
+ */
+ String msg = "Verbindung mit Datenbank " + conn.getCatalog() + " ("
+ + dbmd.getDatabaseProductName() + " "
+ + dbmd.getDatabaseProductVersion() + ") als " + username
+ + " erfolgreich aufgebaut";
+ if (isGuiWanted)
+ JOptionPane.showMessageDialog(null, msg, "DB-Prop Admin",
+ JOptionPane.INFORMATION_MESSAGE);
+ else
+ System.out.println(msg);
+ // stm.close();
+ conn.close();
+ result = true;
+ } catch (Exception e) {
+ String msg = "Ein Fehler ist aufgetreten.\n" + e.toString();
+ if (props.getProperty("driverName").indexOf("postgres") > -1
+ && e.toString().indexOf("Date Style") > -1) {
+ msg += "\nPrüfen Sie,ob Date Style auf dem Server auf German, DMY steht.";
+ }
+ if (isGuiWanted)
+ JOptionPane.showMessageDialog(null, msg, "DB-Prop Admin",
+ JOptionPane.WARNING_MESSAGE);
+ else
+ System.out.println("Fehler: " + e.toString());
+
+ }
+ return result;
+ }
+
+ private static void formValuesToProps() throws Exception {
+
+ String driver = tdriver.getText();
+ String name = tadminUser.getText();
+ String passwd = tAdminPasswd.getText();
+ String url = turl.getText();
+
+ if (driver == null || name == null || passwd == null || url == null
+ || driver.equals("") || name.equals("") || url.equals("")) {
+ if (isGuiWanted)
+ JOptionPane.showMessageDialog(null,
+ "Bitte alle Felder ausfüllen!", "DB-Prop Admin",
+ JOptionPane.INFORMATION_MESSAGE);
+ return;
+ }
+
+ props.setProperty("connectionPassword", "sx_des"
+ + CryptUtils.encryptStringDES(tAdminPasswd.getText()));
+ props.setProperty("connectionName", name);
+ props
+ .setProperty("restrictedConnectionName", tRestrictedUser
+ .getText());
+ if (tRestrictedPassword.getText() != null
+ && tRestrictedPassword.getText().length() > 1)
+ props.setProperty("restrictedConnectionPassword", "sx_des"
+ + CryptUtils
+ .encryptStringDES(tRestrictedPassword.getText()));
+
+ props.setProperty("connectionURL", url);
+ props.setProperty("driverName", driver);
+ props.setProperty("minIdle", (String) minIdle.getValue());
+ props.setProperty("maxIdle", (String) maxIdle.getValue());
+ props.setProperty("maxActive", (String) maxActive.getValue());
+ props.setProperty("maskCache", (String) ltfMaskCache.getValue());
+ props.setProperty("userCache", (String) ltfUserCache.getValue());
+ props.setProperty("logLevelSQL", sqlLogLevel.getSelectedItem()
+ .toString());
+ props.setProperty("logLevelXML", xmlLogLevel.getSelectedItem()
+ .toString());
+ props.setProperty("developmentMode", rbEntwicklungsmodus
+ .getSelectedName().equals("an") ? "true" : "false");
+
+ }
+
+ private static void saveProps() {
+ try {
+ props.remove("charSet");
+ props.remove("DateStyle");
+
+ props.remove("GL_DATETIME");
+ props.remove("CLIENT_LOCALE");
+ OutputStream os = new FileOutputStream(dbpropfile);
+ props.store(os, "SuperX DB.properties");
+ os.close();
+ System.out.println("Änderung gespeichert in " + dbpropfile);
+
+ } catch (IOException e) {
+ String fehler = "Konnte db.properties-Datei nicht speichern:"
+ + e.toString();
+ if (isGuiWanted)
+ JOptionPane.showMessageDialog(null, fehler, "DB-Prop Admin",
+ JOptionPane.WARNING_MESSAGE);
+ System.out.println(e.toString());
+ System.exit(1);
+ }
+ }
+
+ public static void main(String args[]) {
+ logLevels.add("SEVERE");
+ logLevels.add("WARNING");
+ logLevels.add("INFO");
+ logLevels.add("FINE");
+ logLevels.add("FINER");
+ logLevels.add("FINEST");
+ System.out.println("Umgebungsvariable LANG: "
+ + System.getProperty("file.encoding"));
+ if (System.getProperty("file.encoding").toLowerCase().endsWith("utf8")) {
+ System.out
+ .println("Achtung: Ihre Default-Dateicodierung nutzt einen Zeichensatz (UTF8), der die Verschlüsselung nicht unterstützt.");
+ System.out
+ .println("Bitte setzen Sie Ihre Umgebungsvariable LANG auf eine deutsche LOCALE (z.B. de_DE@euro");
+ System.exit(1);
+ }
+ GetOpts.setOpts(args);
+ PropAdmin propAdmin = null;
+ if (GetOpts.isPresent("-dbproperties"))
+ dbpropfile = GetOpts.getValue("-dbproperties");
+
+ if (GetOpts.isPresent("-nogui") || GetOpts.isPresent("-no-gui")
+ || GetOpts.isPresent("--no-gui")) {
+ isGuiWanted = false;
+ } else {
+ try {
+ // wenn keine graphische Umgebung verfügbar ist
+ // tritt ein Fehler auf.
+ JFrame f = new JFrame();
+
+ } catch (Throwable e) {
+ System.out
+ .println("Keine graphische Umgebung verfuegbar - starte Shell-Modus");
+ isGuiWanted = false;
+ }
+ if (isGuiWanted)
+ propAdmin = new PropAdmin();
+ }
+
+ try {
+ properties_einlesen();
+ if (isGuiWanted) {
+ initFormFromProps();
+ }
+ } catch (IOException e) {
+ String fehler = "Konnte db.properties-Datei nicht finden.\nEs wird eine neue in \n"
+ + dbpropfile + " \nangelegt.";
+ if (isGuiWanted) {
+ JOptionPane.showMessageDialog(null, fehler, "DB-Prop Admin",
+ JOptionPane.INFORMATION_MESSAGE);
+ System.out.println(fehler);
+ tdriver.setText(defaultDBDriver);
+ tadminUser.setText(defaultUser);
+ turl.setText(defaultConnection);
+
+ } else {
+ System.out
+ .println("Sie koennen nur bestehende db.properties Dateien bearbeiten.");
+ System.out
+ .println("Geben Sie den Parameter -dbproperties:/home/superx/../db.properties an");
+ System.out.println(e);
+ System.exit(1);
+ }
+ }
+
+ if (isGuiWanted) {
+ propAdmin.show();
+ } else {
+ noGuiEdit();
+
+ }
+ }
+
+ private static void noGuiEdit() {
+ try {
+ BufferedReader br = new BufferedReader(new InputStreamReader(
+ System.in));
+
+ System.out
+ .println("Die meisten Paramter koennen Sie mit dem vi bearbeiten.");
+ System.out
+ .print("Passwort für uneingeschränkten User (erscheint auf Bildschirm!): ");
+
+ String newAdminPassword = br.readLine();
+ System.out.println();
+ // System.out.println("you entered: " + pass);
+
+ if (testConnection(props.getProperty("connectionName"),
+ newAdminPassword)) {
+ System.out.print("Einen Moment - Verschlüsselung läuft ...");
+ props.setProperty("connectionPassword", "sx_des"
+ + CryptUtils.encryptStringDES(newAdminPassword));
+ System.out.println(" OK");
+ saveProps();
+ }
+ if (props.getProperty("restrictedConnectionName") != null) {
+ System.out
+ .print("Passwort für eingeschraenkten User (erscheint auf Bildschirm!): ");
+
+ String newPassword = br.readLine();
+
+ System.out.println();
+
+ if (testConnection(props
+ .getProperty("restrictedConnectionName"), newPassword)) {
+ System.out
+ .print("Einen Moment - Verschlüsselung läuft ...");
+ props.setProperty("restrictedConnectionPassword", "sx_des"
+ + CryptUtils.encryptStringDES(newPassword));
+ System.out.println(" OK");
+ saveProps();
+ }
+ }
+ System.exit(0);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void itemStateChanged(ItemEvent e) {
+
+ String s = (String) e.getItem();
+
+ for (int i = 0; i < connTypes.length; i++) {
+ if (s.equals(connTypes[i][0])) {
+ tdriver.setText(connTypes[i][1]);
+ // if(turl.getText().indexOf( ">>") < 0)
+ turl.setText(connTypes[i][2]);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/Psql.java b/src/de/superx/bin/Psql.java
new file mode 100644
index 0000000..9b8ccaa
--- /dev/null
+++ b/src/de/superx/bin/Psql.java
@@ -0,0 +1,255 @@
+package de.superx.bin;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.StreamTokenizer;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+/*
+ * This example application demonstrates some of the drivers other features
+ * by implementing a simple psql replacement in Java.
+ *
+ */
+
+public class Psql
+{
+ Connection db; // The connection to the database
+ Statement st; // Our statement to run queries with
+ DatabaseMetaData dbmd; // This defines the structure of the database
+ boolean done = false; // Added by CWJ to permit \q command
+ String delim = "\t";
+ String header="false";
+
+ public Psql(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException
+ {
+
+ if (args.length > 0)
+ {
+ delim=args[0].trim();
+
+ }
+ if (args.length > 0)
+ {
+ header=args[1].trim();
+
+ }
+ SxConnection myConnection = new SxConnection();
+ try
+ {
+ Connection myDb=myConnection.getConnection();
+ st=myDb.createStatement();
+ dbmd = myDb.getMetaData();
+ st = myDb.createStatement();
+ }
+ catch (Exception e)
+ {
+ System.err.println("Keine DB-Verbindung: "+e.toString());
+ }
+
+ // This prints the backend's version
+ System.out.println("Connected to " + dbmd.getDatabaseProductName() + " " + dbmd.getDatabaseProductVersion());
+
+ System.out.println();
+
+ // This provides us the means of reading from stdin
+ StreamTokenizer input = new StreamTokenizer(new InputStreamReader(System.in));
+ input.resetSyntax();
+ input.slashSlashComments(true); // allow // as a comment delimiter
+ input.eolIsSignificant(false); // treat eol's as spaces
+ input.wordChars(32, 126);
+ input.whitespaceChars(59, 59);
+ // input.quoteChar(39); *** CWJ: messes up literals in query string ***
+
+ // Now the main loop.
+ int tt = 0, lineno = 1;
+ while (tt != StreamTokenizer.TT_EOF && ! done)
+ {
+ System.out.print("[" + lineno + "] ");
+ System.out.flush();
+
+ // Here, we trap SQLException so they don't terminate the application
+ try
+ {
+ if ((tt = input.nextToken()) == StreamTokenizer.TT_WORD)
+ {
+ processLine(input.sval);
+ lineno++;
+ }
+ }
+ catch (SQLException ex)
+ {
+ System.out.println(ex.getMessage());
+ }
+ }
+
+ System.out.println("Now closing the connection");
+ st.close();
+ db.close();
+ }
+
+ /*
+ * This processes a statement
+ */
+ public void processLine(String line) throws SQLException
+ {
+ if (line.startsWith("\\"))
+ {
+ processSlashCommand(line);
+ return ;
+ }
+
+ boolean type = st.execute(line);
+ boolean loop = true;
+ while (loop)
+ {
+ if (type)
+ {
+ // A ResultSet was returned
+ ResultSet rs = st.getResultSet();
+ displayResult(rs);
+ }
+ else
+ {
+ int count = st.getUpdateCount();
+
+ if (count == -1)
+ {
+ // This indicates nothing left
+ loop = false;
+ }
+ else
+ {
+ // An update count was returned
+ System.out.println("Updated " + st.getUpdateCount() + " rows");
+ }
+ }
+
+ if (loop)
+ type = st.getMoreResults();
+ }
+ }
+
+ /*
+ * This displays a result set.
+ * Note: it closes the result once complete.
+ */
+ public void displayResult(ResultSet rs) throws SQLException
+ {
+ ResultSetMetaData rsmd = rs.getMetaData();
+ int cols = rsmd.getColumnCount();
+ // Print the result column names
+ if(header.equals("true"))
+ {
+ for (int i = 1;i <= cols;i++)
+ System.out.print(rsmd.getColumnLabel(i) + (i < cols ? delim : "\n"));
+ }
+
+ // now the results
+ while (rs.next())
+ {
+ for (int i = 1;i <= cols;i++)
+ {
+ Object o = rs.getObject(i);
+ if (rs.wasNull())
+ System.out.print("{null}" + (i <= cols ? delim : "\n"));
+ else
+ System.out.print(o.toString() + (i <= cols ? delim : "\n"));
+ }
+ }
+
+ // finally close the result set
+ rs.close();
+ }
+
+ /*
+ * This process / commands (for now just /d)
+ */
+ public void processSlashCommand(String line) throws SQLException
+ {
+ if (line.startsWith("\\d"))
+ {
+
+ if (line.startsWith("\\d "))
+ {
+ // Display details about a table
+ String table = line.substring(3);
+ displayResult(dbmd.getColumns(null, null, table, "%"));
+ }
+ else
+ {
+ String types[] = null;
+ if (line.equals("\\d"))
+ types = allUserTables;
+ else if (line.equals("\\di"))
+ types = usrIndices;
+ else if (line.equals("\\dt"))
+ types = usrTables;
+ else if (line.equals("\\ds"))
+ types = usrSequences;
+ else if (line.equals("\\dS"))
+ types = sysTables;
+ else
+ throw new SQLException("Unsupported \\d command: " + line);
+
+ // Display details about all system tables
+ //
+ // Note: the first two arguments are ignored. To keep to the spec,
+ // you must put null here
+ //
+ displayResult(dbmd.getTables(null, null, "%", types));
+ }
+ }
+ else if (line.equals("\\q")) // Added by CWJ to permit \q command
+ done = true;
+ else
+ throw new SQLException("Unsupported \\ command: " + line);
+ }
+
+ private static final String allUserTables[] = {"TABLE", "INDEX", "SEQUENCE"};
+ private static final String usrIndices[] = {"INDEX"};
+ private static final String usrTables[] = {"TABLE"};
+ private static final String usrSequences[] = {"SEQUENCE"};
+ private static final String sysTables[] = {"SYSTEM TABLE", "SYSTEM INDEX"};
+
+ /*
+ * Display some instructions on how to run the example
+ */
+ public static void instructions()
+ {
+ System.out.println("\nThis example shows how some of the other JDBC features work within the\ndriver. It does this by implementing a very simple psql equivalent in java.\nNot everything that psql does is implemented.\n");
+ System.out.println("Useage:\n java example.psql jdbc:postgresql:database user password [debug]\n\nThe debug field can be anything. It's presence will enable DriverManager's\ndebug trace. Unless you want to see screens of items, don't put anything in\nhere.");
+ System.exit(1);
+ }
+
+ /*
+ * This little lot starts the test
+ */
+ public static void main(String args[])
+ {
+ System.out.println("PostgreSQL psql example v6.3 rev 1\n");
+
+ //if (args.length < 3)
+ // instructions();
+
+ // This line outputs debug information to stderr. To enable this, simply
+ // add an extra parameter to the command line
+ //if (args.length > 3)
+ // DriverManager.setLogStream(System.err);
+
+ // Now run the tests
+ try
+ {
+ Psql test = new Psql(args);
+ }
+ catch (Exception ex)
+ {
+ System.err.println("Exception caught.\n" + ex);
+ ex.printStackTrace();
+ }
+ }
+}
diff --git a/src/de/superx/bin/PublicPrivateKeyManager.java b/src/de/superx/bin/PublicPrivateKeyManager.java
new file mode 100644
index 0000000..e18ee29
--- /dev/null
+++ b/src/de/superx/bin/PublicPrivateKeyManager.java
@@ -0,0 +1,119 @@
+package de.superx.bin;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.Hashtable;
+
+import de.memtext.util.DSAHandler;
+import de.memtext.util.GetOpts;
+
+public class PublicPrivateKeyManager {
+
+ public static void main(String[] args) {
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-dbproperties,-function");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.exit(1);
+ }
+
+ SxConnection sxcon = new SxConnection();
+ sxcon.setPropfile(GetOpts.getValue("-dbproperties"));
+
+ String function = GetOpts.getValue("-function");
+ try {
+ if (function.equals("install"))
+ { install(sxcon);
+ check(sxcon);
+ }
+ if (function.equals("delete"))
+ {
+ delete(sxcon);
+ System.out.println("public/private key entfernt");
+ }
+ if (function.equals("check"))
+ {
+ System.out.println("Suche keys ...");
+ check(sxcon);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static void check(SxConnection sxcon) throws Exception
+ {
+ Connection con = sxcon.getConnection();
+ Statement st=con.createStatement();
+ ResultSet rs=st.executeQuery("select count(*) from sx_repository where id='privatekey'");
+ int countprivate=0;
+ while (rs.next())
+ countprivate=rs.getInt(1);
+ rs.close();
+ rs=st.executeQuery("select count(*) from sx_repository where id='publickey'");
+ int countpublic=0;
+ while (rs.next())
+ countpublic=rs.getInt(1);
+ rs.close();
+ st.close();
+ con.close();
+ if (countprivate==0) System.out.println("private key nicht installiert");
+ if (countprivate==1) System.out.println("private key installiert");
+ if (countprivate>1)
+ {
+ System.out.println("mehr als ein private key gefunden - alle keys werden gelöscht");
+ delete(sxcon);
+ }
+ if (countpublic==0) System.out.println("public key nicht installiert");
+ if (countpublic==1) System.out.println("public key installiert");
+ if (countpublic>1)
+ {
+ System.out.println("mehr als ein public key gefunden - alle keys werden gelöscht");
+ delete(sxcon);
+ }
+
+
+ }
+ private static void delete(SxConnection sxcon) throws Exception {
+ Connection con = sxcon.getConnection();
+ Statement st = con.createStatement();
+ st
+ .executeUpdate("delete from sx_repository where id in ('privatekey','publickey')");
+ st.close();
+ con.close();
+ }
+
+ private static void install(SxConnection sxcon) throws Exception {
+ delete(sxcon);
+ Connection con = sxcon.getConnection();
+ Statement st=con.createStatement();
+ ResultSet rs=st.executeQuery("select max(tid) from sx_repository");
+ int tid=0;
+ while (rs.next())
+ tid=rs.getInt(1);
+ rs.close();
+ Hashtable table = DSAHandler.generateKeyPair();
+ //PreparedStatement pst = con .prepareStatement("insert into testmb (tid,id,content,active) (?,?,2)");
+//
+
+ PreparedStatement pst = con
+ .prepareStatement("insert into sx_repository (tid,id,content,aktiv) values (?,?,?,2)");
+ pst.setInt(1, ++tid);
+ pst.setString(2, "privatekey");
+ pst.setString(3, table.get("privatekey").toString());
+ //System.out.println(pst.get);
+ pst.execute();
+ pst.setInt(1, ++tid);
+ pst.setString(2, "publickey");
+ pst.setString(3, table.get("publickey").toString());
+ pst.execute();
+ pst.close();
+ con.close();
+
+ }
+}
+
+//Created on 21.10.2006 at 10:03:41
diff --git a/src/de/superx/bin/RestrictedConnectionManager.java b/src/de/superx/bin/RestrictedConnectionManager.java
new file mode 100644
index 0000000..8a8f28c
--- /dev/null
+++ b/src/de/superx/bin/RestrictedConnectionManager.java
@@ -0,0 +1,132 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.Properties;
+
+import de.memtext.util.GetOpts;
+import de.superx.util.PropsReader;
+
+public class RestrictedConnectionManager {
+
+ public static void main(String[] args) {
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-dbproperties,-kern_tabellen_freischalten");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.exit(1);
+ }
+
+ String kerninsert = GetOpts.getValue("-kern_tabellen_freischalten");
+ if (!kerninsert.equals("true") && !kerninsert.equals("false"))
+ throw new IllegalArgumentException(
+ "-kern_tabellen_freischalten:true/false");
+
+ String dbpropfile = GetOpts.getValue("-dbproperties");
+ try {
+ Properties props = PropsReader.prepareProps(new File(dbpropfile));
+ String restrictedUser = props
+ .getProperty("restrictedConnectionName");
+ if (restrictedUser == null || restrictedUser.trim().equals("")) {
+ System.out
+ .println("RestrictedRightsManager: Keine Aktion nötig, da kein eingeschränkter User gefunden in "
+ + dbpropfile);
+ } else {
+ Class.forName(props.getProperty("driverName"));
+
+ Connection conn = DriverManager.getConnection(props
+ .getProperty("connectionURL"), props
+ .getProperty("connectionName"), PropsReader.check(props
+ .getProperty("connectionPassword")));
+ Statement stm = conn.createStatement();
+ StringBuffer grant = new StringBuffer(
+ "grant update on userinfo to "+restrictedUser+";grant insert,update on protokoll to " + restrictedUser +
+ ";grant insert,update,delete,select on user_pw to "+restrictedUser+";") ;
+ if (props.getProperty("driverName").indexOf("postgres")>-1)
+ grant.append(";grant all on protokoll_protokoll_id_seq to "+restrictedUser+";"+
+ "grant all on sx_captions_tid_seq to "+restrictedUser+";");
+
+ if (kerninsert.equals("true")) {
+ freischalten(grant, restrictedUser, "protokoll");
+
+
+
+
+
+ freischalten(grant, restrictedUser, "user_pw");
+
+ freischalten(grant, restrictedUser, "group_field_pref");
+ freischalten(grant, restrictedUser, "sx_captions");
+ freischalten(grant, restrictedUser, "sx_stylesheets");
+ freischalten(grant, restrictedUser, "sx_mask_style");
+ freischalten(grant, restrictedUser, "userinfo");
+ freischalten(grant, restrictedUser, "groupinfo");
+ freischalten(grant, restrictedUser, "user_institution");
+ freischalten(grant, restrictedUser, "user_sachgeb_bez");
+ freischalten(grant, restrictedUser, "user_masken_bez");
+ freischalten(grant, restrictedUser, "group_sachgeb_bez");
+ freischalten(grant, restrictedUser, "group_masken_bez");
+ freischalten(grant, restrictedUser, "user_group_bez");
+ freischalten(grant, restrictedUser, "user_sichten");
+ freischalten(grant, restrictedUser, "user_sichtarten");
+ freischalten(grant, restrictedUser, "group_sichten");
+ freischalten(grant, restrictedUser, "group_sichtarten");
+ freischalten(grant, restrictedUser, "felderinfo");
+ freischalten(grant, restrictedUser, "maskeninfo");
+ freischalten(grant, restrictedUser, "konstanten");
+ freischalten(grant, restrictedUser, "maske_system_bez");
+ freischalten(grant, restrictedUser, "masken_felder_bez");
+ freischalten(grant, restrictedUser, "sachgeb_maske_bez");
+ freischalten(grant, restrictedUser, "organigramm");
+ freischalten(grant, restrictedUser, "themenbaum");
+ freischalten(grant, restrictedUser, "sx_downloads");
+ freischalten(grant, restrictedUser, "download_group_bez");
+ freischalten(grant, restrictedUser, "download_keyw_bez");
+ freischalten(grant, restrictedUser, "download_user_bez");
+ freischalten(grant, restrictedUser, "group_hinweis");
+ freischalten(grant, restrictedUser, "user_hinweis");
+ freischalten(grant, restrictedUser, "user_einstellungen");
+ freischalten(grant, restrictedUser, "user_dialog");
+ }
+ stm.execute(grant.toString());
+ String upd = null;
+
+ ResultSet rs = null;
+ if (props.getProperty("driverName").indexOf("postgres") > -1)
+ rs = conn.getMetaData().getTables(null, null, null, null);
+ else
+ rs = conn.getMetaData().getTables("superx", "superx", null,
+ null);
+
+ while (rs.next()) {
+ upd = "grant select on " + rs.getObject(3).toString()
+ + " to " + restrictedUser + ";";
+ //System.out.println(upd);
+ if (rs.getString(4) != null
+ && (rs.getString(4).equals("TABLE") || rs
+ .getString(4).equals("VIEW")))
+ stm.execute(upd);
+ }
+ rs.close();
+ stm.close();
+ conn.close();
+ System.out.println(" RestrictedRightsManager fertig");
+ }
+ } catch (Exception e) {
+ System.out.println("Es ist ein Fehler aufgetreten:");
+ e.printStackTrace();
+ }
+ }
+
+ private static void freischalten(StringBuffer grant, String user,
+ String table) {
+ grant.append("grant select,insert, update, delete on " + table + " to " + user
+ + ";");
+ }
+}
+
+//Created on 03.11.2006 at 15:44:10
diff --git a/src/de/superx/bin/SendMail.java b/src/de/superx/bin/SendMail.java
new file mode 100644
index 0000000..5c35c01
--- /dev/null
+++ b/src/de/superx/bin/SendMail.java
@@ -0,0 +1,239 @@
+package de.superx.bin;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Date;
+import java.util.Properties;
+
+import javax.activation.DataHandler;
+import javax.activation.FileDataSource;
+import javax.mail.Message;
+import javax.mail.Multipart;
+import javax.mail.PasswordAuthentication;
+import javax.mail.Session;
+import javax.mail.Transport;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeBodyPart;
+import javax.mail.internet.MimeMessage;
+import javax.mail.internet.MimeMultipart;
+
+import com.martiansoftware.jsap.FlaggedOption;
+import com.martiansoftware.jsap.JSAP;
+import com.martiansoftware.jsap.JSAPException;
+import com.martiansoftware.jsap.JSAPResult;
+import com.martiansoftware.jsap.Switch;
+
+//TODO flag ssl aktivieren
+public class SendMail {
+ private static final String port = "25";
+ private String to, from, smtphost, username, password, subject, msg,
+ msgfile, attach;
+ private boolean sslWanted = false;
+
+ public void send(String[] args) {
+
+ readArgs(args);
+ Session session = getSession();
+
+ try {
+ // create a message
+ MimeMessage message = new MimeMessage(session);
+ message.setFrom(new InternetAddress(from));
+ InternetAddress[] address = { new InternetAddress(to) };
+ message.setRecipients(Message.RecipientType.TO, address);
+ message.setSubject(subject);
+ String content = getContent();
+
+ // attach the file to the message
+ if (attach != null) {
+ // create and fill the first message part
+ MimeBodyPart mbp1 = new MimeBodyPart();
+ mbp1.setText(content);
+
+ // create the second message part
+ MimeBodyPart mbp2 = new MimeBodyPart();
+
+ FileDataSource fds = new FileDataSource(attach);
+ mbp2.setDataHandler(new DataHandler(fds));
+ mbp2.setFileName(fds.getName());
+ // create the Multipart and add its parts to it
+ Multipart mp = new MimeMultipart();
+ mp.addBodyPart(mbp1);
+ mp.addBodyPart(mbp2);
+
+ // add the Multipart to the message
+ message.setContent(mp);
+
+ } else {
+ message.setContent(content, "text/html");
+ }
+
+ // set the Date: header
+ message.setSentDate(new Date());
+
+ // Transport transport = session.getTransport("smtp");
+ // transport.connect(smtphost, port, username, password);
+
+ Transport.send(message);
+ System.out.println("Email verschickt");
+
+ } catch (Exception mex) {
+ mex.printStackTrace();
+ System.out.println("Es ist ein Fehler aufgetreten: " + mex);
+ System.exit(-1);
+ }
+
+ }
+
+ private String getContent() throws IOException {
+ String content = msg;
+ if (msgfile != null)
+ content = readFile(new File(msgfile));
+ return content;
+
+ }
+
+ private void readArgs(String[] args) {
+ JSAP jsap = new JSAP();
+ FlaggedOption fto = new FlaggedOption("to")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(true)
+ .setLongFlag("to");
+ FlaggedOption ffrom = new FlaggedOption("from")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(true)
+ .setLongFlag("from");
+ FlaggedOption fhost = new FlaggedOption("host")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(true)
+ .setLongFlag("host");
+
+ FlaggedOption fusername = new FlaggedOption("username")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(true)
+ .setLongFlag("username");
+
+ FlaggedOption fpassword = new FlaggedOption("password")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(true)
+ .setLongFlag("password");
+ FlaggedOption fsubject = new FlaggedOption("subject")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(true)
+ .setLongFlag("subject");
+ FlaggedOption fmsg = new FlaggedOption("msg")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(false)
+ .setLongFlag("msg");
+ FlaggedOption fmsgfile = new FlaggedOption("msgfile")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(false)
+ .setLongFlag("msgfile");
+ FlaggedOption fattach = new FlaggedOption("attach")
+ .setStringParser(JSAP.STRING_PARSER).setRequired(false)
+ .setLongFlag("attach");
+ Switch sw1 = new Switch("ssl").setLongFlag("ssl");
+
+ sw1.setHelp("ssl aktivieren");
+
+ JSAPResult config = null;
+ try {
+ jsap.registerParameter(fto);
+ jsap.registerParameter(ffrom);
+ jsap.registerParameter(fhost);
+ jsap.registerParameter(sw1);
+ jsap.registerParameter(fusername);
+ jsap.registerParameter(fpassword);
+ jsap.registerParameter(fsubject);
+ jsap.registerParameter(fmsg);
+ jsap.registerParameter(fmsgfile);
+ jsap.registerParameter(fattach);
+ config = jsap.parse(args);
+ if (!config.success()) {
+ for (java.util.Iterator errs = config.getErrorMessageIterator(); errs
+ .hasNext();) {
+ System.out.println("Error: " + errs.next());
+
+ }
+ printUsage();
+ }
+
+ to = config.getString("to");
+ from = config.getString("from");
+ smtphost = config.getString("host");
+ sslWanted = config.getBoolean("ssl");
+ subject = config.getString("subject");
+ username = config.getString("username");
+ password = config.getString("password");
+ msg = config.getString("msg");
+ msgfile = config.getString("msgfile");
+ attach = config.getString("attach");
+ // System.out.println(smtphost + " " + username + " " + password);
+ } catch (JSAPException e) {
+
+ System.out.println("Fehler: " + e);
+ printUsage();
+
+ }
+ }
+
+ private Session getSession() {
+ Authenticator authenticator = new Authenticator();
+
+ Properties properties = new Properties();
+ properties.setProperty("mail.smtp.submitter", authenticator
+ .getPasswordAuthentication().getUserName());
+ properties.setProperty("mail.smtp.auth", "true");
+ if (sslWanted) {
+ properties.put("mail.smtp.starttls.enable", "true");
+ System.out.println("SSL aktiviert");
+ }
+ properties.setProperty("mail.smtp.host", this.smtphost);
+ properties.setProperty("mail.smtp.port", port);
+
+ return Session.getInstance(properties, authenticator);
+ }
+
+ private static void printUsage() {
+ System.out
+ .println("usage: java de.superx.bin.SendMail --to test@test.de --from system@super-ics.de --host smtp.strato.de --ssl (optional) --username system --password geheim --subject \"Ihre Dokumente\" "
+ + " --msg \"Hier erhalten Sie Ihre Protokolle\" (optional) --msgfile c:\\nachricht.txt (optional) --attach c:\\protokoll.xls (optinal)");
+ System.exit(1);
+ }
+
+ /**
+ * Copy of de.memtext.util.StringUtils.readFile Reads the contents of a file
+ * and returns them as a string
+ *
+ * @param filename
+ * @return String with content of files
+ * @throws IOException
+ */
+ public static String readFile(File f) throws IOException {
+ FileReader fr = new FileReader(f);
+ BufferedReader bfr = new BufferedReader(fr);
+ String line;
+ StringBuffer result = new StringBuffer();
+ while ((line = bfr.readLine()) != null) {
+ result.append(line + "\n");
+
+ }
+ bfr.close();
+ fr.close();
+ return result.toString();
+ }
+
+ public static void main(String[] args) {
+ SendMail sm = new SendMail();
+ sm.send(args);
+ }
+
+ private class Authenticator extends javax.mail.Authenticator {
+ private PasswordAuthentication authentication;
+
+ public Authenticator() {
+ // String username = "auth-user";
+ // String password = "auth-password";
+ authentication = new PasswordAuthentication(username, password);
+ }
+
+ protected PasswordAuthentication getPasswordAuthentication() {
+ return authentication;
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/ShowEnv.java b/src/de/superx/bin/ShowEnv.java
new file mode 100644
index 0000000..6f5c7ea
--- /dev/null
+++ b/src/de/superx/bin/ShowEnv.java
@@ -0,0 +1,36 @@
+/*
+ * Created on 15.09.2003
+ *
+ * To change the template for this generated file go to
+ * Window>Preferences>Java>Code Generation>Code and Comments
+ */
+package de.superx.bin;
+import java.util.Enumeration;
+import java.util.Properties;
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * ShowEnv.java
+ * @
+ * Dieses Javaprogramm ...
+ *
+ *
+ *
+ *
+ */
+public class ShowEnv {
+
+ public static void main(String[] args) {
+ Properties sysprops = System.getProperties();
+ Enumeration propnames = sysprops.propertyNames();
+ System.out.println("SuperX @version@\n");
+ while (propnames.hasMoreElements()) {
+ String propname = (String)propnames.nextElement();
+ System.out.println(
+ propname + "=" + System.getProperty(propname)
+ );
+ }
+ }
+
+
+}
diff --git a/src/de/superx/bin/SimpleSoapClient.java b/src/de/superx/bin/SimpleSoapClient.java
new file mode 100644
index 0000000..64bb137
--- /dev/null
+++ b/src/de/superx/bin/SimpleSoapClient.java
@@ -0,0 +1,107 @@
+package de.superx.bin;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.nio.charset.Charset;
+
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.SOAPConnection;
+import javax.xml.soap.SOAPConnectionFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+public class SimpleSoapClient {
+
+
+ public static void main(String args[]) {
+ if (args.length != 3) {
+ System.out
+ .println("Usage path/to/envelope.xml URL /path/to/ouputfile.xml");
+ System.exit(-1);
+ }
+ try {
+ // Create SOAP Connection
+ SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory
+ .newInstance();
+ SOAPConnection soapConnection = soapConnectionFactory
+ .createConnection();
+
+ // Send SOAP Message to SOAP Server
+ String url = args[1];
+
+ SOAPMessage sr = getSoapMessageFromString(readFile(new File(args[0])));
+ sr.getMimeHeaders().addHeader("SOAPAction",
+ "http://sap.com/xi/WebService/soap1.1");
+
+ SOAPMessage soapResponse = soapConnection.call(sr, url);
+
+ soapResponse.writeTo(System.out);
+ final StringWriter sw = new StringWriter();
+
+ Transformer transformer = TransformerFactory.newInstance()
+ .newTransformer();
+ // optional indenting
+ transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+ transformer.setOutputProperty(
+ "{http://xml.apache.org/xslt}indent-amount", "2");
+
+ transformer.transform(new DOMSource(soapResponse.getSOAPPart()),
+ new StreamResult(sw));
+
+ writeFile(args, sw);
+
+ soapConnection.close();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static void writeFile(String[] args, final StringWriter sw)
+ throws IOException {
+ FileWriter fw = new FileWriter(args[2]);
+ BufferedWriter bfw = new BufferedWriter(fw);
+ bfw.write(sw.toString());
+ bfw.close();
+ fw.close();
+ }
+
+ //
+ // I did this in two steps. First created a DOM Document, and then create
+ // the SOAPMessage from the Document.
+ private static SOAPMessage getSoapMessageFromString(String xml)
+ throws SOAPException, IOException {
+ MessageFactory factory = MessageFactory.newInstance();
+ SOAPMessage message = factory
+ .createMessage(
+ new MimeHeaders(),
+ new ByteArrayInputStream(xml.getBytes(Charset
+ .forName("UTF-8"))));
+ return message;
+ }
+
+ private static String readFile(File f) throws IOException {
+ FileReader fr = new FileReader(f);
+ BufferedReader bfr = new BufferedReader(fr);
+ String line;
+ StringBuffer result = new StringBuffer();
+ while ((line = bfr.readLine()) != null) {
+ result.append(line + "\n");
+
+ }
+ bfr.close();
+ fr.close();
+ return result.toString();
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/SimpleTransform.java b/src/de/superx/bin/SimpleTransform.java
new file mode 100644
index 0000000..1cb9c27
--- /dev/null
+++ b/src/de/superx/bin/SimpleTransform.java
@@ -0,0 +1,123 @@
+package de.superx.bin;
+/*
+ *
+ * Simple Transformation of an XML Source via xsl File
+ */
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+
+import de.memtext.util.GetOpts;
+import de.memtext.util.TimeUtils;
+
+/**
+ * Use the TraX interface to perform a transformation in the simplest manner possible
+ * (3 statements).
+ */
+public class SimpleTransform {
+ private static String usage =
+ "-------------------------------------\nGebrauch: java de.superx.SimpleTransform -logger=<> -IN=<> -XSL=<> -method=<>(optional) -param=<>(optional) -OUT=<>(optional) \n---------------------------------------------------";
+ static Logger logger =
+ (Logger) Logger.getLogger(SimpleTransform.class.toString());
+
+ private static String _out = "";
+ public static void transform(String args[])
+ throws
+ TransformerException,
+ TransformerConfigurationException,
+ FileNotFoundException,
+ IOException,
+ ClassNotFoundException,
+ FileNotFoundException,
+ IOException {
+
+ String _xml = "";
+ String _xsl = "";
+
+ String method = "text";
+ String _params = "";
+ String logfile = "";
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts.isAllRequiredOptionsPresent("-logger,-IN,-XSL");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-logger"))
+ logfile = GetOpts.getValue("-logger");
+ if (GetOpts.isPresent("-IN"))
+ _xml = GetOpts.getValue("-IN");
+ if (GetOpts.isPresent("-XSL"))
+ _xsl = GetOpts.getValue("-XSL");
+ if (GetOpts.isPresent("-OUT"))
+ _out = GetOpts.getValue("-OUT");
+ if (GetOpts.isPresent("-method"))
+ method = GetOpts.getValue("-method");
+ if (GetOpts.isPresent("-param"))
+ _params = GetOpts.getValue("-param");
+
+ //logger.initRaw(dosql.class)
+ //PropertyConfigurator.configure(logfile);
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ //logfile = MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + MyLogManager.getProperty(".level"));
+
+ SxTransformer myTransformer = null;
+ if (_out.equals(""))
+ myTransformer = new SxTransformer(logger, System.out);
+ else
+ myTransformer = new SxTransformer(logger, _out);
+ myTransformer.quellstring = _xml;
+ myTransformer.stylesheet = _xsl;
+ myTransformer.setParams(_params);
+ try {
+ myTransformer.transformFile(method);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+ public static void main(String args[]) {
+ try {
+ if (args.length < 2) {
+ System.err.println(
+ "Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zur xml-Datei,Pfad zur xsl-Datei) erfoderlich");
+ System.err.println(usage);
+ System.exit(1);
+ }
+ TimeUtils t=new TimeUtils(); t.start();
+ transform(args);
+ t.print(" done");
+ String msg = "XML-Transformation erfolgreich ";
+ if (_out != null && !_out.equals(""))
+ msg += _out + " erzeugt";
+ System.out.println(msg);
+ } catch (Exception ex) {
+ System.err.println("Es ist ein Fehler aufgetreten, "+_out+" konnte nicht erstellt werden\n"+ex.toString());
+ File f = new File(_out);
+ if (f.exists()) {
+ f.delete();
+ }
+ System.exit(1);
+ }
+ }
+}
+
+
+
diff --git a/src/de/superx/bin/SpecialUpdater.java b/src/de/superx/bin/SpecialUpdater.java
new file mode 100644
index 0000000..2986b96
--- /dev/null
+++ b/src/de/superx/bin/SpecialUpdater.java
@@ -0,0 +1,66 @@
+package de.superx.bin;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import de.memtext.db.ConnectionCreator;
+
+public class SpecialUpdater {
+public static String url="jdbc:informix-sqli://jupiter:50000:informixserver=superx_host;database=superx";
+public static String passwd="anfang12";
+ SpecialUpdater()
+ {
+
+ }
+ public void run() throws SQLException
+ {
+ ConnectionCreator.loadClass("com.informix.jdbc.IfxDriver");
+ Connection con=ConnectionCreator.getConnection(url,"superx",passwd);
+ Statement stm=con.createStatement();
+ ResultSet rs=stm.executeQuery("select tid,relation from felderinfo where art=12");
+ int tid;
+ String relation,relationCorr;
+ PreparedStatement pst=con.prepareStatement("update felderinfo set relation=? where tid=?");
+ while (rs.next()) {
+ tid=rs.getInt("tid");
+ relation=rs.getString("relation");
+ if (relation.indexOf("tid")>-1&&relation.indexOf("sichten")>-1)
+ {
+ System.out.println("replace for "+tid+" ");
+ System.out.println(" "+relation);
+ relationCorr=relation.replaceAll(" tid "," id ");
+ System.out.println(" "+relationCorr);
+
+ pst.setString(1,relationCorr);
+ pst.setInt(2,tid);
+ pst.execute();
+ }
+
+ }
+ rs.close();
+ stm.close();
+ con.close();
+ }
+ public static void main(String[] args) {
+ if (args.length==0)
+ {
+ System.out.println(" informix driver must be in classpath");
+ System.out.println(" url [passwd]");
+
+ }
+ if (args.length>0)
+ url=args[0];
+ if (args.length>1)
+ passwd=args[1];
+ try {
+ new SpecialUpdater().run();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+}
+
+//Created on 17.02.2005 at 15:55:28
\ No newline at end of file
diff --git a/src/de/superx/bin/SxConnection.java b/src/de/superx/bin/SxConnection.java
new file mode 100644
index 0000000..ffb8d25
--- /dev/null
+++ b/src/de/superx/bin/SxConnection.java
@@ -0,0 +1,171 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Properties;
+
+import de.superx.util.PropsReader;
+import de.superx.util.SqlStringUtils;
+
+/**
+ * Connection-Objekt für JDBC-Verbindungen.
+ *
+ * @author Daniel Quathamer
+ * @version 1.1
+ */
+public class SxConnection {
+
+ byte key[] = { (byte) 255, (byte) 221, (byte) 127, (byte) 109, (byte) 129 };
+ int keyLength = key.length;
+ boolean isPwLogWanted = false;
+ public Connection con;
+ private String m_DBUrl;
+ private String m_User;
+ private String m_Password;
+ private Properties props = new Properties();
+ public String m_DriverClass;
+ public String propfile = "";
+
+ /**
+ * connection
+ *
+ * @param keine.
+ * @return eine unbenutzte Verbindung
+ */
+ public synchronized Connection getConnection() throws Exception {
+ loadProperties();
+ props.put("user", m_User);
+
+ props.put("password", m_Password);
+ if (m_DriverClass.equals("org.postgresql.Driver")) {
+ props.put("charSet", SqlStringUtils.getEncoding().equals("UTF-8")?"UTF-8":"Latin-1");
+ props.put("DateStyle", "German, DMY");
+ }
+ if (m_DriverClass.equals("com.informix.jdbc.IfxDriver")) {
+ props.put("GL_DATETIME", "%d.%m.%Y %T");
+ props.put("CLIENT_LOCALE", SqlStringUtils.getEncoding().equals("UTF-8")?"UTF-8":"de_de.8859-1");
+ }
+
+ Class.forName(m_DriverClass);
+ //System.out.println(m_DriverClass);
+ //Zur Zeit wird die db_locale auf Deutsch festgelegt.
+ // In Zukunft muss sie mit db.properties übergeben werden.
+ con = DriverManager.getConnection(m_DBUrl, props);
+
+ if (m_DriverClass.equals("org.postgresql.Driver")) {
+ //Seit postgres 8 (win) geht der props.Datestyle Parameter nicht
+ // mehr
+ DatabaseMetaData dbmd = con.getMetaData();
+ if (dbmd.getDatabaseMajorVersion() >= 8) {
+ Statement stmt = con.createStatement();
+ stmt.execute("set datestyle to 'ISO, DMY';");
+ stmt.close();
+ }
+ }
+
+ //Statement stmt = con.createStatement();
+ //stmt.execute("select * from userinfo;");
+ //ResultSet rs = stmt.getResultSet();
+ //ResultSetMetaData rsmd = rs.getMetaData();
+ // int cols = rsmd.getColumnCount();
+ // stmt.close();
+ return con;
+ }
+
+ /**
+ * Aus den db.properties Parameter holen
+ *
+ *
+ */
+ private void loadProperties() throws Exception {
+ String pfad = "";
+ if (propfile.equals("") || propfile.equals(null))
+ pfad = ".." + System.getProperty("file.separator") + "conf"
+ + System.getProperty("file.separator") + "db.properties";
+ else
+ pfad = propfile;
+ //String pfad=".." + System.getProperty("file.separator") + ".." +
+ // System.getProperty("file.separator") +
+ // "webserver"+System.getProperty("file.separator") +
+ // "tomcat"+System.getProperty("file.separator") + "webapps"
+ // +System.getProperty("file.separator")
+ // +"superx"+System.getProperty("file.separator")
+ // +"WEB-INF"+System.getProperty("file.separator") +"db.properties";
+ //InputStream is =
+ // this.getClass().getResourceAsStream(pfad);
+ File f = new File(pfad);
+ props = PropsReader.prepareProps(f);
+
+ m_DBUrl = props.getProperty("connectionURL");
+ m_User = props.getProperty("connectionName");
+ m_Password = PropsReader.check(props.getProperty("connectionPassword"));
+ m_DriverClass = props.getProperty("driverName");
+
+ }
+
+ public PreparedStatement prepareStatement(String stm) {
+ PreparedStatement t = null;
+ try {
+ t = con.prepareStatement(stm);
+ } catch (SQLException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ return (t);
+ }
+
+ public String getCatalog() throws SQLException {
+ String dbname = "";
+ dbname = con.getCatalog();
+ return dbname;
+ }
+
+ //public ResultSet sqlMetaData() throws SQLException
+ //{
+ //ResultSet rs=con.}
+ /**
+ * @return
+ */
+ public String getM_DriverClass() {
+ return m_DriverClass;
+ }
+
+ public String getDatabaseAbbr()
+ {
+ String result="unknown";
+ if (getM_DriverClass().toLowerCase().indexOf(
+ "postgres") > -1) result="PG";
+ if (getM_DriverClass().toLowerCase().indexOf(
+ "informix") > -1) result="IDS";
+ return result;
+ }
+
+ public String getPropfile() {
+ return propfile;
+ }
+
+ /**
+ * @param string
+ */
+ public void setM_DriverClass(String string) {
+ m_DriverClass = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setPropfile(String string) {
+ propfile = string;
+ }
+
+ public void close() throws SQLException {
+ con.close();
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/SxDBUtils.java b/src/de/superx/bin/SxDBUtils.java
new file mode 100644
index 0000000..3a42235
--- /dev/null
+++ b/src/de/superx/bin/SxDBUtils.java
@@ -0,0 +1,302 @@
+package de.superx.bin;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+import java.text.FieldPosition;
+import java.text.SimpleDateFormat;
+import java.util.LinkedList;
+import java.util.List;
+
+import de.memtext.util.StringUtils;
+import de.memtext.util.TimeUtils;
+import de.superx.util.SqlStringUtils;
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * SxDBUtils.java
+ * @
+ * Dieses Klasse enthält nützliche Methoden für den Umggang mit DBen
+ *
+ *
+ *
+ *
+ *
+ */
+public class SxDBUtils {
+ private static SimpleDateFormat AmericanDateFormat =
+ new SimpleDateFormat("yyyy-MM-dd");
+
+ public static int fieldCount(String tabname) throws Exception {
+ int fieldcount;
+ SxConnection myConnection = new SxConnection();
+ //myConnection.setPropfile( PropFile);
+ String query =
+ "select count(*) from pg_attribute A, pg_class C, pg_type T where A.attrelid=C.relfilenode and A.atttypid=T.oid and A.attnum>0 and C.relname='"
+ + tabname
+ + "';";
+ Connection myDb = myConnection.getConnection();
+ Statement st = myDb.createStatement();
+ ResultSet rs = null;
+ try {
+ rs = st.executeQuery(query);
+ } catch (SQLException se) {
+ System.err.println("SQL-Fehler: " + se.toString());
+ } catch (Exception e) {
+ System.err.println("DB-Zugriff-Fehler: " + e.toString());
+ }
+
+ if (rs.next()) {
+ fieldcount = rs.getInt(1);
+ } else {
+ fieldcount = 0;
+ }
+ return fieldcount;
+
+ }
+ public static void main(String args[]) {
+ TimeUtils tu=new TimeUtils();
+ String f_wert=null;
+ tu.start();
+ for (int i=0;i<1000;i++)
+ {
+ f_wert="\nx\r\nx\n\rx\\\n\\\rx\\\r\\\nx\\n\\rx\\r\\nx\\rx\r";
+ f_wert= replaceString(f_wert, "\n", "\\\n");
+ f_wert = replaceString(f_wert, "\r\n", "\\\n");
+ f_wert = replaceString(f_wert, "\n\r", "\\\n");
+ f_wert = replaceString(f_wert,"\\\n\\\r","");
+ f_wert = replaceString(f_wert,"\\\r\\\n","");
+ f_wert = replaceString(f_wert,"\\r\\n","");
+ f_wert = replaceString(f_wert,"\\n\\r","");
+ f_wert = replaceString(f_wert,"\\r","\\\n");
+ f_wert = replaceString(f_wert,"\r","\\\n");
+ }
+ tu.print("replace String 1000x");
+ String old=f_wert;
+ StringBuffer t=null;
+ for (int i=0;i<1000;i++)
+ {
+ f_wert="\nx\r\nx\n\rx\\\n\\\rx\\\r\\\nx\\n\\rx\\r\\nx\\rx\r";
+ t=new StringBuffer(f_wert);
+ StringUtils.replace(t,"\n","\\\n");
+ StringUtils.replace(t,"\r\n","\\\n");
+ StringUtils.replace(t,"\n\r","\\\n");
+ StringUtils.replace(t,"\\\n\\\r","");
+ StringUtils.replace(t,"\\\r\\\n","");
+ StringUtils.replace(t,"\\n\\r","");
+ StringUtils.replace(t,"\\r\\n","");
+ StringUtils.replace(t,"\\r","\\\n");
+ StringUtils.replace(t,"\r","\\\n");
+ }
+ tu.print("replace StringBuffer 1000x");
+ System.out.println(old.equals(t.toString()));
+ }
+ public static String replaceString(
+ String str,
+ String search_str,
+ String replace_str) {
+ String zs = "";
+
+ if (!search_str.equals("") && search_str != null) {
+ int offset = 0;
+ int pos = str.indexOf(search_str, offset);
+ while (pos > -1) {
+ zs += str.substring(offset, pos);
+ zs += replace_str;
+ offset = pos + search_str.length();
+ pos = str.indexOf(search_str, offset);
+ }
+ zs += str.substring(offset, str.length());
+ } else
+ //Der Suchstring war leer
+ zs = str;
+ return zs;
+ }
+ public static List toResultList(ResultSet rs) throws SQLException {
+ List help = new LinkedList();
+ ResultSetMetaData rsmd = rs.getMetaData();
+ int numberOfColumns = rsmd.getColumnCount();
+
+ List row = null;
+ while (rs.next()) {
+ row = new LinkedList();
+ for (int i = 1; i <= numberOfColumns; i++) {
+ row.add(rs.getObject(i));
+ }
+ help.add(row);
+ }
+ rs.close();
+ return help;
+ }
+
+ public static String getSqlTypeName(int type) {
+ switch (type) {
+ case Types.ARRAY :
+ return "ARRAY";
+ case Types.BIGINT :
+ return "BIGINT";
+ case Types.BIT :
+ return "BOOLEAN";
+ case Types.TINYINT :
+ return "TINYINT";
+ case Types.SMALLINT :
+ return "SMALLINT";
+ case Types.INTEGER :
+ return "INTEGER";
+ case Types.FLOAT :
+ return "FLOAT";
+ case Types.REAL :
+ return "REAL";
+ case Types.DOUBLE :
+ return "DOUBLE";
+ case Types.NUMERIC :
+ return "NUMERIC";
+ case Types.DECIMAL :
+ return "DECIMAL";
+ case Types.CHAR :
+ return "CHAR";
+ case Types.VARCHAR :
+ return "VARCHAR";
+ case Types.LONGVARCHAR :
+ return "LONGVARCHAR";
+ case Types.DATE :
+ return "DATE";
+ case Types.TIME :
+ return "TIME";
+ case Types.TIMESTAMP :
+ return "DATETIME";
+ //used to be TIMESTAMP, but HIS uses datetime
+ case Types.BINARY :
+ return "BINARY";
+ case Types.VARBINARY :
+ return "VARBINARY";
+ case Types.LONGVARBINARY :
+ return "LONGVARBINARY";
+ case Types.NULL :
+ return "NULL";
+ case Types.OTHER :
+ return "OTHER";
+ case Types.JAVA_OBJECT :
+ return "JAVA_OBJECT";
+ case Types.DISTINCT :
+ return "DISTINCT";
+ case Types.STRUCT :
+ return "STRUCT";
+ case Types.BLOB :
+ return "BLOB";
+ case Types.CLOB :
+ return "CLOB";
+ case Types.REF :
+ return "REF";
+ default :
+ return "" + type + " Unknown";
+ }
+ }
+ public static String field_value(Object o) {
+ String f_wert = "";
+ if (o != null) {
+ if (o instanceof java.sql.Date) {
+ if (System.getProperty("user.language") != null
+ && (System.getProperty("user.language").equals("us_US")
+ || System.getProperty("user.language").equals("en_US")))
+ f_wert = "" + getUSDateFormat((java.sql.Date) o);
+ else
+ f_wert = SqlStringUtils.getValueAsString(o);
+ // DateFormat.getDateInstance(DateFormat.MEDIUM).format(o);
+
+ }
+ else{
+
+
+ if (o instanceof java.sql.Timestamp)
+ f_wert = SqlStringUtils.getValueAsString(o);
+ else
+ //"" +DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM).format(o);
+ if (o instanceof java.sql.Time)
+ f_wert = SqlStringUtils.getValueAsString(o);
+ else
+ //""+ DateFormat.getTimeInstance(DateFormat.MEDIUM).format(o);
+ if (o instanceof java.lang.String) {
+ f_wert=o.toString().trim();
+ if(f_wert.length()==0 )
+ f_wert=" "; //Leerstring wird auf " " gesetzt
+ else
+ f_wert=f_wert.trim(); //Leerzeichen bei gefüllten Feldern entfernen.
+ }
+
+ else
+ //default:
+ f_wert = o.toString();
+ }
+
+
+
+ } else
+ f_wert = "";
+ return f_wert;
+ }
+
+ /**
+ * Gets a date String in the format needed by Hsql
+
+ * @param Date - java.util.Date object to be transformed
+ * @return String - in the format for Hsql ("01-01-2004")
+ */
+ public static String getUSDateFormat(java.sql.Date date) {
+ StringBuffer result = new StringBuffer("");
+ if (date != null) {
+ AmericanDateFormat.format(date, result, new FieldPosition(0));
+ //result.append("");
+ }
+ return date == null ? null : result.toString();
+ }
+ public static String prepareInformixCsv(String feldwert)
+ {
+ //Informix-LOAD ist unser Standardformat; es setzt linebreaks als \n um, davor ein "\"
+ //Bei Textfelder müssen alle anderen Linebreaks raus, deshalb der folgende Passus
+
+ String f_wert;
+ char newline = '\n';
+ f_wert=feldwert ;
+ if(f_wert.length()==0 ) f_wert=""; //der String enthält nur Sonderzeichen und wird auf leer gesetzt.
+ else
+ {
+ //wenn der Feldwert zufällig das Zeichen "\" enthält, wird es mit "\" maskiert
+ if( f_wert != null && (f_wert.indexOf("\\") >-1 ))
+ {
+ f_wert=de.memtext.util.StringUtils.replace(f_wert, "\\", "\\\\");
+ }
+ //Linebreaks umsetzen:
+
+ if(f_wert.equals("\n")
+ || f_wert.equals("\r\n")
+ || f_wert.equals("\n\r")
+ || f_wert.equals("\\n\r")
+ || f_wert.equals("\\\n\\\r")
+ || f_wert.equals("\\\n")
+ || f_wert.equals("\\n")
+ || f_wert.equals("\\\r")
+ || f_wert.equals("\\r")
+ || f_wert.equals("\r")
+ )
+ f_wert="";
+ //neue Version mit StringBuffer ist schneller
+ StringBuffer t=new StringBuffer(f_wert);
+ StringUtils.replace(t,"\r\n","\n");
+ StringUtils.replace(t,"\n","\\\n");
+ StringUtils.replace(t,"\n\r","\\\n");
+ StringUtils.replace(t,"\\\n\\\r","");
+ StringUtils.replace(t,"\\\r\\\n","");
+ StringUtils.replace(t,"\\n\\r","");
+ StringUtils.replace(t,"\\r\\n","");
+ StringUtils.replace(t,"\\r","\\\n");
+ StringUtils.replace(t,"\r","\\\n");
+ f_wert=t.toString();
+
+
+ }
+ return f_wert;
+ }
+}
diff --git a/src/de/superx/bin/SxExtractor.java b/src/de/superx/bin/SxExtractor.java
new file mode 100644
index 0000000..8e0a2ed
--- /dev/null
+++ b/src/de/superx/bin/SxExtractor.java
@@ -0,0 +1,372 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.Properties;
+import java.util.StringTokenizer;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import java.util.Enumeration;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import de.memtext.util.ExceptionHandler;
+import de.memtext.util.GetOpts;
+import de.memtext.util.XMLUtils;
+
+/*
+ * Änderungen
+ *
+ * 26.8.04 MB XMLUtils.buildDocumentFromFile -> buildDocument
+ * 18.9.08 DQ Params werden anders gelesen
+ */
+public class SxExtractor {
+ String delim = "^";
+ String header = "false";
+ String logfile = "../conf/logging.properties";
+ String tabelle = "";
+ String dbpropfile = "../conf/db.properties";
+ String myElement = "table";
+ String myAttrib = "name";
+ String outformat = "txt";
+ String outfile = "";
+ String _dateiPfad = "";
+ private static final String extraction_table = "extraction-table";
+ private static final String extraction_script = "extraction-script";
+ private static final String extraction_sql = "extraction-sql";
+ private static final String database_name = "database";
+ private static final String version_name = "version";
+ private static final String transfer_unload_file = "transfer-unload-file";
+
+ private static Document document;
+ //LogUtils logger=null;
+ public Logger logger = (Logger) Logger.getLogger(SxExtractor.class
+ .toString());
+ //static Logger logger = Logger.getLogger(dosql.class);
+ private ExceptionHandler exceptionHandler = new ExceptionHandler(false);
+ private static String usage = "-------------------------------------\n"
+ + "Dieses Script analysiert eine vorgegebene XML-Datei auf Attribute extraction-table, extraction-script und extraction-sql. Wess es ein Attribur findet, startet es die entsprechende DB-Verbindung und entlädt das Ergebnis nach dem Wert des Attributs transfer-unload-file\n"
+ + "Gebrauch: java de.superx.bin.SxExtractor -logger=<> -dbproperties=<> "
+ + "-xml: -params: -outFormat:(optional) "
+ + " -delim: -header:(optional) -outfile:(optional) \n---------------------------------------------------";
+
+ public SxExtractor(String args[]) throws IOException {
+ String name = "";
+ String unl_file = "";
+ String params = "";
+ String database = "";
+ String version = "";
+ String p_database = "";
+ String p_version = "";
+ String unload_params="unload_params.txt";
+ String sourcesystem="";
+ GetOpts.setOpts(args);
+ Node myNode;
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-logger,-dbproperties,-xml");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+ Properties props = new Properties();
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-logger"))
+ logfile = GetOpts.getValue("-logger");
+ if (GetOpts.isPresent("-dbproperties"))
+ dbpropfile = GetOpts.getValue("-dbproperties");
+ if (GetOpts.isPresent("-xml"))
+ _dateiPfad = GetOpts.getValue("-xml");
+ if (GetOpts.isPresent("-params"))
+ params = GetOpts.getValue("-params");
+ if (GetOpts.isPresent("-outFormat"))
+ outformat = GetOpts.getValue("-outFormat");
+ if (GetOpts.isPresent("-delim"))
+ delim = GetOpts.getValue("-delim");
+ if (GetOpts.isPresent("-header"))
+ header = GetOpts.getValue("-header");
+ if (GetOpts.isPresent("-database"))
+ p_database = GetOpts.getValue("-database");
+ if (GetOpts.isPresent("-version"))
+ p_version = GetOpts.getValue("-version");
+ if (GetOpts.isPresent("-unload_params"))
+ unload_params = GetOpts.getValue("-unload_params");
+
+
+ //wenn eine Datei "unload_params.txt existiert und mindestens ein Parameter
+ //definiert ist, überschreibt er die Kommandozeile
+ //Grund: Kommandozeile unter Unix löst Variablen sonst auf
+ if (new File(unload_params).exists())
+ {
+ FileInputStream is = new FileInputStream(unload_params);
+
+ if (is != null) {
+ props.load(is);
+ is.close();
+ Enumeration propnames = props.propertyNames();
+ if(propnames!=null)
+ {
+ params="";
+ while (propnames.hasMoreElements()) {
+ String propname = (String)propnames.nextElement();
+ params+=propname + "=" + props.getProperty(propname)+"^";
+ if(propname.equals("$SOURCESYSTEM"))
+ sourcesystem=props.getProperty(propname);
+ }
+ //params=params.substring(0, params.length()-1);
+ }
+ }
+ }
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+
+ //XMLUtils myUtils=new XMLUtils();
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+ if (delim.equals(""))
+ delim = "^"; //default Delimiter
+
+ document = XMLUtils.buildDocument(new File(_dateiPfad), false);
+ // NodeList myNodes = document.getElementsByTagName(myElement);
+ NodeList myNodes = document.getElementsByTagName("unload-job");
+
+ for (int i = 0; i < myNodes.getLength(); i++) {
+ myNode = myNodes.item(i);
+ if (myNode.getNodeType() == Node.TEXT_NODE)
+ continue;
+ if (XMLUtils.hasAttrib(myNode, transfer_unload_file))
+ unl_file = XMLUtils
+ .getAttribValue(myNode, transfer_unload_file);
+ else
+ unl_file = "";
+ //now we have an unload-job-node, and an unload-file is specified.
+ //now the question: is it an extract-table,script or sql?
+ if (XMLUtils.hasAttrib(myNode, extraction_table))
+ name = XMLUtils.getAttribValue(myNode, extraction_table);
+ else
+ name = "";
+ if (XMLUtils.hasAttrib(myNode, version_name))
+ version = XMLUtils.getAttribValue(myNode, version_name);
+ else
+ version = "";
+ if (XMLUtils.hasAttrib(myNode, database_name))
+ database = XMLUtils.getAttribValue(myNode, database_name);
+ else
+ database = "";
+ if (!name.equals("")) {
+ //This is a simple table to be unloaded
+ extractTable(name, unl_file, database, version, p_database,
+ p_version);
+ }
+
+ if (XMLUtils.hasAttrib(myNode, extraction_script))
+ name = XMLUtils.getAttribValue(myNode, extraction_script);
+ else
+ name = "";
+ if (!name.equals("")) {
+ //this is an extraction script
+ //wenn es ein Attribut "sourcesystem" gibt und
+ //in den unload_params ein SOURCESYSTEM definiert ist,
+ //wird dies auf Gleichheit geprüft
+ if(!XMLUtils.hasAttrib(myNode, "sourcesystem")
+ || XMLUtils.getAttribValue(myNode,"sourcesystem").equals("")
+ || (XMLUtils.hasAttrib(myNode, "sourcesystem") && XMLUtils.getAttribValue(myNode,"sourcesystem").equals(sourcesystem)))
+ {
+ extractionScript(name, unl_file, params, database, version,
+ p_database, p_version);
+ }
+ }
+
+ //Now: are there the sql-Statements?
+ NodeList mySqls = myNode.getChildNodes();
+ //name("extraction-sql");
+ String sql = "";
+
+ for (int k = 0; k < mySqls.getLength(); k++) {
+ Node mySqlNode = mySqls.item(k);
+ if (//mySqlNode.getNodeType() == Node.TEXT_NODE
+ //&&
+ mySqlNode.getNodeName().equals(extraction_sql)) {
+ //continue;
+ //wenn es ein Attribut "sourcesystem" gibt und
+ //in den unload_params ein SOURCESYSTEM definiert ist,
+ //wird dies auf Gleichheit geprüft
+if(!XMLUtils.hasAttrib(mySqlNode, "sourcesystem")
+ || XMLUtils.getAttribValue(mySqlNode,"sourcesystem").equals("")
+ || (XMLUtils.hasAttrib(mySqlNode, "sourcesystem") && XMLUtils.getAttribValue(mySqlNode,"sourcesystem").equals(sourcesystem)))
+ params = extractionSql(unl_file, params, p_database,
+ p_version, mySqlNode); //when version and database
+ // correct
+ }
+ } //mySqls loop
+ } // myNodes loop
+ }
+
+ private String extractionSql(
+
+ String unl_file, String params, String p_database, String p_version,
+ Node mySqlNode) {
+ String database;
+ String version;
+ String sql;
+ if (XMLUtils.hasAttrib(mySqlNode, database_name))
+ database = XMLUtils.getAttribValue(mySqlNode, database_name);
+ else
+ database = "";
+ if (XMLUtils.hasAttrib(mySqlNode, version_name))
+ version = XMLUtils.getAttribValue(mySqlNode, version_name);
+ else
+ version = "";
+ if (isDatabaseAndVersionOk(p_database, p_version, database, version)) {
+
+ sql = XMLUtils.getChildNodeValues(mySqlNode);
+ if (!sql.equals("")) {
+ //This is a simple sql-String to be unloaded
+ //First the params are replaced:
+ if (!params.equals("")) {
+ if (!params.endsWith("^"))
+ params += "^";
+ StringTokenizer st = new StringTokenizer(params, "^");
+ for (; st.hasMoreTokens();) {
+ String param = st.nextToken();
+ if (!param.equals("")) {
+ String paramname = param.substring(0, param
+ .indexOf("="));
+ String paramvalue = param.substring(param
+ .indexOf("=") + 1, param.length());
+ sql = de.superx.bin.SxDBUtils.replaceString(sql,
+ paramname, paramvalue);
+ } //param not ""
+ } //loop
+ } //params !=""
+ String[] myArgs = new String[7];
+ myArgs[0] = logfile; //logfile
+ myArgs[1] = dbpropfile; //db.properties
+ myArgs[2] = sql; //_sql
+ myArgs[3] = outformat; //outformat
+ myArgs[4] = delim; //_delim
+ myArgs[5] = header; //header
+ myArgs[6] = unl_file;
+
+ try {
+ Doquery.go(myArgs);
+ } catch (Exception e) {
+
+ e.printStackTrace();
+ }
+
+ logger.info("Executed sql:\n " + sql);
+ } //when sql !=""
+ }
+ return params;
+ }
+
+ private boolean isDatabaseAndVersionOk(String p_database, String p_version,
+ String database, String version) {
+ boolean version_ok=false;
+ StringTokenizer st = new StringTokenizer(version, ",");
+ for (; st.hasMoreTokens();) {
+ String m_version = st.nextToken();
+ if (m_version.trim().equals(p_version))
+ version_ok=true;
+ } //loop
+
+ return (database.indexOf(p_database) > -1 || database.equals(""))
+ && (version_ok || version.equals(""));
+ }
+
+ private void extractionScript(String name, String unl_file, String params,
+ String database, String version, String p_database, String p_version) {
+ if (isDatabaseAndVersionOk(p_database, p_version, database, version)) {
+ //This is an sql-File whose result is to be unloaded
+ String[] myArgs = new String[8];
+ myArgs[0] = "-logger:" + logfile; //logfile
+ myArgs[1] = "-dbproperties:" + dbpropfile; //db.properties
+
+ myArgs[2] = "-sqlfile:" + name; //_sql
+ myArgs[3] = "-outFormat:" + outformat; //outformat
+ myArgs[4] = "-delim:" + delim; //_delim
+ myArgs[5] = "-header:" + header; //header
+ myArgs[6] = "-params:" + params;
+ if (unl_file.equals("")) {
+ if (outformat.equals("txt"))
+ myArgs[7] = "-outfile:" + name + ".unl"; //outfile
+ else
+ myArgs[7] = "-outfile:" + name + "." + outformat;
+ //outfile
+ } else
+ myArgs[7] = "-outfile:" + unl_file;
+
+ try {
+ de.superx.bin.Dosql.execute(myArgs);
+ } catch (Exception e) {
+
+ e.printStackTrace();
+ }
+ logger.info("Executed sqlFile: " + name);
+ }
+ }
+
+ private void extractTable(String name, String unl_file, String database,
+ String version, String p_database, String p_version) {
+ if (isDatabaseAndVersionOk(p_database, p_version, database, version)) {
+ String[] myArgs = new String[7];
+ myArgs[0] = logfile; //logfile
+ myArgs[1] = dbpropfile; //db.properties
+
+ myArgs[2] = "select * from " + name; //_sql
+ myArgs[3] = outformat; //outformat
+ myArgs[4] = delim; //_delim
+ myArgs[5] = header; //header
+ if (unl_file.equals("")) {
+ if (outformat.equals("txt"))
+ myArgs[6] = name + ".unl"; //outfile
+ else
+ myArgs[6] = name + "." + outformat; //outfile
+ } else
+ myArgs[6] = unl_file;
+
+ try {
+ Doquery.go(myArgs);
+ } catch (FileNotFoundException e) {
+
+ e.printStackTrace();
+ } catch (ClassNotFoundException e) {
+
+ e.printStackTrace();
+ } catch (IOException e) {
+
+ e.printStackTrace();
+ } catch (SQLException e) {
+
+ e.printStackTrace();
+ }
+
+ logger.info("Unloaded Table " + name);
+ } //if database & version correct
+
+ }
+
+ public static void main(String args[]) {
+ try {
+ SxExtractor test = new SxExtractor(args);
+ } catch (Exception ex) {
+ System.err.println("Exception caught.\n" + ex);
+ ex.printStackTrace();
+ }
+ }
+
+ private void severeEnd(String txt) {
+ logger.severe(txt);
+ System.exit(-1);
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/SxExtractorForm.java b/src/de/superx/bin/SxExtractorForm.java
new file mode 100644
index 0000000..7a905f0
--- /dev/null
+++ b/src/de/superx/bin/SxExtractorForm.java
@@ -0,0 +1,21 @@
+/*
+ * Created on 16.04.2004
+ *
+ * To change the template for this generated file go to
+ * Window>Preferences>Java>Code Generation>Code and Comments
+ */
+package de.superx.bin;
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * SxExtractorForm.java
+ * @
+ * Dieses Javaprogramm ...
+ *
+ *
+ *
+ *
+ */
+public class SxExtractorForm {
+
+}
diff --git a/src/de/superx/bin/SxJasper.java b/src/de/superx/bin/SxJasper.java
new file mode 100644
index 0000000..92bfdd6
--- /dev/null
+++ b/src/de/superx/bin/SxJasper.java
@@ -0,0 +1,404 @@
+package de.superx.bin;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Locale;
+import org.w3c.dom.Document;
+
+
+import de.memtext.util.GetOpts;
+import net.sf.jasperreports.engine.JRException;
+import net.sf.jasperreports.engine.JRExporterParameter;
+import net.sf.jasperreports.engine.JRParameter;
+import net.sf.jasperreports.engine.JasperCompileManager;
+import net.sf.jasperreports.engine.JasperExportManager;
+import net.sf.jasperreports.engine.JasperFillManager;
+import net.sf.jasperreports.engine.JasperPrint;
+import net.sf.jasperreports.engine.JasperPrintManager;
+import net.sf.jasperreports.engine.export.JRCsvExporter;
+import net.sf.jasperreports.engine.export.JRRtfExporter;
+import net.sf.jasperreports.engine.export.JRXlsExporter;
+import net.sf.jasperreports.engine.query.JRXPathQueryExecuterFactory;
+import net.sf.jasperreports.engine.util.JRXmlUtils;
+import net.sf.jasperreports.engine.util.JRLoader;
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ *
+ * @
+ * Dieses Javaprogramm führt JasperReports aus und gibt das Ergebnis aus.
+ *
+ *Aufruf: java $JAVA_OPTS -cp "$CP" de.superx.bin.SxJasper -logger:$LOGGER_PROPERTIES -db_properties:$DB_PROPERTIES -JRXML: -JASPER: -JRPRINT: -XML: -IGNORE_PAGINATION: -OUT:
+
+ Aktion: sx_jasper führt einen JasperReports-Task aus.
+ Das Ergebnis wird in eine Datei ausgegeben
+ Die Datenbankverbindung ist in $DB_PROPERTIES definiert.
+
+ Achtung: Der Workflow ist wie folgt:
+ Quelldatei.jrxml ist die XML-Beschreibungsdatei des Berichts
+
+ Task compile: Quelldatei.jrxml -> Quelldatei.jasper
+ Quelldatei.jasper ist kompilierte Beschreibungsdatei für den Bericht
+
+ Task fill/fillIgnorePagination: Quelldatei.jasper -> Quelldatei.jrprint
+ Quelldatei.jrprint enthält mit Daten gefüllte Berichtsvorlage
+
+ Task pdf,csv,html,xml,xmlEmbed,rtf,xls,jxl,print: Quelldatei.jrprint -> Ausgabedatei (Default: Quelldatei+Formatspezifische Endung)
+ Rendering des Berichts wird ausgeführt.
+
+ Sonderform run:
+ Aus vorhandender .jasper-Datei wird direkt eine pdf-Datei erzeugt.
+ Setzen Sie den Logging-Level in $LOGGER_PROPERTIES auf INFO, um Laufzeiten zu sehen
+
+
+ */
+//Änderungen
+
+public class SxJasper {
+ private static Connection myDb;
+ private static Statement st; // Our statement to run queries with
+ private static DatabaseMetaData dbmd;
+ // This defines the structure of the database
+ private static boolean done = false; // Added by CWJ to permit \q command
+ private static String taskName = "run";
+ private static String jrxmlFileName = "";
+ private static String jasperFileName = "";
+ private static String jrprintFileName = "";
+ private static String XMLfileName = "";
+ private static String XSLfileName = "";
+ private static String ignorePagination = "";
+ private static String params = "";
+ private static String logfile = "../conf/logging.properties";
+ private static String dbpropfile = "../conf/db.properties";
+ private static SxConnection myConnection = null;
+ private static String db_driver;
+private static String outfile = "";
+ private static Logger logger =
+ (Logger) Logger.getLogger(SxJasper.class.toString());
+ private static final String TASK_COMPILE = "compile";
+ private static final String TASK_FILL = "fill";
+ private static final String TASK_PRINT = "print";
+ private static final String TASK_PDF = "pdf";
+ private static final String TASK_RTF = "rtf";
+ private static final String TASK_XML = "xml";
+ private static final String TASK_XML_EMBED = "xmlEmbed";
+ private static final String TASK_HTML = "html";
+ private static final String TASK_XLS = "xls";
+ private static final String TASK_JXL = "jxl";
+ private static final String TASK_CSV = "csv";
+ private static final String TASK_RUN = "run";
+ private static final String TASK_FILL_IGNORE_PAGINATION = "fillIgnorePagination";
+
+ private static String usage =
+ "-------------------------------------\nGebrauch: java de.superx.bin.SxJasper -logger=<> -JRXML=<> -OUT=<>(optional) \n---------------------------------------------------";
+
+ /**
+ * @param args
+ * @throws ClassNotFoundException
+ * @throws FileNotFoundException
+ * @throws IOException
+ * @throws SQLException
+ */
+ public static void go(String args[])
+ throws
+ ClassNotFoundException,
+ FileNotFoundException,
+ IOException,
+ SQLException {
+ if (args.length== 0) {
+ throw new IllegalArgumentException("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, outfile) erfoderlich");
+
+ }
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts.isAllRequiredOptionsPresent("-logger,-db_properties,-JRXML");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+ if (GetOpts.isPresent("-logger"))
+ logfile = GetOpts.getValue("-logger");
+ if (GetOpts.isPresent("-JRXML"))
+ jrxmlFileName = GetOpts.getValue("-JRXML");
+ if (GetOpts.isPresent("-JASPER"))
+ jasperFileName = GetOpts.getValue("-JASPER");
+ else
+ jasperFileName=de.memtext.util.FileUtils.getFileNameWithoutSuffix(jrxmlFileName)+".jasper";
+ if (GetOpts.isPresent("-JRPRINT"))
+ jrprintFileName = GetOpts.getValue("-JRPRINT");
+ else
+ jrprintFileName=de.memtext.util.FileUtils.getFileNameWithoutSuffix(jrxmlFileName)+".jrprint";
+ if (GetOpts.isPresent("-XML"))
+ XMLfileName = GetOpts.getValue("-XML");
+ if (GetOpts.isPresent("-IGNORE_PAGINATION"))
+ ignorePagination = GetOpts.getValue("-IGNORE_PAGINATION");
+ if (GetOpts.isPresent("-XSL"))
+ XSLfileName = GetOpts.getValue("-XSL");
+ if (GetOpts.isPresent("-OUT"))
+ outfile = GetOpts.getValue("-OUT");
+ else
+ outfile=de.memtext.util.FileUtils.getFileNameWithoutSuffix(jrxmlFileName)+".pdf";
+ if (GetOpts.isPresent("-db_properties"))
+ dbpropfile = GetOpts.getValue("-db_properties");
+ if (GetOpts.isPresent("-param"))
+ params = GetOpts.getValue("-param");
+
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile = MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + logfile);
+ try
+ {
+ long start = System.currentTimeMillis();
+ if (!jrxmlFileName.equals(""))
+ {
+ if (jasperFileName.equals(""))
+ jasperFileName=JasperCompileManager.compileReportToFile(jrxmlFileName);
+ else
+ JasperCompileManager.compileReportToFile(jrxmlFileName,jasperFileName);
+ logger.info("Compile time : " + (System.currentTimeMillis() - start));
+ }
+ if (!jasperFileName.equals("") )
+ {
+ logger.info("Filling " + jasperFileName);
+
+ //Preparing parameters
+ Map parameters = new HashMap();
+ if(!XMLfileName.equals(""))
+ {
+ logger.info("XML-Source " + XMLfileName);
+ Document document = JRXmlUtils.parse(new File(XMLfileName));
+ parameters.put(JRXPathQueryExecuterFactory.PARAMETER_XML_DATA_DOCUMENT, document);
+ parameters.put(JRXPathQueryExecuterFactory.XML_DATE_PATTERN, "dd.MM.yyyy HH:mm:ss");
+ parameters.put(JRXPathQueryExecuterFactory.XML_NUMBER_PATTERN, "###0.00;-###0.00");
+ parameters.put(JRXPathQueryExecuterFactory.XML_LOCALE, Locale.GERMAN);
+ parameters.put(JRParameter.REPORT_LOCALE, Locale.GERMAN);
+ }
+ else
+ getConnection(logger, dbpropfile);
+
+ //parameters.put("ReportTitle", "Rektorenliste");
+ //parameters.put("FilterClause", "'Boston', 'Chicago', 'Oslo'");
+ //parameters.put("OrderClause", "City");
+
+ if (ignorePagination.equals("true"))
+ {
+ parameters.put(JRParameter.IS_IGNORE_PAGINATION, Boolean.TRUE);
+ }
+
+ if (jrprintFileName.equals(""))
+ jrprintFileName=JasperFillManager.fillReportToFile(jasperFileName, parameters, myDb);
+ else
+ JasperFillManager.fillReportToFile(jasperFileName, jrprintFileName, parameters, myDb);
+
+ logger.info("Filling time : " + (System.currentTimeMillis() - start));
+
+ }
+ if (outfile.endsWith(".prn"))
+ {
+ JasperPrintManager.printReport(jrprintFileName, true);
+ logger.info("Printing time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }
+ if (outfile.endsWith(".pdf"))
+ {
+ JasperExportManager.exportReportToPdfFile(jrprintFileName,outfile);
+ logger.info("PDF creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }
+ if (outfile.endsWith(".rtf"))
+ {
+ File sourceFile = new File(jrprintFileName);
+
+ JasperPrint jasperPrint = (JasperPrint)JRLoader.loadObject(sourceFile);
+ File destFile = new File(sourceFile.getParent(), outfile);
+
+ JRRtfExporter exporter = new JRRtfExporter();
+
+ exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
+ exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
+
+ exporter.exportReport();
+
+ logger.info("RTF creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }
+ if (outfile.endsWith(".xml"))
+ {
+ JasperExportManager.exportReportToXmlFile(jrprintFileName,outfile, false);
+ logger.info("XML creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }
+ /*else if (TASK_XML_EMBED.equals(taskName))
+ {
+ if(outfile.equals(""))
+ outfile=jrxmlFileName + ".xml";
+ JasperExportManager.exportReportToXmlFile(jrprintFileName,outfile, true);
+ logger.info("XML creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }*/
+ if (outfile.endsWith(".htm") || outfile.endsWith(".html"))
+ {
+ JasperExportManager.exportReportToHtmlFile(jrprintFileName,outfile);
+ logger.info("HTML creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }
+ if (outfile.endsWith(".xls"))
+ {
+ File sourceFile = new File(jrprintFileName);
+
+ JasperPrint jasperPrint = (JasperPrint)JRLoader.loadObject(sourceFile);
+
+ File destFile = new File(sourceFile.getParent(), outfile);
+
+ JRXlsExporter exporter = new JRXlsExporter();
+
+ exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
+ exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
+ //exporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.FALSE);
+
+ exporter.exportReport();
+
+ logger.info("XLS creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }
+ /* else if (TASK_JXL.equals(taskName))
+ {
+ File sourceFile = new File(jrprintFileName);
+
+ JasperPrint jasperPrint = (JasperPrint)JRLoader.loadObject(sourceFile);
+ if(outfile.equals(""))
+ outfile=jasperPrint.getName() + ".jxl.xls";
+
+ File destFile = new File(sourceFile.getParent(), outfile);
+
+ JExcelApiExporter exporter = new JExcelApiExporter();
+
+ exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
+ exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
+ exporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.TRUE);
+
+ exporter.exportReport();
+
+ logger.info("XLS creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }*/
+ if (outfile.endsWith(".csv"))
+ {
+ File sourceFile = new File(jrprintFileName);
+
+ JasperPrint jasperPrint = (JasperPrint)JRLoader.loadObject(sourceFile);
+ File destFile = new File(sourceFile.getParent(), outfile);
+
+ JRCsvExporter exporter = new JRCsvExporter();
+
+ exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
+ exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
+
+ exporter.exportReport();
+
+ logger.info("CSV creation time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }
+ /*else if (TASK_RUN.equals(taskName))
+ {
+ //Preparing parameters
+ Map parameters = new HashMap();
+ //parameters.put("ReportTitle", "Address Report");
+ //parameters.put("FilterClause", "'Boston', 'Chicago'");
+ //parameters.put("OrderClause", "City");
+ if(outfile.equals(""))
+ outfile=jrxmlFileName+".pdf";
+ getConnection(logger, dbpropfile);
+ JasperRunManager.runReportToPdfFile(jrxmlFileName+".jasper",outfile, parameters, myDb);
+ logger.info("PDF running time : " + (System.currentTimeMillis() - start));
+ System.exit(0);
+ }*/
+ }
+ catch (JRException e)
+ {
+ e.printStackTrace();
+ System.exit(1);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ System.exit(1);
+ }
+ //getConnection(logger, dbpropfile);
+
+
+ logger.info("SxJasper erfolgreich beendet");
+
+ }
+
+ /*
+ * Display some instructions on how to run the example
+ */
+ public static void instructions() {
+ System.out.println("SuperX @version@\n");
+ System.out.println(
+ "\nDieses Java-Programm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.\n");
+ System.out.println(
+ "Gebrauch:\n java doquery (optional) (optional) (optional)\n");
+ System.exit(1);
+ }
+
+ public static void main(String args[]) {
+//args=new String[7];
+//args[0]="e:\\superx\\logging.properties";
+//args[1]="e:/superx/db.properties";
+//args[2]="select * from sos_stud_allg_cube";; ;
+//args[3]="txt";
+//args[4]="^";
+//args[5]="false";
+//args[6]="e:/superx/test.unl";
+ try {
+ go(args);
+ } catch (Exception ex) {
+ System.err.println("Doquery Aufruf fehlgeschlagen.\n" + ex);
+ ex.printStackTrace();
+ System.exit(1);
+ }
+ }
+ public static void getConnection(Logger logger,String propFile) throws SQLException {
+ myConnection = new SxConnection();
+ myConnection.setPropfile(propFile);
+ logger.config("Starting Connection...");
+ try {
+ myDb = myConnection.getConnection();
+ st = myDb.createStatement();
+ //st = myDb.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
+ // java.sql.ResultSet.CONCUR_READ_ONLY);
+ //st.setFetchSize(100);
+ dbmd = myDb.getMetaData();
+ //st = myDb.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
+ //ResultSet.CONCUR_UPDATABLE);
+ } catch (Exception e) {
+ logger.severe("Keine DB-Verbindung: " + e.toString());
+ throw new SQLException("Keine DB-Verbindung: " + e.toString());
+ }
+ db_driver = myConnection.m_DriverClass;
+
+ }
+
+
+}
diff --git a/src/de/superx/bin/SxJdbcClient.java b/src/de/superx/bin/SxJdbcClient.java
new file mode 100644
index 0000000..cf0c740
--- /dev/null
+++ b/src/de/superx/bin/SxJdbcClient.java
@@ -0,0 +1,1127 @@
+package de.superx.bin;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * SxJdbcClient.java
+ * @
+ * Dieses Klasse stellt einen jdbc-Client zur Verfügung.
+ * Sie stellt eine Verbindung mit SxConnection her, und führt sql-Ausdrücke aus.
+ * Das Ergebnis findet sich in der Eigenschaft rs (ResultSet).
+ *
+ *
+ *
+ */
+
+public class SxJdbcClient {
+ String sqlstmt;
+ String propFile;
+ //public static String propfile="../conf/db.properties";
+ String loglevel = "../conf/logging.properties";
+ public Logger myLogger = null; // = Logger.getLogger(SxJdbcClient.class);
+ Connection myDb = null;
+ SxConnection myConnection = null;
+ public Statement st = null;
+ public PreparedStatement pst = null;
+ public DatabaseMetaData dbmd;
+ public ResultSet rs = null;
+ public ResultSetMetaData rsmd = null;
+ public String db_driver = null;
+ private final List _keywords = new ArrayList();
+ private final List _dataTypes = new ArrayList();
+ private final List _functions = new ArrayList();
+ private final List _tables = new ArrayList();
+ private final List _columns = new ArrayList();
+ private boolean isLogAllResultSetsToConsole = false;
+ public String[] mySchemas = null;
+
+ public SxJdbcClient(Logger logger, String dbpropfile) {
+ propFile = dbpropfile;
+ myLogger = logger;
+ myLogger.config("Starting the jdbc-Client.");
+ //loglevel=myLogger.getRootLogger().getLevel().toString().trim();
+ }
+ public SxJdbcClient(Logger logger, String dbpropfile, String sql) {
+ propFile = dbpropfile;
+ setSqlstmt(sql);
+ myLogger = logger;
+ myLogger.config("Starting the jdbc-Client.");
+ //loglevel=myLogger.getRootLogger().getLevel().toString().trim();
+ }
+
+ public synchronized void sqlResultSet(Statement st, String sql)
+ throws SQLException {
+ sql = sql.trim();
+ int pos = 0;
+ boolean type = false;
+ myLogger.info("sql-stmt: " + sql);
+ //variante \! echo " .." ist eigentlich für psql, \ entfernen
+ if (sql.startsWith("\\!")) sql=sql.substring(1);
+ // ein Shell Kommando ausführen
+ if (sql.startsWith("!")) {
+ pos = sql.indexOf("\n");
+ if (pos == -1)
+ executeShellScript(sql.substring(1));
+ else {
+ executeShellScript(sql.substring(1, pos));
+ // System.out.println("rest: "+sql.substring(pos+1));
+ sqlResultSet(st, sql.substring(pos + 1));
+ }
+ } else {
+ type = st.execute(sql);
+ boolean loop = true;
+ //while (loop)
+ //{
+
+ if (type) {
+ // A ResultSet was returned
+ rs = st.getResultSet();
+ rsmd = rs.getMetaData();
+
+ if (isLogAllResultSetsToConsole)
+ logToConsole(rs);
+ } else {
+ int count = st.getUpdateCount();
+ rs = null;
+ rsmd = null;
+ if (count == -1) {
+ // This indicates nothing left
+ loop = false;
+ } else {
+ // An update count was returned
+ myLogger.info("Statement executed; " + count + " rows");
+ }
+ }
+ }
+ //if (loop)
+ // type = st.getMoreResults();
+ //}
+
+ //return(rs);
+
+ }
+ private void logToConsole(ResultSet rs) throws SQLException {
+ int colCount = rs.getMetaData().getColumnCount();
+ StringBuffer buf = new StringBuffer();
+ while (rs.next()) {
+ for (int i = 1; i <= colCount; i++) {
+ buf.append(rs.getObject(i) + " ^");
+ }
+ buf.append("\n");
+ }
+ if (buf.length()>1) System.out.println(buf.toString());
+ }
+ /**
+ * wird erst in eine temporäre Datei geschrieben und dann ausgeführt
+ * weil direktes Ersetzen von Umgebungsvariablen wie
+ * sx_auto_upload_table.x userinfo $JOOLAPDIR/.../rohdaten/unl/userinfo.unl nicht funktionierte
+ * @param inString - Echtes Kommando ohne ! am Anfang
+ */
+ private void executeShellScript(String inString) {
+ if (inString.startsWith("!"))
+ throw new IllegalArgumentException("kein ! erlaubt");
+ String extCommand = "";
+ myLogger.info("SxJdbcClient - executing shell command:" + inString);
+ if (inString == null || inString.length() < 1) {
+ return;
+ }
+ try {
+ File fp = new File(".");
+ File f=File.createTempFile("_tmp", ".x", fp);
+ FileWriter fw = new FileWriter(f);
+ fw.write(inString);
+ fw.flush();
+ fw.close();
+
+ sendToShell("! chmod +x "+f.getAbsolutePath());
+ sendToShell("! "+f.getAbsolutePath());
+
+ if (myLogger != null
+ && f != null
+ && myLogger.getLevel() != null
+ && myLogger.getLevel().intValue() <= Level.INFO.intValue())
+ f.delete();
+ } catch (Exception e) {
+ // e.printStackTrace();
+ throw new RuntimeException(
+ "Failed to execute command '" + inString + "': " + e);
+
+ }
+ return;
+ }
+ /**
+ * basically a copy from HSQl SQLTOOL
+ * @param inString
+ * @return
+ * @throws IOException
+ * @throws InterruptedException
+ */
+ private void sendToShell(String inString)
+ throws IOException, InterruptedException {
+ String extCommand;
+ StringTokenizer toker = new StringTokenizer(inString);
+ String other = null;
+ String arg1 = null;
+ arg1 = toker.nextToken();
+
+ if (toker.hasMoreTokens()) {
+ other = toker.nextToken("").trim();
+ }
+ InputStream stream;
+ byte[] ba = new byte[1024];
+ extCommand =
+ ((arg1.length() == 1) ? "" : arg1.substring(1))
+ + ((arg1.length() > 1 && other != null) ? " " : "")
+ + ((other == null) ? "" : other);
+
+ Process proc = Runtime.getRuntime().exec(extCommand);
+ proc.getOutputStream().close();
+ int i;
+ stream = proc.getInputStream();
+ while ((i = stream.read(ba)) > 0) {
+ System.out.println(new String(ba, 0, i));
+ }
+ stream.close();
+ stream = proc.getErrorStream();
+ while ((i = stream.read(ba)) > 0) {
+ System.out.println(new String(ba, 0, i));
+ }
+ stream.close();
+ if (proc.waitFor() != 0) {
+ throw new RuntimeException(
+ "Failed to execute command '" + extCommand + "'");
+ }
+
+ }
+
+ /*
+ * This displays a result set.
+ * Note: it closes the result once complete.
+ */
+
+ /*
+ * This process / commands (for now just /d)
+ */
+ public void Rs_executeALL() throws SQLException {
+ if(myConnection==null) getConnection();
+ StringTokenizer stoken = new StringTokenizer(sqlstmt, ";");
+
+ int n = 0;
+
+ while (stoken.hasMoreTokens()) {
+ n++;
+ String sql = stoken.nextToken().trim();
+ myLogger.info("Statement Nummer " + n + ": ");
+
+ if (sql.length() > 5) {
+ sqlResultSet(st, sql);
+ //rs = st.getResultSet();
+ }
+
+ //rs=sqlResultSet(st,sql);
+ }
+ /*try {
+ myConnection.close();
+ } catch (SQLException e) {
+ myLogger.severe("Failed to close connection: "+e.toString());
+ }
+ */
+
+ }
+ public void execute() throws SQLException {
+ try {
+ getConnection();
+ } catch (SQLException e) {
+ myLogger.severe("Failed to get connection: " + e.toString());
+ throw new SQLException("Failed to get connection: " + e.toString());
+ }
+ myLogger.info("Statement : " + sqlstmt);
+
+ if (sqlstmt.length() > 5) {
+ sqlResultSet(st, sqlstmt);
+ //rs = st.getResultSet();
+ }
+
+ //rs=sqlResultSet(st,sql);
+
+ }
+ public void executeQueryWithinConnection() throws SQLException {
+ myLogger.info("Statement : " + sqlstmt);
+
+ if (sqlstmt.length() > 5) {
+ sqlResultSet(st, sqlstmt);
+ //rs = st.getResultSet();
+ }
+
+ //rs=sqlResultSet(st,sql);
+
+ }
+ public static void updateRs(
+ ResultSet rs,
+ int col,
+ int coltype,
+ String wert) {
+ try {
+ if (col == 1)
+ rs.updateString(col, wert);
+ } catch (SQLException e) {
+ System.err.println("SQL-Insert Fehler:" + e.toString());
+
+ //rs.updateNull(col);
+ }
+
+ }
+ public void TableColumns(String tabelle) {
+
+ try {
+ getConnection();
+ if (!dbmd.storesLowerCaseIdentifiers())
+ tabelle = tabelle.toUpperCase();
+ myLogger.config(
+ "Tabellenkatalog für "
+ + tabelle
+ + " in Datenbank "
+ + myConnection.getCatalog());
+
+ rs =
+ dbmd.getColumns(myConnection.getCatalog(), null, tabelle, null);
+ rsmd = rs.getMetaData();
+ } catch (SQLException e) {
+ myLogger.severe(
+ "Tabellenkatalog für "
+ + tabelle
+ + " konnte nicht erstellt werden: "
+ + e.toString());
+
+ }
+ /*try {
+ myConnection.close();
+ } catch (SQLException e) {
+ myLogger.severe("Failed to close connection: "+e.toString());
+ }
+ */
+ }
+ public void prepareStatement(String sql) {
+
+ try {
+ getConnection();
+ myLogger.config(
+ "PrepareStatement für "
+ + sql
+ + " in Datenbank "
+ + myConnection.getCatalog());
+ pst = myConnection.con.prepareStatement(sql);
+ } catch (SQLException e) {
+ myLogger.severe(
+ "PrepareStatement konnte nicht erstellt werden für SQL-Statement:"
+ + sql
+ + ": "
+ + e.toString());
+ System.exit(-1);
+ }
+
+ }
+ public String getTableSchema(String tabelle) throws SQLException {
+ String myCatalog="";
+ try {
+ getConnection();
+ } catch (SQLException e) {
+ myLogger.severe("Failed to get connection: " + e.toString());
+ throw new SQLException("Failed to get connection: " + e.toString());
+ }
+ String zs = "";
+ String table_type="";
+ if(tabelle.equals(""))
+ {
+ //Schema für alle Tabellen
+ zs += "";
+ try {
+ myCatalog=myConnection.getCatalog();
+ myLogger.config(
+ "Column-katalog für "
+ +" Datenbank "
+ + myCatalog);
+ } catch (SQLException e) {
+ myLogger.info(
+ "getCatalog nicht implementiert " + e.toString());
+ myCatalog=null;
+ }
+ ResultSet myTables=dbmd.getTables(myCatalog,null,null,null);
+ if(myTables != null)
+ {
+ while (myTables.next()) {
+ tabelle = myTables.getString( "TABLE_NAME");
+ table_type=myTables.getString( "TABLE_TYPE");
+
+ if((table_type==null || table_type.equalsIgnoreCase("TABLE")) && !tabelle.startsWith("_")){
+ myLogger.info("Getting Table "+tabelle);
+ zs += myTableSchema(tabelle);
+ }
+ }
+
+ }
+ zs += "";
+ }
+ else
+ //only one Table is asked for
+ zs = myTableSchema(tabelle);
+
+ try {
+ myConnection.close();
+ } catch (SQLException e) {
+ myLogger.severe("Failed to close connection: " + e.toString());
+ }
+
+ return zs;
+ }
+ /**
+ * @param tabelle
+ * @param zs
+ * @return
+ */
+ private String myTableSchema(String tabelle) {
+ String mzs="\n";
+
+ if (db_driver.equals("org.hsqldb.jdbcDriver") || db_driver.equalsIgnoreCase("oracle.jdbc.oracledriver"))
+ tabelle = tabelle.toUpperCase();
+ SxTransformer myTransformer = null;
+ myTransformer = new SxTransformer(myLogger);
+ myTransformer.setDelim("");
+ myTransformer.setHeader("false");
+ mzs += ""
+ + getColumnSchema(tabelle, myTransformer)
+ + "\n";
+ mzs += ""
+ + getIndexSchema(tabelle, myTransformer)
+ + "\n";
+ mzs += ""
+ + getPrimaryKeySchema(tabelle, myTransformer)
+ + "\n";
+ mzs += ""
+ + getForeignKeySchema(tabelle, myTransformer)
+ + "\n";
+ mzs += ""
+ + getImportedKeySchema(tabelle, myTransformer)
+ + "\n";
+ mzs += ""
+ + getPrivilegeSchema(tabelle, myTransformer)
+ + "\n";
+ mzs += "
\n";
+ return mzs;
+ }
+ private String getIndexSchema(
+ String tabelle,
+ SxTransformer myTransformer) {
+ String zs = "";
+ String myCatalog="";
+
+ try {
+ myCatalog=myConnection.getCatalog();
+ myLogger.config(
+ "Index-katalog für "
+ + tabelle
+ + " in Datenbank "
+ + myCatalog);
+ } catch (SQLException e) {
+ myLogger.info(
+ "getCatalog nicht implementiert " + e.toString());
+ myCatalog=null;
+ }
+ //zuerst Primary Keys rausfinden, damit die nicht doppelt rauskommen
+ String primaryKeys="";
+ try {
+ rs = dbmd.getPrimaryKeys(myCatalog, null, tabelle);
+ rsmd = rs.getMetaData();
+ if (rs != null) {
+ myTransformer.setOutrs(rs);
+ myTransformer.setOutrsmd(getRsmd());
+ primaryKeys += myTransformer.getResult("xml");
+ } else
+ myLogger.info("Keine Rückgabewerte aus PrimaryKey-schema");
+ } catch (SQLException e) {
+ myLogger.severe(
+ "PrimaryKey-katalog konnte nicht erstellt werden: "
+ + e.toString());
+ }
+
+ try {
+ try {
+ rs =
+ dbmd.getIndexInfo(
+ myCatalog,
+ null,
+ tabelle, //tabelle.toUpperCase(),
+ false,
+ false);
+ } catch (Exception e) {
+ //Sowohl Postgres als auch Informix erkennen manche Indizes nicht!
+ //Deshalb wird null abgefangen
+ rs = null;
+ }
+ if (rs != null) {
+ rsmd = rs.getMetaData();
+ String[] indexes = new String[255];
+ String[] uniqueIndex = new String[255];
+ String[] indexCols = new String[255];
+ int i = 1;
+ int k = 1;
+ /*myTransformer.setOutrs( rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+ */
+ while (rs.next()) {
+ boolean neuerIndex = true;
+
+ String indexName = rs.getString("INDEX_NAME");
+ if (indexName != null && primaryKeys.indexOf(""+indexName.trim()+"") <0 )
+ {
+ indexName=indexName.trim();
+
+ if (i > 1) {
+ //existiert der index schon?
+ for (k = 1; k < i; k++) {
+ if (indexes[k].equals(indexName)) {
+
+ neuerIndex = false;
+ break;
+ }
+
+ }
+
+ }
+
+ if (neuerIndex) {
+ indexes[i] = indexName;
+ uniqueIndex[i] = rs.getString("non_unique");
+ //Postgres macht daraus "false", informix "0"
+ if (uniqueIndex[i].equals("0")
+ || uniqueIndex[i].equals("false"))
+ uniqueIndex[i] = "true";
+ else
+ uniqueIndex[i] = "false";
+
+ indexCols[i] =
+ "\n";
+ i++;
+ } else {
+ indexCols[k] += "\n";
+
+ //i++;
+ }
+ } //Wenn indexName != null
+
+ } //von while
+ for (k = 1; k < i; k++) {
+ if (!indexes[k].startsWith("1")) {
+ //only if this is not an automatically created index in Informix
+ zs += "\n";
+ zs += indexCols[k];
+ zs += "\n";
+ }
+ }
+
+ } else
+ myLogger.warning("Keine Rückgabewerte aus Indexschema");
+ } catch (SQLException e) {
+ myLogger.severe(
+ "Indexkatalog konnte nicht erstellt werden: " + e.toString());
+ }
+
+ return (zs);
+ }
+ private String getPrivilegeSchema(
+ String tabelle,
+ SxTransformer myTransformer) {
+ String zs = "";
+ String myCatalog="";
+
+ try {
+ myCatalog=myConnection.getCatalog();
+ myLogger.config(
+ "Privileges-katalog für "
+ + tabelle
+ + " in Datenbank "
+ + myCatalog);
+ } catch (SQLException e) {
+ myLogger.info(
+ "getCatalog nicht implementiert " + e.toString());
+ myCatalog=null;
+ }
+ try {
+ rs =
+ dbmd.getTablePrivileges(
+ myCatalog,
+ null,
+ tabelle.toUpperCase());
+ rsmd = rs.getMetaData();
+ if (rs != null) {
+ myTransformer.setOutrs(rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+ } else
+ myLogger.info("Keine Rückgabewerte aus Privilegschema");
+ } catch (SQLException e) {
+ myLogger.severe(
+ "Privilegkatalog konnte nicht erstellt werden: "
+ + e.toString());
+ }
+
+ return (zs);
+ }
+ private String getForeignKeySchema(
+ String tabelle,
+ SxTransformer myTransformer) {
+ String zs = "";
+ String myCatalog="";
+
+ try {
+ myCatalog=myConnection.getCatalog();
+ myLogger.config(
+ "ForeignKey-katalog für "
+ + tabelle
+ + " in Datenbank "
+ + myCatalog);
+ } catch (SQLException e) {
+ myLogger.info(
+ "getCatalog nicht implementiert " + e.toString());
+ myCatalog=null;
+ }
+ try {
+ rs = dbmd.getExportedKeys(myCatalog, null, tabelle);
+ rsmd = rs.getMetaData();
+ if (rs != null) {
+ myTransformer.setOutrs(rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+ } else
+ myLogger.info("Keine Rückgabewerte aus ForeignKey-schema");
+ } catch (SQLException e) {
+ myLogger.severe(
+ "ForeignKey-katalog konnte nicht erstellt werden: "
+ + e.toString());
+ }
+
+ return (zs);
+ }
+
+ private String getPrimaryKeySchema(
+ String tabelle,
+ SxTransformer myTransformer) {
+ String zs = "";
+ String myCatalog="";
+
+ try {
+ myCatalog=myConnection.getCatalog();
+ myLogger.config(
+ "PrimaryKey-katalog für "
+ + tabelle
+ + " in Datenbank "
+ + myCatalog);
+ } catch (SQLException e) {
+ myLogger.info(
+ "getCatalog nicht implementiert " + e.toString());
+ myCatalog=null;
+ }
+ try {
+ rs = dbmd.getPrimaryKeys(myCatalog, null, tabelle);
+ rsmd = rs.getMetaData();
+ if (rs != null) {
+ myTransformer.setOutrs(rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+ } else
+ myLogger.info("Keine Rückgabewerte aus PrimaryKey-schema");
+ } catch (SQLException e) {
+ myLogger.severe(
+ "PrimaryKey-katalog konnte nicht erstellt werden: "
+ + e.toString());
+ }
+
+ return (zs);
+ }
+
+ private String getImportedKeySchema(
+ String tabelle,
+ SxTransformer myTransformer) {
+ String zs = "";
+ String myCatalog="";
+
+ try {
+ myCatalog=myConnection.getCatalog();
+ myLogger.config(
+ "ImportedKeys-katalog für "
+ + tabelle
+ + " in Datenbank "
+ + myCatalog);
+ } catch (SQLException e) {
+ myLogger.info(
+ "getCatalog nicht implementiert " + e.toString());
+ myCatalog=null;
+ }
+ try {
+ rs = dbmd.getImportedKeys(myCatalog, null, tabelle);
+ rsmd = rs.getMetaData();
+ if (rs != null) {
+ myTransformer.setOutrs(rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+ } else
+ myLogger.info("Keine Rückgabewerte aus ImportedKey-schema");
+ } catch (SQLException e) {
+ myLogger.severe(
+ "ImportedKey-katalog konnte nicht erstellt werden: "
+ + e.toString());
+ }
+
+ return (zs);
+ }
+ private String getColumnSchema(
+ String tabelle,
+ SxTransformer myTransformer) {
+ String zs = "";
+ String myCatalog="";
+
+ try {
+ myCatalog=myConnection.getCatalog();
+ myLogger.config(
+ "Column-katalog für "
+ + tabelle
+ + " in Datenbank "
+ + myCatalog);
+ } catch (SQLException e) {
+ myLogger.info(
+ "getCatalog nicht implementiert " + e.toString());
+ myCatalog=null;
+ }
+ try {
+
+ /*rs=dbmd.getColumns(myConnection.getCatalog(),null,tabelle,null);
+ rsmd = rs.getMetaData();
+ if(rs != null)
+ {
+
+ myTransformer.setOutrs( rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+
+
+ }
+ else
+
+ myLogger.info("Keine Rückgabewerte aus Column-schema");
+ */
+ rs =
+ //dbmd.getColumns(myConnection.getCatalog(), null, tabelle, null);
+ dbmd.getColumns(myCatalog, null, tabelle, null);
+ rsmd = rs.getMetaData();
+ if (rs != null) {
+ /*
+ myTransformer.setOutrs( rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+ */
+ while (rs.next()) {
+ String colName = "";
+ String colType = "";
+ String colSize = "";
+ String colNotNull = "";
+ String colDefault = "";
+
+ String colDescription = "";
+ colName = rs.getString("COLUMN_NAME").toLowerCase();
+
+ colType = SxDBUtils.getSqlTypeName(rs.getInt("DATA_TYPE"));
+
+ String digits = rs.getString("DECIMAL_DIGITS");
+ String columSize=rs.getString("COLUMN_SIZE");
+
+ if (colType.equals("NUMERIC") || colType.equals("DECIMAL"))
+ {
+ if(db_driver.equalsIgnoreCase("oracle.jdbc.oracledriver") && columSize.equalsIgnoreCase("0"))
+ {
+ colType="INTEGER";
+ colSize="4";
+ }
+ else
+ colSize =
+ "(" + columSize + "," + digits + ")";
+ }
+ else
+ colSize = rs.getString("COLUMN_SIZE");
+ Object o = rs.getObject("COLUMN_DEF");
+ if (o != null)
+ colDefault = o.toString();
+ if (colDefault.equals("null"))
+ colDefault = "";
+ if (colDefault.startsWith("nextval"))
+ colType = "SERIAL";
+ digits = rs.getString("IS_NULLABLE");
+ if (digits != null && digits.equals("NO"))
+ colNotNull = "true";
+ else
+ colNotNull = "false";
+ o = rs.getObject("REMARKS");
+ if (o != null)
+ colDescription = o.toString().trim();
+
+ if (//(colSize.equals("-1") && colType.equals("VARCHAR"))
+ //||
+ colType.equals("LONGVARCHAR")) {
+ colType = "text";
+ colSize = "";
+ }
+
+ zs += "\n";
+ else
+ zs += "/>\n";
+ } //von while
+
+ } else
+ myLogger.info("Keine Rückgabewerte aus Column-schema");
+
+ } catch (SQLException e) {
+ myLogger.severe(
+ "Column-katalog konnte nicht erstellt werden: " + e.toString());
+ }
+
+ return (zs);
+ }
+
+ public String getTableSchemaHIS(String tabelle) throws SQLException {
+ try {
+ getConnection();
+ } catch (SQLException e) {
+ myLogger.severe("Failed to get connection: " + e.toString());
+ throw new SQLException("Failed to get connection: " + e.toString());
+ }
+ SxTransformer myTransformer = null;
+ myTransformer = new SxTransformer(myLogger);
+ myTransformer.setDelim("");
+ myTransformer.setHeader("false");
+
+ String zs = "";
+
+ try {
+ myLogger.config(
+ "HIS-Konformer Column-katalog für "
+ + tabelle
+ + " in Datenbank "
+ + myConnection.getCatalog());
+
+ rs =
+ dbmd.getColumns(myConnection.getCatalog(), null, tabelle, null);
+ rsmd = rs.getMetaData();
+ if (rs != null) {
+ /*
+ myTransformer.setOutrs( rs);
+ myTransformer.setOutrsmd(getRsmd());
+ zs += myTransformer.getResult("xml");
+ */
+ while (rs.next()) {
+ String colName = "";
+ String colType = "";
+ String colSize = "";
+ String colNotNull = "";
+ String colDefault = "";
+ String colKey = "false";
+ String colDescription = "";
+ colName = rs.getString("COLUMN_NAME");
+
+ colType = SxDBUtils.getSqlTypeName(rs.getInt("DATA_TYPE"));
+
+ String t = rs.getString("DECIMAL_DIGITS");
+ if (colType.equals("NUMERIC") || colType.equals("DECIMAL"))
+ colSize =
+ "(" + rs.getString("COLUMN_SIZE") + "," + t + ")";
+ else
+ colSize = rs.getString("COLUMN_SIZE");
+ Object o = rs.getObject("COLUMN_DEF");
+ if (o != null)
+ colDefault = o.toString();
+ if (colDefault.equals("null"))
+ colDefault = "";
+ if (colDefault.startsWith("nextval"))
+ colType = "SERIAL";
+ t = rs.getString("IS_NULLABLE");
+ if (t.equals("NO"))
+ colNotNull = "true";
+ else
+ colNotNull = "false";
+ if ((colSize.equals("-1") && colType.equals("VARCHAR"))
+ || colType.equals("LONGVARCHAR")) {
+ colType = "text";
+ colSize = "";
+ }
+
+ zs += "= 0) {
+ posNewLine = stmts.indexOf("\n", pos);
+ if (posNewLine > 0)
+ endOfComment = posNewLine;
+ else
+ endOfComment = -1;
+ String head = stmts.substring(0, pos);
+ String tail = "";
+ if (endOfComment > -1)
+ tail = stmts.substring(posNewLine + 1, stmts.length());
+ stmts = head + tail;
+ pos = stmts.indexOf("--");
+ }
+ sqlstmt = stmts;
+ //mehrfach NewLines ersetzen
+ while (sqlstmt.indexOf("\n\n") > -1)
+ sqlstmt = sqlstmt.replaceAll("\n\n", "\n");
+ //sqlstmt = stmts.replace('\n', ' ');
+ //System.out.println("after "+sqlstmt);
+ }
+
+ /**
+ * @return
+ */
+ public ResultSet getRs() {
+ return rs;
+ }
+
+ /**
+ * @return
+ */
+ public ResultSetMetaData getRsmd() {
+ return rsmd;
+ }
+
+ /**
+ * @param set
+ */
+ public void setRs(ResultSet set) {
+ rs = set;
+ }
+
+ /**
+ * @param data
+ */
+
+ private void loadDataTypes() {
+ try {
+ final ResultSet rs = dbmd.getTypeInfo();
+ try {
+ while (rs.next()) {
+ _dataTypes.add(rs.getString(1).trim().toUpperCase());
+ }
+ } finally {
+ rs.close();
+ }
+ } catch (Throwable ex) {
+ myLogger.severe(
+ "Error occured creating data types collection "
+ + ex.toString());
+ }
+ }
+
+ private void loadFunctions() {
+ StringBuffer buf = new StringBuffer(1024);
+
+ try {
+ buf.append(dbmd.getNumericFunctions());
+ } catch (Throwable ex) {
+ myLogger.severe("Error" + ex.toString());
+ }
+
+ buf.append(",");
+
+ try {
+ buf.append(dbmd.getStringFunctions());
+ } catch (Throwable ex) {
+ myLogger.severe("Error" + ex.toString());
+ }
+
+ buf.append(",");
+
+ try {
+ buf.append(dbmd.getTimeDateFunctions());
+ } catch (Throwable ex) {
+ myLogger.severe("Error" + ex.toString());
+ }
+
+ StringTokenizer strtok = new StringTokenizer(buf.toString(), ",");
+
+ while (strtok.hasMoreTokens()) {
+ final String func = strtok.nextToken().trim();
+ if (func.length() > 0) {
+ _functions.add(func.toUpperCase());
+ }
+ }
+ }
+
+ private void loadTables() {
+ try {
+ // TODO: Use table types from meta data?
+ final ResultSet rs =
+ dbmd.getTables(
+ null,
+ null,
+ null,
+ new String[] { "TABLE", "VIEW" });
+ while (rs.next()) {
+ _tables.add(rs.getString(3).toUpperCase());
+ }
+ } catch (Throwable th) {
+ myLogger.severe("failed to load table names" + th.toString());
+ }
+ }
+ public static void main(String args[]) {
+ new SxJdbcClient(Logger.getAnonymousLogger(), null).setSqlstmt(
+ "! echo \"adfasf\" > te.txt");
+ }
+ public boolean isLogAllResultSetsToConsole() {
+ return isLogAllResultSetsToConsole;
+ }
+
+ public void setLogAllResultSetsToConsole(boolean b) {
+ isLogAllResultSetsToConsole = b;
+ }
+
+}
+
diff --git a/src/de/superx/bin/SxTestXmlCreator.java b/src/de/superx/bin/SxTestXmlCreator.java
new file mode 100644
index 0000000..a8e8ac8
--- /dev/null
+++ b/src/de/superx/bin/SxTestXmlCreator.java
@@ -0,0 +1,79 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+
+import org.xml.sax.SAXException;
+
+import com.meterware.httpunit.GetMethodWebRequest;
+import com.meterware.httpunit.WebConversation;
+import com.meterware.httpunit.WebRequest;
+import com.meterware.httpunit.WebResponse;
+import com.meterware.httpunit.WebTable;
+
+import de.memtext.util.StringUtils;
+
+public class SxTestXmlCreator {
+ public static void main(String args[]) {
+
+ if (args.length != 1) {
+ System.out.println("usage SxTestXmlCreator filename (which contains url or sql)");
+ System.exit(-1);
+ }
+ try {
+ File f=new File(args[0]);
+ createTestXml(f);
+ } catch (Exception e) {
+ System.out.println(e);
+ }
+ }
+
+ private static void createTestXml(File f) throws MalformedURLException,
+ IOException, SAXException {
+ String input=StringUtils.readFile(f);
+
+ //if (input.startsWith("http"))
+
+ String url=input;
+ WebConversation wc = new WebConversation();
+ WebRequest req = new GetMethodWebRequest(url);
+ WebResponse resp = wc.getResponse(req);
+
+ if (resp.getTables().length == 0) {
+ System.out.println("Keine Tabelle geliefert\n" + resp.getText());
+ System.exit(1);
+ }
+
+ WebTable table = resp.getTables()[1];
+ String params=url.substring(url.indexOf("?")+1);
+ params=params.trim();
+ if (params.charAt(params.length()-1)=='\n') params=params.substring(0,params.length()-2);
+ StringBuffer erg = new StringBuffer(
+ "\n \n");
+ for (int col = 0; col < table.getColumnCount(); col++) {
+ for (int row = 0; row < table.getRowCount(); row++) {
+ String val = table.getTableCell(row, col).getText();
+ //wenn \n vorkommt test auskommentieren
+ if (val.indexOf("\n")> -1) erg.append("");
+ }
+ }
+
+ erg.append("\n");
+
+
+
+
+
+
+
+ StringUtils.write(new File("temp.xml"),erg.toString());
+ System.out.println("XML ist in temp.xml");
+ }
+
+}
+
+//Created on 27.04.2006 at 14:47:18
diff --git a/src/de/superx/bin/SxTransformer.java b/src/de/superx/bin/SxTransformer.java
new file mode 100644
index 0000000..9bc066f
--- /dev/null
+++ b/src/de/superx/bin/SxTransformer.java
@@ -0,0 +1,894 @@
+package de.superx.bin;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.Writer;
+import java.net.URI;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.StringTokenizer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.URIResolver;
+import javax.xml.transform.sax.SAXResult;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.fop.apps.FOUserAgent;
+import org.apache.fop.apps.Fop;
+import org.apache.fop.apps.FopConfParser;
+import org.apache.fop.apps.FopFactory;
+import org.apache.fop.apps.FopFactoryBuilder;
+import org.apache.fop.apps.MimeConstants;
+import org.jfor.jfor.converter.Converter;
+import org.xml.sax.InputSource;
+
+import de.superx.util.SqlStringUtils;
+
+// ACHTUNG - PDF ERZEUGUNG WIEDER AKTIV DQ 27.12.2005!!!
+
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX SxTransformer.java @ Dieses
+ * Javaprogramm transformiert ResultSets in text, html oder xml und gibt
+ * das Ergebnis als Ausgabestrom für stdout oder eine Datei aus.
+ *
+ *
+ *
+ */
+public class SxTransformer {
+
+ /**
+ *
+ */
+ private String head_delim1 = "";
+
+ private String head_delim2 = "\t";
+
+ private String header_delim1 = "";
+
+ private String header_delim2 = "\n";
+
+ private String fld_delim1 = "";
+
+ private String fld_delim2 = "\t";
+
+ private String row_delim1 = "";
+
+ private String row_delim2 = "\n";//we only user unix newline, even under
+ // DOS
+
+ private String rs_delim1 = "";
+
+ private String rs_delim2 = "";
+
+ private String delim = "\t";
+
+ private String header = "false";
+
+ private String outHeader = "";
+
+ private String outFooter = "";
+
+ public String format = "txt";
+
+ public String params = "";
+
+ public String[] XslPipeline;
+
+ public String stylesheet = "";
+
+ public PrintWriter myOutwriter;
+
+ public OutputStream myOutputStream;
+
+ public ResultSet outrs = null;
+
+ public ResultSetMetaData outrsmd = null;
+
+ public String quellstring = null;
+
+ public String outfile = "";
+ private File fopxconfFile=null;
+ public void setFopxconfFile(File fopxconfFile) {
+ this.fopxconfFile = fopxconfFile;
+ }
+
+ Logger myLogger;
+
+ String loglevel;
+
+ //PrintStream outputstream=null;
+
+ //TODO ggfs. auf Saxon umstellen
+ //TransletUtils.initFactory("net.sf.saxon.TransformerFactoryImpl",
+ // "org.apache.xalan.xsltc.trax.TransformerFactoryImpl");
+ //System.out.println("Using xsl processor: "
+ // + TransletUtils.getUsedProcessor());
+ public SxTransformer(Logger logger, PrintStream myStream) {
+ super();
+ myLogger = logger;
+ myLogger.config("Starting the Transformer with Stdout-Output.");
+ myOutwriter = new PrintWriter(myStream);
+ }
+
+ public SxTransformer(Logger logger, String myFile) {
+ super();
+ myLogger = logger;
+ myLogger.config("Starting the Transformer with File-Output.");
+ outfile = myFile;
+ myLogger.setLevel(Level.SEVERE);
+
+ }
+
+ public SxTransformer(Logger logger, FileWriter myFilewriter) {
+ super();
+ myLogger = logger;
+ myLogger.config("Starting the Transformer with File-Output.");
+ myOutwriter = new PrintWriter(new BufferedWriter(myFilewriter));
+ }
+
+ public SxTransformer(Logger logger) {
+ super();
+ myLogger = logger;
+ myLogger.config("Starting the Transformer without Stream");
+ }
+
+ public void printResult(String outFormat) {
+ //loglevel=myLogger.getRootLogger().getLevel().toString().trim();
+ assignDelims(outFormat);
+ myLogger.config("Resultset wird formatiert");
+ String f_wert = "";
+ //ResultSetMetaData rsmd = rs.getMetaData();
+
+ String zs = "";
+ String headZs = "";
+ int cols = 0;
+ Object o = null;
+ String[] lbl = null;
+ int[] types = new int[255];
+ // de.memtext.util.MemoryUtils.printfree();
+ if (outrs != null) {
+
+ try {
+ cols = outrsmd.getColumnCount();
+ lbl = new String[255];
+ zs = outHeader + rs_delim1;
+ headZs = header_delim1;
+ ;
+ // Print the result column names?
+ for (int i = 1; i <= cols; i++) {
+ lbl[i] = outrsmd.getColumnLabel(i);
+ types[i] = outrsmd.getColumnType(i);
+ if (outFormat.equals("xml")) {
+ fld_delim1 = "";
+ fld_delim2 = "";
+ } else {
+
+ if (i < cols)
+ headZs += (head_delim1 + lbl[i] + head_delim2);
+ else {
+ headZs += (head_delim1 + lbl[i] + head_delim2);
+ headZs += (header_delim2);
+ //out.newLine();
+ }
+ }
+ }
+ } catch (SQLException e1) {
+ myLogger.severe("Fehler beim Einlesen der Feldnamen: " + e1.toString());
+ e1.printStackTrace();
+ }
+ if (header.equals("true")) zs += headZs;
+
+ // try {
+ myOutwriter.write(zs);
+ myOutwriter.flush();
+ /*
+ * } catch (IOException e) { myLogger.severe("Fehler beim Ausgeben
+ * der Feldnamen: " + e.toString());
+ * }
+ */
+
+ //now the results
+ StringBuffer line = new StringBuffer();
+ try {
+ int rowCounter = 0;
+
+ do {
+
+ line.setLength(0);
+
+ line.append(row_delim1);
+ for (int i = 1; i <= cols; i++) {
+ if (outFormat.equals("xml")) {
+ fld_delim1 = "";
+ fld_delim2 = "";
+ }
+ if (types[i] == Types.LONGVARCHAR) {
+ //Der Informix-Treiber verlangt hier getString
+ // statt getObject!
+ o = outrs.getString(i);
+ } else {
+ o = outrs.getObject(i);
+ }
+ if (outrs.wasNull())
+ if (i < cols)
+ line.append(fld_delim1 + "" + fld_delim2);
+ else {
+ line.append(fld_delim1 + "" + fld_delim2);
+ line.append(row_delim2);
+ //out.newLine();
+ }
+ else {
+ //vergl. de.superx.common.Maske.getCSV
+ f_wert = SxDBUtils.field_value(o);
+ if (outFormat.equals("xml") && (f_wert.indexOf("&") > -1 || f_wert.indexOf("<") > -1 || f_wert.indexOf(">") > -1))
+ f_wert = "";
+ //wenn der Feldwert zufällig das Trennzeichen enthält, wird es mit "\" maskiert
+ if (outFormat.equals("txt")) {
+ f_wert = SxDBUtils.prepareInformixCsv(f_wert);
+ if (f_wert != null && (f_wert.indexOf(fld_delim2) > -1)) f_wert = de.memtext.util.StringUtils.replace(f_wert, fld_delim2, "\\" + fld_delim2);
+ }
+ if (i < cols)
+ line.append(fld_delim1 + f_wert + fld_delim2);
+ else {
+ line.append(fld_delim1 + f_wert + fld_delim2);
+ line.append(row_delim2);
+ }
+ }
+ }
+ myOutwriter.write(line.toString());
+ rowCounter++;
+ if (rowCounter > 10000) {
+ de.memtext.util.MemoryUtils.printfree();
+ myOutwriter.flush();
+
+ rowCounter = 0;
+ }
+ } while (outrs.next()); //von while
+
+ myOutwriter.write(rs_delim2 + outFooter);
+
+ myOutwriter.flush();
+ outrs.close();
+ myOutwriter.close();
+
+ } /*
+ * catch (IOException e) { myLogger.severe("Fehler beim Ausgeben
+ * der Feldwerte: " + e.toString()); }
+ */
+ catch (SQLException e) {
+ myLogger.warning("SQL-Fehler beim Ausgeben der Feldwerte: " + e.toString());
+ try {
+ myOutwriter.write(rs_delim2 + outFooter);
+ myOutwriter.flush();
+ myOutwriter.close();
+ outrs.close();
+ }
+ /*
+ * catch (IOException e1) { myLogger.severe("Fehler beim
+ * Ausgeben der Feldwerte: " + e1.toString()); }
+ */
+ catch (SQLException e1) {
+ myLogger.warning("SQL-Fehler beim Ausgeben der Feldwerte: " + e1.toString());
+ }
+ }
+
+ }
+
+ else //wenn outrs=null
+ {
+
+ myOutwriter.flush();
+ myOutwriter.close();
+
+ }
+ myLogger.info("resultset printed");
+
+ }
+
+ public void transformString(String methode) throws TransformerException {
+ try {
+
+ javax.xml.transform.TransformerFactory tFactory = javax.xml.transform.TransformerFactory.newInstance();
+
+ javax.xml.transform.Transformer transformer = tFactory.newTransformer(new javax.xml.transform.stream.StreamSource(stylesheet));
+ StringReader s1 = new StringReader(quellstring);
+ transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, SqlStringUtils.getEncoding());
+ transformer.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, methode);
+ transformer.setParameter("sx_client", format);
+ String result = null;
+ if (!params.endsWith(",")) params += ",";
+ StringTokenizer st = new StringTokenizer(params, ",");
+ for (; st.hasMoreTokens();) {
+ String param = st.nextToken();
+ if (!param.equals("")) {
+ String paramname = param.substring(0, param.indexOf("="));
+ String paramvalue = param.substring(param.indexOf("=") + 1, param.length());
+ transformer.setParameter(paramname, paramvalue);
+ }
+ }
+ transformer.transform(new javax.xml.transform.stream.StreamSource(s1), new javax.xml.transform.stream.StreamResult(myOutwriter));
+ } catch (Exception e) {
+ myLogger.severe("XSL-Transformation fehlgeschlagen: " + e.toString());
+
+ }
+
+ }
+
+ public void transformFile(String methode) throws TransformerException, Exception
+ {
+
+ javax.xml.transform.TransformerFactory tFactory = javax.xml.transform.TransformerFactory.newInstance("net.sf.saxon.TransformerFactoryImpl", null);
+
+ javax.xml.transform.Transformer transformer = tFactory.newTransformer(new javax.xml.transform.stream.StreamSource(this.stylesheet));
+ //StringReader s1 = new StringReader(quellstring);
+ transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, SqlStringUtils.getEncoding());
+ if (methode.equals("pdf") || methode.equals("rtf"))
+ transformer.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, "xml");
+ else
+ transformer.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, methode);
+
+ transformer.setParameter("sx_client", format);
+ transformer.setParameter("versionParam", "2.0");
+
+ // String result = null;
+ if (!params.endsWith(",")) params += ",";
+ StringTokenizer st = new StringTokenizer(params, ",");
+ for (; st.hasMoreTokens();) {
+ String param = st.nextToken();
+ if (!param.equals("")) {
+ String paramname = param.substring(0, param.indexOf("="));
+ String paramvalue = param.substring(param.indexOf("=") + 1, param.length());
+ transformer.setParameter(paramname, paramvalue);
+ }
+ }
+
+ if (methode.equals("pdf")) { //Sichern um zurücksetzen zu können.
+ Level logLevel = myLogger.getParent().getLevel();
+ myLogger.getParent().setLevel(Level.SEVERE);
+
+ // configure fopFactory as desired
+ //akt. Pfad muss WEB-INF sein oder vorher als -fopxconf Param übergeben worden sein
+
+
+ FopFactory fopFactory ;
+ FOUserAgent foUserAgent;
+
+ // in fop.xconf fopFactory.setSourceResolution(96); // =96dpi (dots/pixels per Inch)
+ if (fopxconfFile==null)
+ fopxconfFile=new File ("conf" + File.separator + "fop.xconf");
+ if (!fopxconfFile.exists())
+ {
+ String msg=fopxconfFile.getAbsolutePath()+" nicht gefunden";
+ System.out.println(msg);
+ throw new IllegalStateException(msg);
+ }
+
+ FopConfParser parser = new FopConfParser(fopxconfFile); //parsing configuration
+
+ FopFactoryBuilder builder = parser.getFopFactoryBuilder(); //building the factory with the user options
+ String fa=fopxconfFile.getCanonicalPath();
+
+ URI uri=new File(fa).getParentFile().getParentFile().toURI();
+ // System.out.println(uri);
+ builder.setBaseURI(uri);
+ builder.setStrictFOValidation(false);
+ fopFactory = builder.build();
+
+ foUserAgent = fopFactory.newFOUserAgent();
+
+
+ try {
+ myOutputStream = new java.io.FileOutputStream(outfile);
+ } catch (FileNotFoundException e) {
+ myLogger.severe("Ausgabedatei " + outfile + " kann nicht erzeugt werden:" + e.toString());
+ System.exit(-1);
+ }
+
+ try {
+ // Construct fop with desired output format
+ Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, myOutputStream);
+
+ // Setup input for XSLT transformation
+ Source src = new StreamSource(quellstring);
+
+ // Resulting SAX events (the generated FO) must be piped through to FOP
+ Result res = new SAXResult(fop.getDefaultHandler());
+
+ // Start XSLT transformation and FOP processing
+ try {
+ transformer.transform(src, res);
+ System.out.println("Success!");
+ } catch (TransformerException ex) {
+ throw new Exception(ex);
+ }
+ } catch (Exception e) {
+ e.printStackTrace(System.err);
+ myLogger.severe("FOP-Transformation Fehler: " + e.toString());
+ } finally {
+ myOutputStream.close();
+ myLogger.getParent().setLevel(logLevel);
+ }
+
+ } else {
+ if (methode.equals("rtf")) {
+ String zielstring = "";
+ myLogger.info("Ausgabedatei " + outfile + " vorbereiten");
+ Writer myWriter = null;
+ try {
+ myWriter = new BufferedWriter(new FileWriter(outfile));
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ try {
+ myLogger.info("Transformiere nach fo ");
+ transformer.transform(new javax.xml.transform.stream.StreamSource(quellstring), new StreamResult("tmp.fo"));
+
+ myLogger.info("Transformiere nach rtf ");
+
+ new Converter(new InputSource("tmp.fo"), myWriter, Converter.createConverterOption());
+ } catch (Exception e1) {
+
+ e1.printStackTrace();
+ }
+ } else {
+ if (methode.equals("xls")) {
+
+ } else {
+ //Normal xml Transformation, not fop or rtf
+ try {
+
+ FileWriter myFile = new FileWriter(outfile);
+ myOutwriter = new PrintWriter(myFile);
+ transformer.transform(new javax.xml.transform.stream.StreamSource(quellstring), new javax.xml.transform.stream.StreamResult(myOutwriter));
+ } catch (IOException e) {
+ myLogger.severe("Datei " + outfile + " kann nicht erzeugt werden: " + e.toString());
+ } catch (TransformerException e) {
+ myLogger.severe("Datei " + outfile + " kann nicht transformiert werden: " + e.toString());
+ }
+ //new javax.xml.transform.stream.StreamResult( myOutwriter));
+ }
+ }
+ }
+
+ }
+
+ public void outputString() {
+ BufferedWriter out = new BufferedWriter(myOutwriter);
+ try {
+ out.write(quellstring);
+ out.flush();
+ } catch (IOException e) {
+ myLogger.severe("Fehler beim Ausgeben des Ergebnisses: " + e.toString());
+ }
+
+ }
+
+ public String getResult(String outFormat) throws SQLException {
+
+ //loglevel=myLogger.getRootLogger().getLevel().toString().trim();
+ assignDelims(outFormat);
+ myLogger.config("Resultset wird formatiert");
+ String f_wert = "";
+ //ResultSetMetaData rsmd = rs.getMetaData();
+ int cols = outrsmd.getColumnCount();
+ String[] lbl = new String[255];
+ String zs = rs_delim1;
+ String headZs = header_delim1;
+ ;
+ // Print the result column names?
+ for (int i = 1; i <= cols; i++) {
+ lbl[i] = outrsmd.getColumnLabel(i);
+ if (outFormat.equals("xml")) {
+ fld_delim1 = "";
+ fld_delim2 = "";
+ } else {
+
+ if (i < cols)
+ headZs += (head_delim1 + lbl[i] + head_delim2);
+ else {
+ headZs += (head_delim1 + lbl[i] + head_delim2);
+ headZs += (header_delim2);
+ //out.newLine();
+ }
+ }
+ }
+ if (header.equals("true")) zs += headZs;
+
+ //now the results
+ try {
+ while (outrs.next())
+
+ {
+ zs += (row_delim1);
+ for (int i = 1; i <= cols; i++) {
+ Object o = outrs.getObject(i);
+ f_wert = SxDBUtils.field_value(o);
+ if (outFormat.equals("xml")) {
+ fld_delim1 = "";
+ fld_delim2 = "\n";
+ }
+ if (outrs.wasNull())
+ if (i < cols)
+ zs += (fld_delim1 + "" + fld_delim2);
+ else {
+ zs += (fld_delim1 + "" + fld_delim2);
+ zs += (row_delim2);
+ //out.newLine();
+ }
+ else if (i < cols)
+ zs += (fld_delim1 + f_wert.trim() + fld_delim2);
+ else {
+ zs += (fld_delim1 + f_wert.trim() + fld_delim2);
+ zs += (row_delim2);
+
+ // out.newLine();
+ }
+
+ // }
+ // catch (IOException e)
+ // {
+ // myLogger.severe("Fehler beim Ausgeben der Feldwerte:
+ // "+e.toString());
+ //
+ // }
+
+ }
+ } //von while
+ zs += (rs_delim2);
+
+ } catch (Exception e) {
+ myLogger.severe("Fehler beim Ausgeben der Feldwerte: " + e.toString());
+ }
+ outrs.close();
+
+ return zs;
+ }
+
+ private void assignDelims(String outFormat) {
+ if (outFormat.equals("html")) {
+ outHeader = "";
+ outFooter = "";
+ rs_delim1 = "";
+ head_delim1 = "";
+ head_delim2 = " | ";
+ header_delim1 = "";
+ header_delim2 = "
\n";
+ row_delim1 = "";
+ row_delim2 = "
";
+ fld_delim1 = "";
+ fld_delim2 = " | ";
+ }
+ if (outFormat.equals("xml")) {
+ outHeader = "";
+ outFooter = "";
+ rs_delim1 = "\n";
+ rs_delim2 = "";
+ head_delim1 = "";
+ head_delim2 = "";
+ header_delim1 = "";
+ header_delim2 = "";
+ row_delim1 = "\n";
+ row_delim2 = "
\n";
+ fld_delim1 = "";
+ fld_delim2 = "";
+ }
+ }
+
+ /**
+ * @return
+ */
+ public String getDelim() {
+ return delim;
+ }
+
+ /**
+ * @return
+ */
+ public String getFld_delim1() {
+ return fld_delim1;
+ }
+
+ /**
+ * @return
+ */
+ public String getFld_delim2() {
+ return fld_delim2;
+ }
+
+ /**
+ * @return
+ */
+ public String getFormat() {
+ return format;
+ }
+
+ /**
+ * @return
+ */
+ public String getHead_delim1() {
+ return head_delim1;
+ }
+
+ /**
+ * @return
+ */
+ public String getHead_delim2() {
+ return head_delim2;
+ }
+
+ /**
+ * @return
+ */
+ public String getHeader() {
+ return header;
+ }
+
+ /**
+ * @return
+ */
+ public String getHeader_delim1() {
+ return header_delim1;
+ }
+
+ /**
+ * @return
+ */
+ public String getHeader_delim2() {
+ return header_delim2;
+ }
+
+ /**
+ * @return
+ */
+ public ResultSet getOutrs() {
+ return outrs;
+ }
+
+ /**
+ * @return
+ */
+ public ResultSetMetaData getOutrsmd() {
+ return outrsmd;
+ }
+
+ /**
+ * @return
+ */
+ public String getRow_delim1() {
+ return row_delim1;
+ }
+
+ /**
+ * @return
+ */
+ public String getRow_delim2() {
+ return row_delim2;
+ }
+
+ /**
+ * @return
+ */
+ public String getRs_delim1() {
+ return rs_delim1;
+ }
+
+ /**
+ * @return
+ */
+ public String getRs_delim2() {
+ return rs_delim2;
+ }
+
+ /**
+ * @return
+ */
+ public String[] getXslPipeline() {
+ return XslPipeline;
+ }
+
+ /**
+ * @param string
+ */
+ public void setDelim(String string) {
+ delim = string;
+ fld_delim1 = "";
+ fld_delim2 = string;
+ head_delim2 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setFld_delim1(String string) {
+ fld_delim1 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setFld_delim2(String string) {
+ fld_delim2 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setFormat(String string) {
+ format = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setHead_delim1(String string) {
+ head_delim1 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setHead_delim2(String string) {
+ head_delim2 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setHeader(String string) {
+ header = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setHeader_delim1(String string) {
+ header_delim1 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setHeader_delim2(String string) {
+ header_delim2 = string;
+ }
+
+ /**
+ * @param set
+ */
+
+ public void setOutrs(ResultSet set) {
+ outrs = set;
+ }
+
+ /**
+ * @param data
+ */
+ public void setOutrsmd(ResultSetMetaData data) {
+ outrsmd = data;
+ }
+
+ /**
+ * @param string
+ */
+ public void setRow_delim1(String string) {
+ row_delim1 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setRow_delim2(String string) {
+ row_delim2 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setRs_delim1(String string) {
+ rs_delim1 = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setRs_delim2(String string) {
+ rs_delim2 = string;
+ }
+
+ /**
+ * @param strings
+ */
+ public void setXslPipeline(String[] strings) {
+ XslPipeline = strings;
+ }
+
+ /**
+ * @return
+ */
+ public String getOutFooter() {
+ return outFooter;
+ }
+
+ /**
+ * @return
+ */
+ public String getOutHeader() {
+ return outHeader;
+ }
+
+ /**
+ * @param string
+ */
+ public void setOutFooter(String string) {
+ outFooter = string;
+ }
+
+ /**
+ * @param string
+ */
+ public void setOutHeader(String string) {
+ outHeader = string;
+ }
+
+ /**
+ * @return
+ */
+ public String getParams() {
+ return params;
+ }
+
+ /**
+ * @param string
+ */
+ public void setParams(String string) {
+ params = string;
+ }
+
+ //-- nur zum Testen --//
+ public static void main(String[] args) throws Exception {
+ Logger log = Logger.getLogger(SxTransformer.class.getName());
+ String rootDir = "/home/superx/tmp/";
+ String quelle = rootDir + "Buchungsbericht_ids_Test.xml";
+ String zielFile = rootDir + "testneu.pdf";
+ String sxlSheet = "/home/superx/dev/edustore/webserver/tomcat/webapps/superx/xml/tabelle_fo_pdf.xsl";
+
+ SxTransformer sxTrans = new SxTransformer(log, zielFile);
+
+ sxTrans.quellstring = quelle;
+ sxTrans.outfile = zielFile;
+ sxTrans.stylesheet = sxlSheet;
+ sxTrans.transformFile("pdf");
+
+
+ }//Ende der Methode
+
+ public class ClasspathUriResolver implements URIResolver {
+
+ public Source resolve(String href, String base) throws TransformerException {
+ Source source = null;
+ InputStream inputStream = ClassLoader.getSystemResourceAsStream(href);
+ if (inputStream != null) {
+ source = new StreamSource(inputStream);
+ }
+ return source;
+ }
+ }
+}//Ende der Klasse
+
+
diff --git a/src/de/superx/bin/SxValidate.java b/src/de/superx/bin/SxValidate.java
new file mode 100644
index 0000000..e361e4e
--- /dev/null
+++ b/src/de/superx/bin/SxValidate.java
@@ -0,0 +1,281 @@
+package de.superx.bin;
+/*
+ * Copyright 1999-2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * $Id: Validate.java,v 1.5 2004/02/17 19:11:45 minchau Exp $
+ *
+ * Erweitert für SuperX von Daniel Quathamer
+ * 16.11.2006
+ */
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FilenameFilter;
+import java.io.IOException;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.ext.LexicalHandler;
+import org.xml.sax.helpers.DefaultHandler;
+
+/* Use JAXP SAXParser to parse 1 .xml file or all the .xml files in a directory.
+ * Takes 1 or 2 command-line arguments:
+ * Argument 1 (required) is a file name or directory name.
+ * Argument 2 (optional) is a log file name. If ommitted, messages are written to screen.
+ */
+public class SxValidate
+{
+ static int numXMLFiles = 0;
+ static int numValidFiles = 0;
+ static int numInvalidFiles = 0;
+ static int numFilesMissingDoctype = 0;
+ static int numMalformedFiles = 0;
+ static boolean useSchema = false;
+ static StringBuffer buff = new StringBuffer();
+
+ public static void main(String[] args)
+ throws FileNotFoundException, IOException, ParserConfigurationException, SAXException
+ {
+ if (args.length == 0 || args.length > 2)
+ {
+ System.out.println("\nGeben Sie 'sx_validate.x -help' für Information über SxValidate");
+ return;
+ }
+ if (args[0].toLowerCase().equals("-help"))
+ {
+ String sep = "\n====================================================\n";
+ String a = "sx_validate [SCHEMA] \nValidate nutzt Xerces um einen einzelnen XML-File zu validieren bzw. die xml Files in dem Verzeichnis das Sie spezifizieren. Der Parser validiert jedes Dokument (Konformität zum DOCTYPE oder XMLSchema).\n";
+ String b = "Jede xml Datei sollte eine DOCTYPE declaration oder einen XMLSchema-Verweis enthalten.\n\n";
+ String c = "SxValidate nimmt 1 oder 2 Argumente:\n";
+ String d = " Argument 1 spezifiziert das Verzeichnis oder die Datei.\n";
+ String e = " Argument 2 (einfach 'SCHEMA') spezifiziert, ob nach XML-Schema validiert werden soll.\n";
+ System.out.println(sep+a+b+c+d+e+sep);
+ return;
+ }
+ try
+ {
+ SxValidate v = new SxValidate();
+ v.validate(args);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ void validate(String[] args)
+ throws FileNotFoundException, IOException, ParserConfigurationException, SAXException
+ {
+ File dir = new File(args[0]);
+
+ // User may include a 2nd argument for the validation method
+
+ useSchema = false;
+ if(args.length == 2 && args[1].equalsIgnoreCase("SCHEMA"))
+ useSchema=true;
+
+ if (dir.isFile()) // Just checking one file.
+ {
+ parse(null,args[0],useSchema);
+ }
+ else if (dir.isDirectory()) // Checking the contents of a directory.
+ {
+ // Only interested in .xml files.
+ XMLFileFilter filter = new XMLFileFilter();
+ String [] files = dir.list(filter);
+ for (int i = 0; i 1)
+ buff.append("Parsed " + numXMLFiles + " .xml files in " + args[0] + ".\n");
+ if (numValidFiles > 1)
+ buff.append( numValidFiles + " files are valid.\n");
+ else if (numValidFiles == 1)
+ buff.append( numValidFiles + " file is valid.\n");
+ if (numInvalidFiles > 1)
+ buff.append(numInvalidFiles + " files are not valid.\n");
+ else if (numInvalidFiles == 1)
+ buff.append( numInvalidFiles + " file is not valid.\n");
+ if (numMalformedFiles > 1)
+ buff.append(numMalformedFiles + " files are not well-formed.\n");
+ else if (numMalformedFiles == 1)
+ buff.append( numMalformedFiles + " file is not well-formed.\n");
+ if (numFilesMissingDoctype > 1)
+ buff.append(numFilesMissingDoctype + " files do not contain a DOCTYPE declaration.\n");
+ else if (numFilesMissingDoctype == 1)
+ buff.append(numFilesMissingDoctype + " file does not contain a DOCTYPE declaration.\n");
+
+ System.out.print(buff.toString());
+
+ }
+
+ // Parse each XML file.
+ void parse(String dir, String filename,boolean useSchema)
+ throws FileNotFoundException, IOException, ParserConfigurationException, SAXException
+ {
+ try
+ {
+ File f = new File(dir, filename);
+ StringBuffer errorBuff = new StringBuffer();
+ InputSource input = new InputSource(new FileInputStream(f));
+ // Set systemID so parser can find the dtd with a relative URL in the source document.
+ input.setSystemId(f.toString());
+
+ SAXParserFactory spfact = SAXParserFactory.newInstance();
+
+ spfact.setValidating(true);
+ spfact.setNamespaceAware(true);
+
+ SAXParser parser = spfact.newSAXParser();
+ XMLReader reader = parser.getXMLReader();
+
+ //Instantiate inner-class error and lexical handler.
+ Handler handler = new Handler(filename, errorBuff);
+ reader.setProperty("http://xml.org/sax/properties/lexical-handler", handler);
+ if(useSchema)
+ {
+ parser.setProperty(
+ "http://java.sun.com/xml/jaxp/properties/schemaLanguage",
+ "http://www.w3.org/2001/XMLSchema");
+ buff.append("Nutze XML-Schema Validierung\n");
+ }
+ parser.parse(input, handler);
+ if (handler.containsDTD && !handler.errorOrWarning) // valid
+ {
+ buff.append("VALID " + filename +"\n");
+ numValidFiles++;
+ }
+ else if (handler.containsDTD) // not valid
+ {
+ buff.append ("NOT VALID " + filename + "\n");
+ buff.append(errorBuff.toString());
+ numInvalidFiles++;
+ }
+ else // no DOCTYPE to use for validation
+ {
+ if(handler.errorOrWarning)
+ {
+ buff.append("Datei " + filename +" wurde validiert:\n"+errorBuff.toString());
+ numInvalidFiles++;
+ }
+ else
+ {
+ buff.append("Datei " + filename +" wurde validiert:\n"+errorBuff.toString());
+ numValidFiles++;
+
+ }
+
+ }
+ }
+ catch (Exception e) // Serious problem!
+ {
+ buff.append("NOT WELL-FORMED " + filename + ". " + e.getMessage() + "\n");
+ numMalformedFiles++;
+ }
+ finally
+ {
+ numXMLFiles++;
+ }
+ }
+ // Inner classes
+
+ // Only interested in parsing .xml files.
+ class XMLFileFilter implements FilenameFilter
+ {
+ public boolean accept(File dir, String fileName)
+ {
+ return fileName.toLowerCase().endsWith(".xml") && new File(dir.toString(),fileName).isFile();
+ }
+ }
+
+ // Catch any errors or warnings, and verify presence of doctype statement.
+ class Handler extends DefaultHandler implements LexicalHandler
+ {
+ boolean errorOrWarning;
+ boolean containsDTD;
+ String sourceFile;
+ StringBuffer errorBuff;
+
+ Handler(String sourceFile, StringBuffer errorBuff)
+ {
+ super();
+ this.sourceFile = sourceFile;
+ this.errorBuff = errorBuff;
+ errorOrWarning = false;
+ containsDTD = false;
+ }
+
+ public void error(SAXParseException exc)
+ {
+ errorBuff.append(sourceFile + " Error: " + exc.getMessage()+ "\n");
+ errorOrWarning = true;
+ }
+ public void warning(SAXParseException exc)
+ {
+ errorBuff.append(sourceFile + " Warning:" + exc.getMessage()+ "\n");
+ errorOrWarning = true;
+ }
+
+ // LexicalHandler methods; all no-op except startDTD().
+
+ // Set containsDTD to true when startDTD event occurs.
+ public void startDTD (String name, String publicId, String systemId)
+ throws SAXException
+ {
+ containsDTD = true;
+ }
+
+ public void endDTD () throws SAXException
+ {}
+
+ public void startEntity (String name) throws SAXException
+ {}
+
+ public void endEntity (String name) throws SAXException
+ {}
+
+ public void startCDATA () throws SAXException
+ {}
+
+ public void endCDATA () throws SAXException
+ {}
+
+ public void comment (char ch[], int start, int length) throws SAXException
+ {}
+ }
+}
+
+
diff --git a/src/de/superx/bin/SxXmlTester.java b/src/de/superx/bin/SxXmlTester.java
new file mode 100644
index 0000000..8f6f450
--- /dev/null
+++ b/src/de/superx/bin/SxXmlTester.java
@@ -0,0 +1,242 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Vector;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+import com.meterware.httpunit.GetMethodWebRequest;
+import com.meterware.httpunit.WebConversation;
+import com.meterware.httpunit.WebRequest;
+import com.meterware.httpunit.WebResponse;
+import com.meterware.httpunit.WebTable;
+
+import de.memtext.db.ConnectionCreator;
+import de.memtext.util.EqualsUtil;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+
+public class SxXmlTester {
+ Document document;
+ List webserverlist = new LinkedList();
+ List dbserverConnections = new LinkedList();
+ StringBuffer errors = new StringBuffer();
+
+ private void readdbServers() throws IOException, SQLException, ClassNotFoundException {
+ NodeList nl = document.getElementsByTagName("dbserver");
+
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node serverNode = (Node) nl.item(i);
+ Connection con=ConnectionCreator.getConnectionCryptPassword(XMLUtils.getAttribValue(serverNode, "db_properties"),
+ "driverName", "connectionURL", "connectionName",
+ "connectionPassword");
+ System.out.println("Found 1 db.properties node");
+ dbserverConnections.add(con);
+ }
+ }
+
+ private void readWebServers() {
+ NodeList nl = document.getElementsByTagName("webserver");
+
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node serverNode = (Node) nl.item(i);
+ webserverlist.add(XMLUtils.getAttribValue(serverNode, "url"));
+ System.out.println("Found 1 webserver node");
+ }
+ }
+
+ private void runDbTests() throws IOException, SQLException, ClassNotFoundException
+ {
+ readdbServers();
+ NodeList nl = document.getElementsByTagName("dbtest");
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node testNode = (Node) nl.item(i);
+
+ String name = XMLUtils.getAttribValue(testNode, "name");
+ System.out.println("Db-Testnr "+(i+1)+" :"+name);
+ String sql = XMLUtils.getAttribValue(testNode, "sql");
+ for (Iterator it = dbserverConnections.iterator(); it.hasNext();) {
+ Connection con= (Connection) it.next();
+ Statement stm=con.createStatement();
+ ResultSet rs=stm.executeQuery(sql);
+ Vector result=new Vector();
+ int colcount=0;
+ while (rs.next())
+ {
+ colcount=rs.getMetaData().getColumnCount();
+ Vector row=new Vector();
+ for (int col=1;col<=colcount;col++)
+ {
+ row.add(rs.getObject(col));
+ }
+ result.add(row);
+ }
+
+
+ for (Iterator it2 = XMLUtils.getChildNodeIterator(testNode); it2
+ .hasNext();) {
+ Node childNode = (Node) it2.next();
+ if (childNode.getNodeName().equals("valuetest")) {
+ String rowStr = XMLUtils.getAttribValue(childNode,
+ "row");
+ int row = Integer.parseInt(rowStr);
+ String colStr = XMLUtils.getAttribValue(childNode,
+ "col");
+ int col = Integer.parseInt(colStr);
+ String val = XMLUtils.getAttribValue(childNode, "val");
+
+ if (col>colcount)
+ {
+ errors.append("Test " + name
+ + " Versuch Spalte "+col+" zu lesen, Tabelle hat nur " + colcount+" Spalten\n" );
+ continue;
+ }
+ if (row>result.size())
+ {
+ errors.append("Test " + name
+ + " Versuch Zeile "+row+" zu lesen, ResultSet hat nur " + result.size()+" Zeilen\n" );
+ continue;
+ }
+ Vector arow=(Vector)result.get(row-1);
+ String gefunden = arow.get(col - 1).toString()
+ ;
+
+ if (!EqualsUtil.areEqual(val, gefunden)) {
+
+ errors.append("Test " + name
+ + " Falscher Wert Zeile " + row
+ + " Spalte " + col + " erwartet:" + val
+ + " gefunden:" + gefunden + "\n(sql:"+sql+"\n\n");
+ }
+ }
+ }
+
+ }
+ }
+ }
+ public void go(String args[]) throws SAXException, IOException, SQLException, ClassNotFoundException {
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ document = XMLUtils.buildDocument(new File(args[0]));
+ runDbTests();
+ runWebtests();
+ if (errors.length()>0)
+ {
+ System.out.println("Es sind Fehler aufgetaucht siehe output-errors.txt");
+ StringUtils.write(new File("output-errors.txt"),new Date()+"\n"+errors.toString());
+
+ }
+ else
+ {
+ System.out.println("Keine Fehler aufgefallen");
+ }
+ }
+
+
+ private void runWebtests() throws SAXException, IOException {
+ readWebServers();
+
+ NodeList nl = document.getElementsByTagName("webtest");
+ WebConversation wc = new WebConversation();
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node testNode = (Node) nl.item(i);
+
+ String name = XMLUtils.getAttribValue(testNode, "name");
+ System.out.println("Webserver-Testnr "+(i+1)+" :"+name);
+ String params = XMLUtils.getChildNodeValue(testNode, "params");
+ for (Iterator it = webserverlist.iterator(); it.hasNext();) {
+ String serverUrl = (String) it.next();
+ serverUrl += params;
+
+ WebRequest req = new GetMethodWebRequest(serverUrl);
+ WebResponse resp;
+ try {
+ resp = wc.getResponse(req);
+ } catch (IOException e) {
+ System.err.println("Aufruf fehlgeschlagen von "+serverUrl);
+ throw e;
+ }
+ StringUtils.write(new File("output_" + name
+ + ".htm"), resp.getText());
+ if (resp.getTables().length <2) {
+ errors.append("Test " + name
+ + " Keine Ergebnistabelle geliefert\n ");
+ continue;
+
+ }
+ for (Iterator it2 = XMLUtils.getChildNodeIterator(testNode); it2
+ .hasNext();) {
+ Node childNode = (Node) it2.next();
+ if (childNode.getNodeName().equals("valuetest")) {
+ String rowStr = XMLUtils.getAttribValue(childNode,
+ "row");
+ int row = Integer.parseInt(rowStr);
+ String colStr = XMLUtils.getAttribValue(childNode,
+ "col");
+ int col = Integer.parseInt(colStr);
+ String val = XMLUtils.getAttribValue(childNode, "val");
+ WebTable table = resp.getTables()[1];
+ if (col>table.getColumnCount())
+ {
+ StringUtils.write(new File("output_" + name
+ + ".htm"), resp.getText());
+ errors.append("Test " + name
+ + " Versuch Spalte "+col+" zu lesen, Tabelle hat nur " + table.getColumnCount()+" Spalten\n" );
+ continue;
+ }
+ if (row>table.getRowCount())
+ {
+ StringUtils.write(new File("output_" + name
+ + ".htm"), resp.getText());
+ errors.append("Test " + name
+ + " Versuch Zeile "+row+" zu lesen, Tabelle hat nur " + table.getRowCount()+" Zeilen\n" );
+ continue;
+ }
+
+ String gefunden = table.getTableCell(row - 1, col - 1)
+ .getText();
+
+ if (!EqualsUtil.areEqual(val, gefunden)) {
+
+ errors.append("Test " + name
+ + " Falscher Wert Zeile " + row
+ + " Spalte " + col + " erwartet:" + val
+ + " gefunden:" + gefunden + "\n(url:"+serverUrl+"\n\n");
+ }
+ }
+ }
+
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+
+ System.out.println("");
+ if (args.length != 1) {
+ System.err.println("usage SxXmlTester test.xml");
+ System.exit(-1);
+ }
+ try {
+ new SxXmlTester().go(args);
+ } catch (Exception e) {
+ System.out.println(e);
+ e.printStackTrace();
+
+ }
+ }
+ // junit.textui.TestRunner.run(AutoTest.class);
+}
+
+//Created on 27.04.2006 at 10:25:34
diff --git a/src/de/superx/bin/UnlFileConverter.java b/src/de/superx/bin/UnlFileConverter.java
new file mode 100644
index 0000000..77c3a36
--- /dev/null
+++ b/src/de/superx/bin/UnlFileConverter.java
@@ -0,0 +1,632 @@
+package de.superx.bin;
+/**
+ * Diese Klasse bereitet die Zeilen der angegebenen ASCII-Dateien für den Upload vor.
+ + "Gebrauch: java de.superx.bin.UnlFileConverter -logger: -IN: -OUT: -INDESCR: -OUTDESCR: -dbproperties: "
+ + "-table:."
+ * @version 0.1 4.7.2003
+ * @author Eugen Ermantraut, D. Quathamer*/
+
+/*
+ * Änderungen
+ *
+ * 26.8.04 MB XMLUtils.buildDocumentFromFile -> buildDocument
+ */
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import org.apache.commons.lang.StringUtils;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import de.memtext.util.ExceptionHandler;
+import de.memtext.util.GetOpts;
+import de.memtext.util.XMLUtils;
+public class UnlFileConverter {
+
+ /* Klassenvariablen */
+ private static String _dateiPfad = "";
+ private static String DELIMITER = "^";
+ private static String _outDateiPfad = "";
+ private static String _tabelle = "";
+ private static String _indescr = "";
+ private static String _outdescr = "";
+ private static String logfile = "../conf/logging.properties";
+ private static String dbpropfile = "";
+ private static String usage =
+ "-------------------------------------\n"
+ + "Gebrauch: java de.superx.bin.UnlFileConverter -logger: -IN: -OUT: -INDESCR: -OUTDESCR: -dbproperties: "
+ + "-table:."
+ + "\n---------------------------------------------------";
+ private static String indescr_name = "";
+ private static String indescr_dbsystem = "";
+ private static String indescr_app = "";
+ private static String indescr_cmd = "";
+ private static String in_rec_sep = "";
+ private static String in_line_sep = "";
+ private static String in_rec_header = "";
+ private static String in_rec_footer = "";
+ private static String in_header = "";
+ private static String in_header_delim = "";
+ private static boolean in_fixedwidth = false;
+ private static String in_escapemode = "";
+ private static String in_chmod = "";
+ private static String out_rec_sep = "";
+ private static String out_line_sep = "";
+ private static String out_rec_header = "";
+ private static String out_rec_footer = "";
+ private static String out_header = "";
+ private static String out_header_delim = "";
+ private static boolean out_fixedwidth = false;
+ private static String out_escapemode = "";
+ private static String out_chmod = "";
+ private static int plaintextcount = 0;
+
+ private static Document inDocument;
+ private static Document outDocument;
+ private static String plaintextTag = "plaintext";
+ private static String[] searchtext = new String[10];
+ private static String[] replacetext = new String[10];
+ private static final String newline = "{newline}";
+ private static final String tab = "{tab}";
+ Logger logger =
+ (Logger) Logger.getLogger(UnlFileConverter.class.toString());
+ private ExceptionHandler exceptionHandler = new ExceptionHandler(false);
+
+ public UnlFileConverter() {
+ }
+ public static void main(String[] args)
+ throws FileNotFoundException, IOException {
+ UnlFileConverter r = new UnlFileConverter();
+ GetOpts.setOpts(args);
+ String isdrin =
+ GetOpts.isAllRequiredOptionsPresent("-logger,-IN,-I_DESCR");
+ if (isdrin != null) {
+ System.err.println(
+ "Datei-Pfade werden als Parameter erwartet. Folgende Optionen fehlen: "
+ + isdrin);
+ r.zeige_hilfe();
+ System.exit(1);
+ }
+
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-logger"))
+ logfile = GetOpts.getValue("-logger");
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile = MyLogManager.getProperty(".level");
+ //logger.info("Using Loggging-Level " + logfile);
+ if (GetOpts.isPresent("-IN"))
+ _dateiPfad = GetOpts.getValue("-IN");
+ if (GetOpts.isPresent("-OUT"))
+ _outDateiPfad = GetOpts.getValue("-OUT");
+ if (GetOpts.isPresent("-I_DESCR"))
+ _indescr = GetOpts.getValue("-I_DESCR");
+ if (GetOpts.isPresent("-O_DESCR"))
+ _outdescr = GetOpts.getValue("-O_DESCR");
+ if (GetOpts.isPresent("-dbproperties"))
+ dbpropfile = GetOpts.getValue("-dbproperties");
+ if (GetOpts.isPresent("-table"))
+ if (dbpropfile.equals("")) {
+ System.err.println(
+ "Wenn auch die Ziel-Tabelle geprüft werden soll, dann muss dbproperties gesetzt sein.");
+ System.err.println(usage);
+ System.exit(1);
+ } else
+ _tabelle = GetOpts.getValue("-table");
+ if (args[0].toString().equals("?")
+ || args[0].toString().equals("/?")
+ || args[0].toString().equals("\\?")
+ || args[0].toString().toLowerCase().equals("-h")
+ || args[0].toString().toLowerCase().equals("--h")) {
+ r.zeige_hilfe();
+ System.exit(1);
+ }
+
+ init_descr();
+ try {
+ r.updateFile(_dateiPfad, _outDateiPfad);
+ System.out.println(
+ "Datei: "
+ + _dateiPfad
+ + " nach "
+ + _outDateiPfad
+ + " umgesetzt");
+ } catch (Exception e) {
+ System.err.println(e.toString());
+ }
+ //}
+
+ } // Ende der Methode
+
+ private void updateFile(String inDateiPfad, String outDateiPfad)
+ throws IOException, Exception {
+ File f = new File(inDateiPfad);
+ if (!f.exists()) {
+ throw new Exception("Datei nicht gefunden: " + inDateiPfad);
+ }
+ BufferedReader in;
+ BufferedWriter out;
+ //--- File-Instanz für temporäre Ergebnis-Datei anlegen ---//
+ File out_tmp;
+ if (inDateiPfad.equals(outDateiPfad))
+ out_tmp = new File(inDateiPfad + ".tmp2");
+ else
+ out_tmp = new File(outDateiPfad);
+ //--- IputStream und OutputStream generieren ---//
+ in = new BufferedReader(new InputStreamReader(new FileInputStream(f)));
+ //--- Output-Stream der temporären Datei erzeugen ---//
+ out =
+ new BufferedWriter(
+ new OutputStreamWriter(new FileOutputStream(out_tmp)));
+
+ //--- Verarbeiten der Datei ---//
+ String text;
+ String text2;
+ String tt;
+ /*char[] cbuf = new char[1024];
+ while(true)
+ {
+ int status = in.read(cbuf,0,1024);
+ if(status == -1)
+ break;
+ //text=cbuf.toString();
+ text=String.valueOf(cbuf);
+ if (text.startsWith(in_rec_header))
+ text = StringUtils.substringAfter(text, in_rec_header);
+ text = createRow(in, text + out_rec_header);
+ //in text steht ein Datensatz
+ text = StringUtils.chomp(text, in_rec_footer);
+ text += out_rec_footer;
+ text = replacePlainText(text);
+ checkTable(text); //Wenn Tabelle gecheckt werden sollte
+
+ out.write(text, 0, text.length());
+ out.write(out_rec_sep);
+ // muss NeuLine schreiben da die Zeile ohne eingelesen wird
+ out.flush();
+ }*/
+
+ text = in.readLine();
+ while (text != null) { //Datei nicht leer
+ if (text.startsWith(in_rec_header))
+ text = StringUtils.substringAfter(text, in_rec_header);
+ text = createRow(in, text + out_rec_header);
+ //in text steht ein Datensatz
+ text = StringUtils.chomp(text, in_rec_footer);
+ text += out_rec_footer;
+ text = replacePlainText(text);
+ checkTable(text); //Wenn Tabelle gecheckt werden sollte
+
+ out.write(text, 0, text.length());
+ out.write(out_rec_sep);
+ // muss NeuLine schreiben da die Zeile ohne eingelesen wird
+ out.flush();
+
+ text = in.readLine();
+
+ } //Ende der While-Schleife,alle records bearbeitet.
+
+ in.close();
+ out.close();
+ //--- Umbenennen Quell-Dateien ---//
+ /*String alt = inDateiPfad + ".in";
+ File altFile = new File(alt);
+ if (altFile.exists())
+ altFile.delete();
+
+ f.renameTo(altFile);*/
+
+ //--- Umformatierte temporäre Datei unter dem ursprünglichen Namen ablegen ---//
+ if (inDateiPfad.equals(outDateiPfad)) {
+ File neuFile = new File(outDateiPfad);
+ if (neuFile.isFile())
+ neuFile.delete();
+ if (!out_tmp.renameTo(neuFile))
+ logger.severe(
+ "Kann "
+ + outDateiPfad
+ + " nicht erzeugen! Existiert die Datei bereits? Die umgesetzte Datei befindet sich in "
+ + out_tmp.getPath()
+ + System.getProperty("file.separator")
+ + out_tmp.getName());
+ else
+ out_tmp.delete();
+ }
+
+ //--- Berechtigung für die neu angelegete Datei neu Vergeben ---//
+ if (!out_chmod.equals("")) {
+ if (!chmode(out_chmod, outDateiPfad)) {
+ logger.severe("Kann Berechtigung nicht ändern " + outDateiPfad);
+ }
+ }
+ //--- Schliessen der Streams und Löschen der temporären Datei ---//
+ in.close();
+ out.close();
+
+ }
+ private String createRow(BufferedReader in, String text)
+ throws IOException {
+ String tt;
+
+ try {
+ //System.out.println(text);
+ if (text.endsWith(in_line_sep) && !in_line_sep.equals("")) {
+ text = StringUtils.chomp(text, in_line_sep);
+ text += out_line_sep;
+ tt = in.readLine();
+ if (tt != null) {
+ text += StringUtils.chomp(tt, in_line_sep);
+ while (tt.endsWith(in_line_sep)) {
+ tt = in.readLine();
+ if (tt != null) {
+
+ text += out_line_sep
+ + StringUtils.chomp(tt, in_line_sep);
+ }
+ //(tt.substring(0,tt.length()));
+ }
+ }
+ } else
+ text = SxDBUtils.replaceString(text, in_line_sep, out_line_sep);
+ } catch (Exception e) {
+ logger.severe(
+ "Fehler beim Umsetzen: " + e.toString() + "\n" + text);
+ throw new IOException();
+ }
+ //Sonderzeichen in xil_proplist abfangen:
+ //text=SxDBUtils.replaceString(text,"\\000" , "\\\\000");
+ return text;
+ }
+ private void checkTable(String text) throws Exception {
+ if (!_tabelle.equals("") && !_tabelle.equals("null")) {
+ //Die Datei ist eine entladene Tabelle
+ //int start=_dateiPfad.indexOf("_",_dateiPfad.length()-4);
+ //if(start <0 )
+ // start=0;
+ // String tabname=_dateiPfad.substring(start,_dateiPfad.length()-4);
+ int numFelder = 0;
+ //System.out.println("Tabelle "+_tabelle+ " DELIM " + DELIMITER);
+ try {
+ numFelder = SxDBUtils.fieldCount(_tabelle);
+ //System.out.println("Felderanzahl:"+numFelder);
+ } catch (Exception e) {
+ System.err.println(
+ "Fehler beim Abfragen der Tabellen-Metadaten: "
+ + e.toString());
+ }
+ int k = 0;
+ int i = 0;
+ int p = 0;
+ do {
+ p = text.indexOf(DELIMITER, i);
+ if (p > 0) {
+ k++;
+ i = p + 1;
+ }
+
+ } while (p > 0);
+ if (k != numFelder) {
+ throw new Exception(
+ "unl-Datei entspricht nicht der Tabelle in der Datenbank;\nDie Tabelle hat "
+ + numFelder
+ + " Felder, die unl-Datei hat "
+ + k
+ + " Felder ");
+ }
+
+ }
+ } //Ende der Methode
+
+ private boolean chmode(String inBerechtigung, String inDat) {
+ String befehl = "chmod " + inBerechtigung + " " + inDat;
+ try {
+ Runtime r = Runtime.getRuntime();
+ Process p = r.exec(befehl);
+ int exitCode = p.waitFor();
+ } catch (Exception e) {
+ logger.severe("Error: " + e.toString());
+ return false;
+ }
+
+ return true;
+ } //Ende der Methode
+ private String replacePlainText(String inS) {
+ String outS = "";
+ for (int i = 0; i <= plaintextcount-1; i++) {
+ if ((searchtext[i].equals("") && replacetext[i].equals(""))
+ || (searchtext[i].equals(replacetext[i])))
+ outS = inS;
+ else
+ outS =
+ SxDBUtils.replaceString(inS, searchtext[i], replacetext[i]);
+ inS = outS;
+ }
+ return outS;
+ }
+
+ /**
+ * Liefert den Teilsstring von 0 bis zu letzten Delimiterzeichen(Exclusive)
+ * @param inS
+ * @return String
+ */
+ private String reorgString(String inS) throws Exception {
+ int ldPos = inS.lastIndexOf(DELIMITER);
+ //--- Wenn Delimiter-Zeichen nicht letztes Zeichen im String ist,
+ //--- muss die Verarbeitung abgebrochen werden---//
+
+ if ((ldPos + 1) < inS.length() || ldPos == -1)
+ //throw new Exception("Datei ist bereits umgesetzt!");
+ return inS;
+ else
+ return inS.substring(0, ldPos);
+
+ } //Ende der Methode
+
+ public boolean check_param_ok(String[] inTab) { //--- Anzahl der übergebenen Parameter prüfen ---//
+ //System.out.println(inTab.length);
+ if (inTab.length < 2) {
+ System.out.println(
+ "Mindestens 2 Parameter erwartet! Mit -h oder ? rufen sie Hilfe auf.");
+ return false;
+ }
+ //--- Dateinpfad übernehmen ---//
+ _dateiPfad = inTab[0].trim();
+ _outDateiPfad = inTab[1].trim();
+
+ if (inTab.length >= 3)
+ DELIMITER = inTab[2].trim();
+ //---Wenn Delimiter-Zeichen übergeben wurde dann übernehmen ---//
+ if (inTab.length > 3)
+ _tabelle = inTab[3].toString().trim();
+
+ return true;
+ } //Ende der Methode
+
+ /**
+ * Prüfen der Datei auf Vorhandensein und Leseberechrigung
+ * @param inFile
+ */
+ private boolean check_Directory(File inFile) {
+ if (inFile.exists()) {
+ if (!inFile.isDirectory()) {
+ System.out.println(inFile + " ist kein Verzeichnis!");
+ return false;
+ }
+ } else {
+ System.out.println(inFile + " Verzeichniss nicht gefunden!");
+ return false;
+ }
+
+ return true;
+ } //Ende der Methode
+
+ private void progEnde() {
+ System.runFinalization();
+ System.exit(0);
+ } //Ende der Methode
+
+ private static void init_descr() {
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+ inDocument = XMLUtils.buildDocument(new File(_indescr), false);
+ NodeList myInNodes = inDocument.getElementsByTagName(plaintextTag);
+ outDocument = XMLUtils.buildDocument(new File(_outdescr), false);
+ NodeList myOutNodes = outDocument.getElementsByTagName(plaintextTag);
+ int i = 0;
+ for (i = 0; i < myInNodes.getLength(); i++) {
+ Node myInNode = myInNodes.item(i);
+ if (myInNode.getNodeType() == Node.TEXT_NODE)
+ continue;
+ String plaintexttype = XMLUtils.getAttribValue(myInNode, "type");
+ try {
+ searchtext[i] = XMLUtils.getTheValue(myInNode);
+ } catch (IllegalArgumentException e) {
+ searchtext[i] = "";
+ }
+ searchtext[i]=SxDBUtils.replaceString(searchtext[i], tab, "\t");
+ searchtext[i]=SxDBUtils.replaceString(searchtext[i], newline, "\n");
+
+ /*if (searchtext[i].equals(tab))
+ searchtext[i] = "\t";
+ if (searchtext[i].equals(newline))
+ searchtext[i] = "\n";*/
+ for (int k = 0; k < myOutNodes.getLength(); k++) {
+ Node myOutNode = myOutNodes.item(k);
+ if (XMLUtils
+ .getAttribValue(myOutNode, "type")
+ .equals(plaintexttype)) {
+
+ try {
+ replacetext[i] = XMLUtils.getTheValue(myOutNode);
+ } catch (IllegalArgumentException e) {
+ replacetext[i] = "";
+ }
+ replacetext[i]=SxDBUtils.replaceString(replacetext[i], tab, "\t");
+ replacetext[i]=SxDBUtils.replaceString(replacetext[i], newline, "\n");
+ /*if (replacetext[i].equals(tab))
+ replacetext[i] = "\t";
+
+ if (replacetext[i].equals(newline))
+ replacetext[i] = "\n";*/
+ }
+ }
+
+ }
+ plaintextcount = i;
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "record-separator");
+ in_rec_sep = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_rec_sep = newline;
+ }
+ if (in_rec_sep.endsWith(newline))
+ in_rec_sep = StringUtils.chomp(in_rec_sep, newline);
+
+ try {
+ Node myNode =
+ XMLUtils.getFirstNode(outDocument, "record-separator");
+ out_rec_sep = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_rec_sep = newline;
+ }
+
+ if (out_rec_sep.endsWith(newline))
+ out_rec_sep = StringUtils.chomp(out_rec_sep, newline) + "\n";
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "line-separator");
+ in_line_sep = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_line_sep = newline;
+ }
+
+ if (in_line_sep.endsWith(newline))
+ in_line_sep = StringUtils.chomp(in_line_sep, newline)+"\n";
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "line-separator");
+ out_line_sep = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_line_sep = newline;
+ }
+ if (out_line_sep.endsWith(newline))
+ out_line_sep = StringUtils.chomp(out_line_sep, newline) + "\n";
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "record-header");
+ in_rec_header = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_rec_header = "";
+ }
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "record-header");
+ out_rec_header = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_rec_header = "";
+ }
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "record-footer");
+ in_rec_footer = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_rec_footer = "";
+ }
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "record-footer");
+ out_rec_footer = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_rec_footer = "";
+ }
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "header");
+ in_header = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_header = "";
+ }
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "header");
+ out_header = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_header = "";
+ }
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "header-delim");
+ in_header_delim = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_header_delim = "^";
+ }
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "header-delim");
+ out_header_delim = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_header_delim = "^";
+ }
+ String s = "";
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "fixedwidth");
+ s = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ s = "";
+ }
+ if (s.equalsIgnoreCase("true") || s.equalsIgnoreCase("yes"))
+ in_fixedwidth = true;
+ else
+ in_fixedwidth = false;
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "fixedwidth");
+ s = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ s = "";
+ }
+
+ if (s.equalsIgnoreCase("true") || s.equalsIgnoreCase("yes"))
+ out_fixedwidth = true;
+ else
+ out_fixedwidth = false;
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "escapemode");
+ in_escapemode = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_escapemode = "";
+ }
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(inDocument, "chmod");
+ in_chmod = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ in_chmod = "";
+ }
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "escapemode");
+ out_escapemode = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_escapemode = "";
+ }
+
+ try {
+ Node myNode = XMLUtils.getFirstNode(outDocument, "chmod");
+ out_chmod = XMLUtils.getTheValue(myNode);
+ } catch (IllegalArgumentException e) {
+ out_chmod = "";
+ }
+
+ }
+ private void zeige_hilfe() {
+ System.out.println(
+ "\n Diese Klasse bereinigt die Zeilen der angegebenen ASCII-Dateien.");
+ System.out.println(
+ " Es wird der letzte Delimeter-Zeichen aus jeder Zeile entfernt.");
+ System.out.println("\n Parameter: ");
+ System.out.println("1. Eingabe-Dateiname mit Pfadangabe ");
+ System.out.println("2. Ausgabe-Dateiname mit Pfadangabe");
+ System.out.println("3. Delimiter-Zeichen(optional)");
+ System.out.println(
+ "4. Tabellenname in der Datenbank, der auf Übereistimmung der Felderanzahl geprüft werden soll (optional, wenn keine Überprüfung, dann 'none').");
+ //System.out.println(" Wenn in einer Zeile Zeichen hinter dem letzten Delimiter-Zeichen ");
+ //System.out.println(" wird die Bearbeitung abgebrochen, da es anzunehmen ist daß diese Datei");
+ //System.out.println(" bereits umgesetzt ist!");
+ System.out.println(" Defaultwert fuer Delimiter ist ^. \n");
+ } // Ende der Methode
+
+} //Ende der Klasse
\ No newline at end of file
diff --git a/src/de/superx/bin/UnloadSqlFromXml.java b/src/de/superx/bin/UnloadSqlFromXml.java
new file mode 100644
index 0000000..abde335
--- /dev/null
+++ b/src/de/superx/bin/UnloadSqlFromXml.java
@@ -0,0 +1,154 @@
+
+package de.superx.bin;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import de.memtext.util.ExceptionHandler;
+import de.memtext.util.GetOpts;
+import de.memtext.util.XMLUtils;
+/**
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * UnloadFromXml.java
+ * @
+
+ */
+
+/*
+ * Änderungen
+ *
+ * 26.8.04 MB XMLUtils.buildDocumentFromFile -> buildDocument
+ */
+
+public class UnloadSqlFromXml {
+ String delim = "^";
+ String header = "false";
+ String logfile = "../conf/logging.properties";
+ String tabelle = "";
+ String dbpropfile = "../conf/db.properties";
+ String myElement = "table";
+ String mySqlAttrib = "script";
+ String myOutfileAttrib = "unl";
+ String outformat="txt";
+ String outfile="";
+ private static Document document;
+ //LogUtils logger=null;
+ public Logger logger = (Logger) Logger.getLogger(SxExtractor.class.toString());
+ //static Logger logger = Logger.getLogger(dosql.class);
+ private ExceptionHandler exceptionHandler = new ExceptionHandler(false);
+ private static String usage="-------------------------------------\n"
+ +"Gebrauch: java de.superx.bin.UnloadTableFromXml -logger=<> -dbproperties=<> "
+ +"-xml: -element: -attribute: -outFormat:(optional) "
+ +" -delim: -header:(optional) -outfile:(optional) \n---------------------------------------------------";
+
+ public UnloadSqlFromXml(String args[]) throws IOException {
+ String sql="";
+ String unl="";
+ String _dateiPfad = "";
+ GetOpts.setOpts(args);
+ String isdrin= GetOpts.isAllRequiredOptionsPresent("-logger,-dbproperties,-xml,-element,-sqlattribute,-outfileattribute");
+ if(isdrin != null)
+ {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-logger"))
+ logfile=GetOpts.getValue("-logger" );
+ if (GetOpts.isPresent("-dbproperties"))
+ dbpropfile=GetOpts.getValue("-dbproperties" );
+ if (GetOpts.isPresent("-xml"))
+ _dateiPfad=GetOpts.getValue("-xml" );
+ if (GetOpts.isPresent("-element"))
+ myElement=GetOpts.getValue("-element" );
+ if (GetOpts.isPresent("-sqlattribute"))
+ mySqlAttrib=GetOpts.getValue("-sqlattribute" );
+ if (GetOpts.isPresent("-outfileattribute"))
+ myOutfileAttrib=GetOpts.getValue("-outfileattribute" );
+
+ if (GetOpts.isPresent("-outFormat"))
+ outformat=GetOpts.getValue("-outFormat" );
+ if (GetOpts.isPresent("-delim"))
+ delim=GetOpts.getValue("-delim" );
+ if (GetOpts.isPresent("-header"))
+ header=GetOpts.getValue("-header" );
+ if (args.length > 0) {
+ logfile = args[0].trim();
+ } else {
+ System.err.println(
+ "Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, Pfad zur SQL-Datei) erfoderlich");
+ System.exit(1);
+ }
+ //logger.initRaw(dosql.class)
+ //PropertyConfigurator.configure(logfile);
+ File f = new File(logfile);
+ if (!f.exists()) {
+ throw new IOException("Datei nicht gefunden: " + logfile);
+ }
+ FileInputStream ins = new FileInputStream(logfile);
+ LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
+ MyLogManager.readConfiguration(ins);
+ logfile = MyLogManager.getProperty(".level");
+ logger.info("Using Loggging-Level " + logfile);
+
+
+
+ //XMLUtils myUtils=new XMLUtils();
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+
+ document = XMLUtils.buildDocument(new File(_dateiPfad), false);
+ NodeList myNodes = document.getElementsByTagName(myElement);
+
+ for (int i = 0; i < myNodes.getLength(); i++) {
+ Node myNode = myNodes.item(i);
+ if (myNode.getNodeType() == Node.TEXT_NODE)
+ continue;
+ sql = XMLUtils.getAttribValue(myNode, mySqlAttrib);
+ unl = XMLUtils.getAttribValue(myNode, myOutfileAttrib);
+ if(!sql.equals("") && !unl.equals(""))
+ {
+ String[] myArgs= new String[10];
+ myArgs[0]=args[0].trim(); //logfile
+ myArgs[1]=args[1].trim(); //db.properties
+
+ myArgs[2]=sql;
+ myArgs[3]=outformat; //outformat
+ myArgs[4]=delim; //_delim
+ myArgs[5]=header; //header
+ myArgs[6]=unl;
+
+
+ try {
+ de.superx.bin.Dosql.execute(myArgs);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ System.out.println(sql);
+ }
+ }
+ }
+
+ public static void main(String args[]) {
+ try {
+ UnloadSqlFromXml test = new UnloadSqlFromXml(args);
+ } catch (Exception ex) {
+ System.err.println("Exception caught.\n" + ex);
+ ex.printStackTrace();
+ }
+ }
+ private void severeEnd(String txt) {
+ logger.severe(txt);
+ System.exit(-1);
+ }
+ }
+
diff --git a/src/de/superx/bin/Upgrade.java b/src/de/superx/bin/Upgrade.java
new file mode 100644
index 0000000..aaaf4fa
--- /dev/null
+++ b/src/de/superx/bin/Upgrade.java
@@ -0,0 +1,58 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.StringTokenizer;
+
+/**
+ * Kopie in de.his.edustore.modules.
+ * @author superx
+ *
+ */
+public class Upgrade {
+
+ /**
+ * @param args Datei obsoletfiles.txt mit zu löschenden Dateien
+ * eine Datei obsoletfiles.txt in superx/WEB-INF/conf anlegen.
+~Darin immer eine Zeile pro alter Jar ausgehend von Verzeichnis tomcat/webapps/superx, also z.B.
+WEB-INF/lib/poixxx.jar
+ * @throws IOException
+ */
+ public static void main(String[] args) throws IOException {
+ if (args.length == 0) {
+ System.out
+ .println("Aufruf java -cp superx4.1.jar de.superx.bin.Upgrade /path/to/superx/WEB-INF/conf/obsoletfiles.txt");
+ System.out.println("In der Datei können zu löschende Dateien ausgehend von tomcat/webapps/superx angegeben werden, z.B. WEB-INF/lib/poi2.5.jar (keine * moeglich)");
+
+ } else {
+ deleteObsoleteFiles(args[0]);
+ }
+ }
+
+ /**
+ * auch in WebFrontendForModuleInstall enthalten
+ * gut wäre verlagerung nach hosu
+ * @param filename
+ * @throws IOException
+ */
+ private static void deleteObsoleteFiles(String filename) throws IOException {
+ File f = new File(filename);
+ String pfad=f.getParentFile().getParentFile().getParentFile().getAbsolutePath();
+ if (f.exists()) {
+ String obfiles = de.memtext.util.StringUtils.readFile(f);
+ StringTokenizer st = new StringTokenizer(obfiles, "\n");
+ while (st.hasMoreTokens()) {
+
+ String afilename = st.nextToken();
+ if (afilename.startsWith("#")) continue;
+ File fi = new File(pfad+File.separator+afilename.trim());
+ if (fi.exists())
+ { fi.delete();
+ System.out.println(fi+" deleted");
+ }
+ }
+
+ }
+ }
+}
+// created at 16.8.2011
\ No newline at end of file
diff --git a/src/de/superx/bin/UploadRecords.java b/src/de/superx/bin/UploadRecords.java
new file mode 100644
index 0000000..3d03750
--- /dev/null
+++ b/src/de/superx/bin/UploadRecords.java
@@ -0,0 +1,85 @@
+package de.superx.bin;
+import de.superx.common.FileToTableUploader;
+import de.memtext.util.GetOpts;
+
+/*
+ * @author Daniel Quathamer Projektgruppe SuperX
+ * upload_records.java
+* Dieses Javaprogramm lädt Inhalte einer Datei in eine Tabelle hoch")
+* DQ 5.1.2006 Upload vom XML-Dateien möglich
+ *
+ */
+
+public class UploadRecords {
+ private static String usage =
+ "-------------------------------------\n"
+ + "Gebrauch: java de.superx.bin.UploadRecords \n-dbproperties: \n"
+ + "-table: \n-unl:(optional, default ist Tabellenname.unl) \n-delim:(optional, default ist ^) \n-header:(optional, mit Feldüberschriften, default ist false)\n"
+ + "-mode:(optional, default is stop) #Bei Fehlerhaften Daten kann das Hochladen gestoppt werden, oder der Datensatz wird übersprungen"
+ + "\n-inserts:(optional, default is false) #Bei -inserts:simple und batch werden Die Rohdaten in Insert-sql-Statements übersetzt (nur für Debugging-Zwecke, sehr langsam. Der Modus exclude-field ist darüberhinaus nicht anwendbar)"
+ + "\n-encoding:"
+ + "\n---------------------------------------------------";
+
+ public static void main(String args[]) {
+ try {
+ GetOpts.setOpts(args);
+ String isdrin =
+ GetOpts.isAllRequiredOptionsPresent("-dbproperties,-table,-unl");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ System.err.println(usage);
+ System.exit(1);
+ }
+ FileToTableUploader myUploader=new FileToTableUploader();
+ //GetOpts myOpts=new GetOpts();
+ if (GetOpts.isPresent("-dbproperties"))
+ myUploader.setDbpropfile(GetOpts.getValue("-dbproperties"));
+ if (GetOpts.isPresent("-informat"))
+ myUploader.setInFormat(GetOpts.getValue("-informat"));
+ if (GetOpts.isPresent("-table"))
+ myUploader.setTargetTable( GetOpts.getValue("-table"));
+
+ if (GetOpts.isPresent("-unl"))
+ myUploader.setSrcFile(GetOpts.getValue("-unl"));
+ else
+ myUploader.setSrcFile(myUploader.getTargetTable() + ".unl");
+ if (GetOpts.isPresent("-header"))
+ myUploader.setHeader(GetOpts.getValue("-header").equalsIgnoreCase("true")?true:false);
+ if (GetOpts.isPresent("-delim"))
+ myUploader.setDelim(GetOpts.getValue("-delim"));
+ if (GetOpts.isPresent("-encoding"))
+ {
+ String encodingParam=GetOpts.getValue("-encoding");
+
+ if(encodingParam != null && !encodingParam.equals("") )
+ myUploader.setEncoding(encodingParam);
+ }
+ else
+ myUploader.setEncoding(System.getProperty("file.encoding"));
+ if (GetOpts.isPresent("-mode")) {
+ myUploader.setMode(GetOpts.getValue("-mode").toLowerCase());
+
+ }
+ if (GetOpts.isPresent("-inserts"))
+ myUploader.setInserts(GetOpts.getValue("-inserts"));
+ long jetzt = new java.util.Date().getTime() ;
+ myUploader.setUploadConnection(myUploader.getConnection(null,myUploader.getDbpropfile()));
+ String protokoll=myUploader.uploadFile();
+ long erstrecht = new java.util.Date().getTime() ;
+ System.out.println(myUploader.numberOfRows+" lines loaded");
+ System.out.println("File "+myUploader.getSrcFile() +" uploaded");
+ if(protokoll.equals(""))
+ protokoll= " in "+(erstrecht-jetzt)/1000 +" Sec.";
+ System.out.println(protokoll);
+
+} catch (Exception ex) {
+ System.err.println("Upload fehlgeschlagen: " + ex);
+ System.exit(1);
+}
+}
+ }
+
+
+
+
+
diff --git a/src/de/superx/bin/WebserviceChecker.java b/src/de/superx/bin/WebserviceChecker.java
new file mode 100644
index 0000000..deef4f5
--- /dev/null
+++ b/src/de/superx/bin/WebserviceChecker.java
@@ -0,0 +1,97 @@
+package de.superx.bin;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.nio.charset.Charset;
+
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.SOAPConnection;
+import javax.xml.soap.SOAPConnectionFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+public class WebserviceChecker extends AbstractWebserviceClient {
+ public static String[] args;
+ public void run()
+ {
+ try {
+ // Create SOAP Connection
+ SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory
+ .newInstance();
+ SOAPConnection soapConnection = soapConnectionFactory
+ .createConnection();
+
+ // Send SOAP Message to SOAP Server
+ String url = readFile(new File(args[1]));
+
+ SOAPMessage sr = getSoapMessageFromString(readFile(new File(args[0])));
+ sr.getMimeHeaders().addHeader("SOAPAction",
+ "http://sap.com/xi/WebService/soap1.1");
+
+ SOAPMessage soapResponse = soapConnection.call(sr, url);
+
+
+ Transformer transformer = TransformerFactory.newInstance()
+ .newTransformer();
+ // optional indenting
+ transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+ transformer.setOutputProperty(
+ "{http://xml.apache.org/xslt}indent-amount", "2");
+
+ transformer.transform(new DOMSource(soapResponse.getSOAPPart()),
+ new StreamResult(new File(args[2])));
+
+
+
+ soapConnection.close();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ public static void main(String a[])
+ {
+ args=a;
+ if (args.length != 3) {
+ System.out
+ .println("Usage path/to/envelope.xml path/to/urlfile /path/to/ouputfile.xml");
+ System.exit(-1);
+ }
+ WebserviceChecker wc=new WebserviceChecker();
+ wc.run();
+
+ }
+
+ private static SOAPMessage getSoapMessageFromString(String xml)
+ throws SOAPException, IOException {
+ MessageFactory factory = MessageFactory.newInstance();
+ SOAPMessage message = factory
+ .createMessage(
+ new MimeHeaders(),
+ new ByteArrayInputStream(xml.getBytes(Charset
+ .forName("UTF-8"))));
+ return message;
+ }
+ private static String readFile(File f) throws IOException {
+ FileReader fr = new FileReader(f);
+ BufferedReader bfr = new BufferedReader(fr);
+ String line;
+ StringBuffer result = new StringBuffer();
+ while ((line = bfr.readLine()) != null) {
+ result.append(line + "\n");
+
+ }
+ bfr.close();
+ fr.close();
+ return result.toString();
+ }
+}
diff --git a/src/de/superx/bin/WebserviceClient.java b/src/de/superx/bin/WebserviceClient.java
new file mode 100644
index 0000000..a75fd60
--- /dev/null
+++ b/src/de/superx/bin/WebserviceClient.java
@@ -0,0 +1,399 @@
+package de.superx.bin;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.util.LogUtils;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+
+public class WebserviceClient extends AbstractWebserviceClient{
+
+ private boolean isDebug = false;
+ private boolean isDBConnectionPossible = true;
+
+ private Document document;
+ private Set newOrUpdatedObjects = new HashSet();
+ private Set deletedObjects = new HashSet();
+ private String dbpropfile;
+ private String objectClass, hsnr;
+ private String changesURL, changesSOAP;
+ private String xmlConfig;
+ private String detailURL;
+ private String detailSOAP, replaceNodeName;
+ private String xsl, outfile;
+ private String stammdatenstart=null;
+ private boolean isDeleteTmpXmlFileWanted = true;
+
+ private static final Logger log = Logger.getLogger("wc");
+
+ private static final String FISTL_HIERARCHIE_INFO = " \n" +
+ " - \n" +
+ " \n" +
+ " \n" +
+ " 000 \n" +
+ " \n" +
+ " \n" +
+ " \n" +
+ " \n" +
+ " \n" +
+ " 0001 \n" +
+ "
\n" +
+ " ";
+
+
+ public static void main(String args[]) {
+ System.out.println("SuperX-WebserviceClient Version 0.9.8");
+ WebserviceClient tc = new WebserviceClient();
+ tc.run(args);
+
+ }
+ public WebserviceClient()
+ {
+
+
+
+ }
+
+ public void run(String args[]) {
+ try {
+
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+ // LogUtils.initRaw(log);
+ LogUtils.initRawFileDateTime("wc", "WebserviceClient.log", 100000,
+ 1, true, false);
+
+ log.setLevel(Level.FINEST);
+ log.getHandlers()[0].setLevel(Level.FINEST);
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-dbproperties,-xmlconfig,-xsl,-hsnr,-out");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ // System.err.println(usage);
+ System.exit(1);
+ }
+ readConfig();
+
+ readChanges();
+
+ if (isReplyOk()) {
+ readObjectIdSets();
+ if (isDBConnectionPossible)
+ toDeletedObjectsTable();
+ writeChangeXml();
+
+ } else {
+ String msg = "Error: Aufruf von Webservice für " + xmlConfig
+ + " fehlgeschlagen";
+ System.out.println(msg);
+ log.severe(msg);
+ LogUtils.close("wc");
+ System.exit(-1);
+ }
+ } catch (Exception e) {
+ log.severe(e.getMessage());
+ System.out.println("Error " + e.getMessage());
+ e.printStackTrace();
+ LogUtils.close("wc");
+ System.exit(1);
+ } finally {
+ LogUtils.close("wc");
+ }
+ }
+
+ private void readChanges() throws Exception {
+ String soapString = StringUtils.replace(changesSOAP,
+ "XXOBJECT_CLASSXX", objectClass);
+ String startDatum = getStartDatum();
+ log.log(Level.INFO, "Startdatum " + startDatum);
+ System.out.println("Startdatum " + startDatum);
+ soapString = StringUtils.replace(soapString, "XXSTARTDATEXX",
+ startDatum);
+ soapString = StringUtils.replace(soapString, "XXTODAYXX",
+ new java.sql.Date(new java.util.Date().getTime()).toString());
+
+ log.fine("SOAP Aufruf:\n" + soapString);
+
+ String result= readSOAP(soapString, changesURL).toString();
+ document = XMLUtils.buildDocumentFromString(result, false);
+ log.finest("Geaenderte Objekte Klasse " + objectClass);
+ // log.finest(sw.toString());
+ // log.finest(
+ // "-----------------------------------------");
+
+ }
+
+ private void readConfig() {
+ dbpropfile = GetOpts.getValue("-dbproperties");
+
+ xmlConfig = GetOpts.getValue("-xmlconfig");
+ outfile = GetOpts.getValue("-out");
+ xsl = GetOpts.getValue("-xsl");
+ hsnr = GetOpts.getValue("-hsnr");
+ System.out.println("\n" + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString() + "\nHochschulnummer " + hsnr);
+ log.info("\nHochschulnummer " + hsnr);
+ if (GetOpts.isPresent("-nodelete"))
+ isDeleteTmpXmlFileWanted = false;
+ if (GetOpts.isPresent("-pause")) {
+ String p = GetOpts.getValue("-pause");
+ pause = Integer.parseInt(p);
+ System.out.println("Pause between soap calls " + pause);
+ }
+ log.log(Level.INFO, "Verarbeite " + xmlConfig);
+ System.out.println("Verarbeite " + xmlConfig);
+ Document dconf = XMLUtils.buildDocument(new File(xmlConfig));
+
+ Node n = XMLUtils.getFirstNode(dconf, "webservice");
+ objectClass = XMLUtils.getAttribValue(n, "object_class");
+
+ n = XMLUtils.getFirstNode(dconf, "changesurl");
+ changesURL = XMLUtils.getTheValue(n);
+ changesURL=adaptURL(changesURL);
+ n = XMLUtils.getFirstNode(dconf, "changessoap");
+ changesSOAP = XMLUtils.getTheValue(n);
+ changesSOAP = StringUtils.replace(changesSOAP, "XXOBJECTICLASSXX",
+ objectClass);
+
+ n = XMLUtils.getFirstNode(dconf, "detailurl");
+ detailURL = XMLUtils.getTheValue(n);
+ detailURL=adaptURL(detailURL);
+ n = XMLUtils.getFirstNode(dconf, "detailsoap");
+ detailSOAP = XMLUtils.getTheValue(n);
+ n = XMLUtils.getFirstNode(dconf, "replacenode");
+ replaceNodeName = XMLUtils.getAttribValue(n, "from");
+
+
+
+ }
+
+
+ private void readObjectIdSets() {
+ Node changehead = XMLUtils.getFirstNode(document, "CHANGEHEAD");
+ Iterator it = (Iterator) XMLUtils.getChildNodeIterator(changehead);
+ int i = 1;
+ while (it.hasNext()) {
+ Node item = (Node) it.next();
+ String objectid = XMLUtils.getChildNodeValue(item, "OBJECTID");
+ String change_ind = XMLUtils.getChildNodeValue(item, "CHANGE_IND");
+ if (change_ind != null && change_ind.equals("D"))
+ deletedObjects.add(objectid);
+ else
+ newOrUpdatedObjects.add(objectid);
+ i++;
+
+ }
+ System.out.println("Zu loeschen " + deletedObjects.size()
+ + " neu/geaendert " + newOrUpdatedObjects.size());
+ log.info("Anzahl zu loeschender Objekte " + deletedObjects.size());
+ log.info("Anzahl zu neuer/geaenderter Objekte "
+ + newOrUpdatedObjects.size());
+ }
+
+ private void writeChangeXml() throws Exception {
+ File f = File.createTempFile("webservicedata", ".xml");
+ // File f=new File("tmpwebservice.xml");
+ if (!isDeleteTmpXmlFileWanted) {
+ System.out.println("Temp Datei: " + f.getAbsolutePath());
+ log.info("Temp Datei: " + f.getAbsolutePath());
+ }
+ if (f.exists())
+ f.delete();
+ // FileWriter fw = new FileWriter(f);
+ PrintWriter fw = new PrintWriter(f, "UTF-8");
+ // FileOutputStream fos = new FileOutputStream(f, false);
+ // BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(fos));
+
+ BufferedWriter bfw = new BufferedWriter(fw);
+ bfw.write("\n");
+
+ int i = 0;
+ int rownr=1;
+ System.out.println(DateUtils.getTodayString() + " "
+ + DateUtils.getNowString());
+ for (Iterator it = newOrUpdatedObjects.iterator(); it.hasNext();) {
+ String objectId = it.next();
+
+ // Hier wird Detailrequest aufgerufen
+ String reply = getSoapDetailRequest(objectId, i);
+ i++;
+ if (i % 10 == 0)
+ System.out.print(i + " ");
+ //bei nicht vollstaendig angelegten Kostenarten ueberspringen
+ if (objectClass.equals("KSTAR")&&reply.indexOf("")>-1)
+ continue;
+ if (reply.indexOf("Es wurden 0000 S")>-1)
+ continue;
+ //bei Finanzstellen ggfs. fehlende Hierarchieinformation durch Dummy ersetzen
+ if (objectClass.equals("FMFCTR"))
+ reply=patchMissingFistlHierarchieInfo(reply);
+
+ reply = purge(reply);
+ reply=StringUtils.replace(reply, "I") == -1) {
+ System.out.println("Fehler bei Lesen von Object " + objectId);
+ System.out.println(reply);
+ bfw.close();
+ fw.close();
+ if (f.exists())
+ f.delete();
+ System.exit(-1);
+ }
+
+ bfw.write(reply.replaceAll(
+ "<\\?xml version=\"1.0\" encoding=\".*>", ""));
+ // System.out.println(objectId + " xxx" + reply);
+
+ // if (i > 20) break;
+ }
+ System.out.println("");
+ bfw.write("\n\n");
+ bfw.close();
+ fw.close();
+
+ SxTransformer sxTrans = new SxTransformer(log, outfile);
+ sxTrans.quellstring = f.getAbsolutePath();
+ sxTrans.stylesheet = xsl;
+ sxTrans.params = "ignoreElements=EX_JEST";
+ sxTrans.transformFile("text");
+ if (isDeleteTmpXmlFileWanted)
+ f.delete();
+
+ System.out.println(" fertig: " + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString());
+ }
+
+ private String patchMissingFistlHierarchieInfo(String input) {
+ String output=StringUtils.replace(input, "", FISTL_HIERARCHIE_INFO);
+ return output;
+ }
+ private String getStartDatum() throws Exception {
+ String result = "2000-01-01";
+
+ if (isDBConnectionPossible) {
+ SxConnection myConnection = new SxConnection();
+ myConnection.setPropfile(dbpropfile);
+ Connection con = myConnection.getConnection();
+ Statement stm = con.createStatement();
+
+ ResultSet rs = stm
+ .executeQuery("select datum from systeminfo where tid=170");
+ while (rs.next()) {
+ Object o = rs.getDate(1);
+ if (o != null)
+ result = o.toString();
+ }
+ rs.close();
+ stm.close();
+ con.close();
+
+ }
+ if (System.getProperty("stammdatenstart")!=null)
+ result=System.getProperty("stammdatenstart");
+ return result;
+ }
+
+ /**
+ * to gxstage_delete_object Table
+ *
+ * @throws Exception
+ *
+ */
+ private void toDeletedObjectsTable() throws Exception {
+ SxConnection myConnection = new SxConnection();
+ myConnection.setPropfile(dbpropfile);
+ Connection con = myConnection.getConnection();
+ PreparedStatement pst = con
+ .prepareStatement("insert into gxstage_delete_object (object_class,object_id) values (?,?)");
+
+ for (Iterator it = deletedObjects.iterator(); it.hasNext();) {
+ String objectId = it.next();
+ pst.clearParameters();
+ pst.setString(1, objectClass);
+ pst.setString(2, objectId);
+ pst.execute();
+ }
+ pst.close();
+ con.close();
+
+ }
+
+ private String getSoapDetailRequest(String objectid, int i)
+ throws Exception {
+
+ String id = objectid.substring(4);
+ //zum Testen einzelner KSTAR if (!id.equals("0000906510")) return "I";
+ // if (id.startsWith("0"))
+ // id = id.substring(1);
+ String id3 = "";
+ if (objectid.length() > 8)
+ id3 = objectid.substring(8);
+ String soapxml = de.memtext.util.StringUtils.replace(detailSOAP,
+ "IDPART1", objectid.substring(0, 4));
+ soapxml = de.memtext.util.StringUtils.replace(soapxml, "IDPART2", id);
+ soapxml = de.memtext.util.StringUtils.replace(soapxml, "IDPART3", id3);
+ soapxml = de.memtext.util.StringUtils.replace(soapxml, "XXOBJECTIDXX",
+ objectid);
+ soapxml = de.memtext.util.StringUtils
+ .replace(soapxml, "XXHSNRXX", hsnr);
+
+ // System.out.println("looking for "+objectid.substring(0,4)+" "+id);
+ /*
+ * soapxml =
+ * " \n"
+ * + " \n" + " \n" +
+ * " \n" + " " +
+ * objectid.substring(0, 4) + " \n" + " " +
+ * id + " \n" + " \n" +
+ * " \n" + " \n" +
+ * "";
+ */
+ // String url =
+ // "https://kpi-nsi.landbw.de/sap/xi/engine?type=entry&version=3.0&Sender.Service=WsHAWCcGetDetailSyn&Interface=http%3A%2F%2Fnsi-cc.bwl.de%2Fhaw%2Fco%5EMiCcGetDetailSynOut";
+
+ if (i == 0)
+ log.finest("1. SOAP Detailaufruf:\n" + soapxml);
+
+ String res = readSOAP(soapxml, detailURL).toString();
+
+ // Document doc=XMLUtils.buildDocumentFromString(sw.toString(), false);
+ String result = StringUtils.replace(res, replaceNodeName,
+ "response");
+
+ return result;
+ }
+
+ private boolean isReplyOk() {
+ boolean result = false;
+ /**
+ * TODO eigentlich sicherheitshalber gucken unter -
+ * I TYPE kommt aber nur einmal vor
+ */
+ Node type = XMLUtils.getFirstNode(document, "TYPE");
+ if (XMLUtils.getTheValue(type).equals("I"))
+ result = true;
+ return result;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/WebserviceClientBewegungsdaten.java b/src/de/superx/bin/WebserviceClientBewegungsdaten.java
new file mode 100644
index 0000000..af88e62
--- /dev/null
+++ b/src/de/superx/bin/WebserviceClientBewegungsdaten.java
@@ -0,0 +1,409 @@
+package de.superx.bin;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.net.Authenticator.RequestorType;
+import java.nio.charset.Charset;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.SOAPConnection;
+import javax.xml.soap.SOAPConnectionFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.util.LogUtils;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+
+public class WebserviceClientBewegungsdaten extends AbstractWebserviceClient {
+
+ private Document configDocument;
+ private XMLInputFactory factory = XMLInputFactory.newInstance();
+
+ private String hsnr;
+
+ private String xmlConfig, datentyp;
+ private String url;
+
+ private String soap;
+
+ private String outfilename;
+ private boolean columnNamesWritten = false, columnNamesHdWritten = false;
+ private File tmpFile, outFile, outFileHd;
+ private String jahr;
+ private PrintWriter fw, fwhd;
+ private BufferedWriter bfw, bfwhd;
+ private static final Logger log = Logger.getLogger("wc");
+
+ public static void main(String args[]) {
+ System.out
+ .println("SuperX-WebserviceClientBewegungsdaten Version 0.9.3");
+ WebserviceClientBewegungsdaten tc = new WebserviceClientBewegungsdaten();
+ tc.run(args);
+
+ }
+
+ public WebserviceClientBewegungsdaten() {
+
+ }
+
+ public void run(String args[]) {
+ try {
+
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+ // LogUtils.initRaw(log);
+ LogUtils.initRawFileDateTime("wc", "WebserviceClient.log", 100000,
+ 1, true, false);
+
+ log.setLevel(Level.FINEST);
+ log.getHandlers()[0].setLevel(Level.FINEST);
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-xmlconfig,-hsnr,-jahr,-out,-datentyp");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ // System.err.println(usage);
+ System.exit(1);
+ }
+ readConfig();
+
+ perform();
+
+ String msg = " fertig: " + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString();
+ log.info(msg);
+ System.out.println(msg);
+ } catch (Exception e) {
+ log.severe(e.getMessage());
+ System.out.println("Error " + e.getMessage());
+ e.printStackTrace();
+ LogUtils.close("wc");
+ System.exit(1);
+ } finally {
+ LogUtils.close("wc");
+
+ }
+ }
+
+ private void perform() throws Exception {
+
+ Node n = XMLUtils.getFirstNode(configDocument, datentyp + "detailurl");
+ url = XMLUtils.getTheValue(n);
+ url = adaptURL(url);
+ n = XMLUtils.getFirstNode(configDocument, datentyp + "detailsoap");
+ soap = XMLUtils.getTheValue(n);
+ soap = soap.replace("XXHSNRXX", hsnr);
+ soap = soap.replace("XXJAHRXX", jahr);
+ System.out.println(datentyp + "\n12x " + soap);
+ //n = XMLUtils.getFirstNode(configDocument, datentyp + "detailreplacenode");
+
+ initOutFile();
+ //Laut Herrn Schweitzer (SAP) keine Daten für Vorjahr und Folgejahr abrufen
+ // monat 0 ist Vorjahr, Monat 13 ist Folgejahr
+ for (int monat = 1; monat <= 12; monat++) {
+
+ String monatssoap = getMonatsoap(monat);
+ log.fine(datentyp + "\nSOAP Aufruf:\n" + monatssoap);
+ String msg = "starte Aufruf " + (monat );
+
+ System.out.print(msg);
+ tmpFile = createSoapFile(monatssoap, url);
+ msg =" - empfangen ";
+ if (!isDeleteTmpXmlFileWanted)
+ msg += " (" + tmpFile+")";
+ msg+=" "+DateUtils.getNowString();
+ System.out.println(msg);
+
+ String nodeName = "EX_" + datentyp.toUpperCase();
+
+ if (isReplyOk()) {
+ String columnNames = getColumnNames(nodeName).toString();
+ if (!columnNamesWritten && !columnNames.equals("")) {
+ bfw.write(columnNames);
+ columnNamesWritten = true;
+ }
+ String data = getData(nodeName).toString();
+ if (!data.equals(""))
+ bfw.write(data);
+ bfw.flush();
+
+ // Header
+ if (datentyp.equals("fmifiit")) {
+ columnNames = getColumnNames("EX_FMIFIHD").toString();
+ if (!columnNamesHdWritten && !columnNames.equals("")) {
+ bfwhd.write(columnNames);
+ columnNamesHdWritten = true;
+ }
+ data = getData("EX_FMIFIHD").toString();
+ if (!data.equals(""))
+ bfwhd.write(data);
+ bfwhd.flush();
+ }
+ if (isDeleteTmpXmlFileWanted)
+ tmpFile.delete();
+
+ } else {
+ msg = "Error: Aufruf von Webservice für Bewegungsdaten "
+ + datentyp + " (" + xmlConfig + ") fehlgeschlagen";
+ System.out.println(msg);
+ System.out.println(StringUtils.readFile(tmpFile));
+ log.severe(msg);
+ LogUtils.close("wc");
+ System.exit(-1);
+ }
+
+ }
+ closeFile();
+ }
+
+ private String getMonatsoap(int monat) {
+ String tempsoap = soap;
+ if (monat == 0) {
+ int vorjahr = Integer.parseInt(jahr);
+ vorjahr--;
+ tempsoap = tempsoap.replaceAll("XXSTARTXX", vorjahr + "-01-01");
+ tempsoap = tempsoap.replaceAll("XXENDEXX", vorjahr + "-12-31");
+ }
+
+ if (monat >= 1 && monat <= 12) {
+ int jahrint = Integer.parseInt(jahr);
+ GregorianCalendar cal = new GregorianCalendar(jahrint,monat-1, 1);
+ String monatstr;
+ if (monat < 10)
+ monatstr = "0" + monat;
+ else
+ monatstr = monat + "";
+ tempsoap = tempsoap.replaceAll("XXSTARTXX", jahr + "-" + monatstr
+ + "-01");
+ int maxDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
+ // System.out.println(maxDay);
+ tempsoap = tempsoap.replaceAll("XXENDEXX", jahr + "-" + monatstr
+ + "-" + maxDay);
+ }
+
+ if (monat == 13) {
+ int folgejahr = Integer.parseInt(jahr);
+ folgejahr++;
+ tempsoap = tempsoap.replaceAll("XXSTARTXX", folgejahr + "-01-01");
+ tempsoap = tempsoap.replaceAll("XXENDEXX", folgejahr + "-12-31");
+ }
+ return tempsoap;
+ }
+
+ private void readConfig() {
+
+ xmlConfig = GetOpts.getValue("-xmlconfig");
+ outfilename = GetOpts.getValue("-out");
+
+ hsnr = GetOpts.getValue("-hsnr");
+ jahr = GetOpts.getValue("-jahr");
+ datentyp = GetOpts.getValue("-datentyp");
+ System.out.println("\n" + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString() + "\nHochschulnummer " + hsnr);
+ log.info("\nHochschulnummer " + hsnr);
+ if (GetOpts.isPresent("-nodelete"))
+ isDeleteTmpXmlFileWanted = false;
+ log.log(Level.INFO, "Geschaeftsjahr " + jahr);
+ System.out.println("Geschaeftsjahr " + jahr);
+
+ log.log(Level.INFO, "Verarbeite " + xmlConfig);
+ System.out.println("Verarbeite " + xmlConfig);
+ configDocument = XMLUtils.buildDocument(new File(xmlConfig));
+
+ }
+
+ private void initOutFile() throws Exception {
+ outFile = new File(outfilename);
+ if (outFile.exists())
+ outFile.delete();
+ // FileWriter fw = new FileWriter(f);
+ fw = new PrintWriter(outFile);
+ // FileOutputStream fos = new FileOutputStream(f, false);
+ // BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(fos));
+
+ bfw = new BufferedWriter(fw);
+
+ if (datentyp.equals("fmifiit")) {
+
+ String hdfilename = StringUtils.replace(outfilename, ".", "hd.");
+ outFileHd = new File(hdfilename);
+ String msg = "Erzeuge zusaetzliche Header_Datei " + hdfilename;
+ log.log(Level.INFO, msg);
+ System.out.println(msg);
+ fwhd = new PrintWriter(outFileHd);
+ bfwhd = new BufferedWriter(fwhd);
+ }
+
+ }
+
+ private void closeFile() throws Exception {
+
+ bfw.close();
+ fw.close();
+
+ if (datentyp.equals("fmifiit")) {
+ bfwhd.close();
+ fwhd.close();
+ }
+
+ if (isDeleteTmpXmlFileWanted)
+ if (tmpFile.exists()) tmpFile.delete();
+ }
+
+ private boolean isReplyOk() throws XMLStreamException, IOException {
+ InputStream in = new FileInputStream(tmpFile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+ boolean checkReturn = false;
+ String result = "";
+ while (parser.hasNext()) {
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ if (parser.getLocalName().equals("RETURN")) {
+ checkReturn = true;
+
+ }
+ break;
+
+ case XMLStreamConstants.CHARACTERS:
+ if (checkReturn && !parser.isWhiteSpace()) {
+ result = parser.getText();
+ checkReturn = false;
+ }
+ break;
+ case XMLStreamConstants.END_DOCUMENT:
+
+ parser.close();
+ break;
+
+ }
+
+ parser.next();
+
+ }
+ in.close();
+ return result.equals("I");
+ }
+
+ private StringBuilder getData(String topnode) throws XMLStreamException,
+ IOException {
+ InputStream in = new FileInputStream(tmpFile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+ final String datumspattern = "(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)";
+
+ StringBuilder result = new StringBuilder();
+ boolean getData = false;
+ while (parser.hasNext()) {
+
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ String name = parser.getLocalName();
+ if (name.equals(topnode))
+ getData = true;
+ // Spaltennamen zu Debugzwecken anzeigen
+ // else if (getData && !name.equals("item"))
+ // result.append(prefix + "_" + parser.getLocalName());
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ if (getData && !parser.isWhiteSpace()) {
+ String data = parser.getText();
+
+ if (data.matches(datumspattern))
+ data = data.replaceAll(datumspattern, "$3.$2.$1");
+ else
+ data = purge(data);
+
+ result.append(data);
+ }
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (parser.getLocalName().equals(topnode))
+ getData = false;
+ else if (getData && parser.getLocalName().equals("item"))
+ result.append("\n");
+ else if (getData) {
+ result.append("^");
+ }
+ break;
+
+ case XMLStreamConstants.END_DOCUMENT:
+ parser.close();
+ break;
+ }
+ parser.next();
+ }
+ in.close();
+ // abschließendes ^ entfernen
+ //if (result.length() > 0) result.setLength(result.length() - 1);
+ return result;
+
+ }
+
+ private String getColumnNames(String topnode)
+ throws XMLStreamException, IOException {
+ InputStream in = new FileInputStream(tmpFile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+
+ String prefix = topnode.replaceAll("EX_", "");
+ StringBuilder result = new StringBuilder();
+ boolean getNames = false;
+ while (parser.hasNext()) {
+
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ String name = parser.getLocalName();
+ if (parser.getLocalName().equals(topnode))
+ getNames = true;
+ else if (getNames && !name.equals("item"))
+ result.append(prefix + "_" + parser.getLocalName() + "^");
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (parser.getLocalName().equals(topnode)||parser.getLocalName().equals("item"))
+ getNames = false;
+ break;
+
+ case XMLStreamConstants.END_DOCUMENT:
+ parser.close();
+ break;
+ }
+ parser.next();
+ }
+ in.close();
+ // abschließendes ^ entfernen
+ if (result.length() > 0)
+ result.setLength(result.length() - 1);
+ if (result.length() > 0)
+ result.append("\n");
+ return result.toString().toLowerCase();
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/WebserviceClientBewegungsdatenAlt.java b/src/de/superx/bin/WebserviceClientBewegungsdatenAlt.java
new file mode 100644
index 0000000..f05e2fd
--- /dev/null
+++ b/src/de/superx/bin/WebserviceClientBewegungsdatenAlt.java
@@ -0,0 +1,301 @@
+package de.superx.bin;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.net.Authenticator.RequestorType;
+import java.nio.charset.Charset;
+import java.util.Calendar;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.SOAPConnection;
+import javax.xml.soap.SOAPConnectionFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.util.LogUtils;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+
+/**
+ * @deprecated
+ * @author superx
+ *
+ */
+public class WebserviceClientBewegungsdatenAlt extends AbstractWebserviceClient {
+
+ private Document resultDocument, configDocument;
+
+ private String hsnr;
+
+ private final Calendar calendar = Calendar.getInstance();
+ private String xmlConfig, datentyp;
+ private String url;
+ private String data;
+ private String soap, replaceNodeName;
+
+ private String xslpfad, outfile;
+
+ private File tempFile;
+ private String jahr;
+ private PrintWriter fw;
+ private BufferedWriter bfw;
+ private static final Logger log = Logger.getLogger("wc");
+
+ public static void main(String args[]) {
+ System.out
+ .println("SuperX-WebserviceClientBewegungsdaten Version 0.9.3");
+ WebserviceClientBewegungsdatenAlt tc = new WebserviceClientBewegungsdatenAlt();
+ tc.run(args);
+
+ }
+
+ public WebserviceClientBewegungsdatenAlt() {
+
+ }
+
+ public void run(String args[]) {
+ try {
+
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+ // LogUtils.initRaw(log);
+ LogUtils.initRawFileDateTime("wc", "WebserviceClient.log", 100000,
+ 1, true, false);
+
+ log.setLevel(Level.FINEST);
+ log.getHandlers()[0].setLevel(Level.FINEST);
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-xmlconfig,-xslpfad,-hsnr,-jahr,-out,-datentyp");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ // System.err.println(usage);
+ System.exit(1);
+ }
+ readConfig();
+
+ perform();
+
+ String msg = " fertig: " + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString();
+ log.info(msg);
+ System.out.println(msg);
+ } catch (Exception e) {
+ log.severe(e.getMessage());
+ System.out.println("Error " + e.getMessage());
+ e.printStackTrace();
+ System.exit(1);
+ } finally {
+ LogUtils.close("wc");
+
+ }
+ }
+
+ private void perform() throws Exception {
+
+ Node n = XMLUtils.getFirstNode(configDocument, datentyp + "detailurl");
+ url = XMLUtils.getTheValue(n);
+ url = adaptURL(url);
+ n = XMLUtils.getFirstNode(configDocument, datentyp + "detailsoap");
+ soap = XMLUtils.getTheValue(n);
+ soap = soap.replace("XXHSNRXX", hsnr);
+ soap = soap.replace("XXJAHRXX", jahr);
+ System.out.println(datentyp + "\n14x " + soap);
+ n = XMLUtils.getFirstNode(configDocument, datentyp
+ + "detailreplacenode");
+ replaceNodeName = XMLUtils.getAttribValue(n, "from");
+ initTempFile();
+
+ // monat 0 ist Vorjahr, Monat 13 ist Folgejahr
+ for (int monat = 0; monat <= 4; monat++) {
+ String monatssoap = getMonatsoap(monat);
+ log.fine(datentyp + "\nSOAP Aufruf:\n" + monatssoap);
+ System.out.print("starte Aufruf " + (monat + 1));
+ data = readSOAP(monatssoap, url).toString();
+ System.gc();
+ System.out.println(" - empfangen ");
+
+
+ data = data
+ .replaceAll("<\\?xml version=\"1.0\" encoding=\".*>", "");
+ System.gc();
+ data = XMLUtils.removeTroublesomeCharacters(data);
+ System.gc();
+ data = data.replaceAll("\u20AC", "EUR");
+ System.gc();
+ data = data.replaceAll("\u2013", "-");// dash
+ System.gc();
+ data = data.replaceAll("\u2026", "...");// ...
+ System.gc();
+
+ data = StringUtils.replace(data, replaceNodeName, "response");
+ System.gc();
+ resultDocument = XMLUtils.buildDocumentFromString(data, false);
+
+ if (isReplyOk()) {
+ if (data.indexOf("")>-1||
+ data.indexOf("")>-1||
+ data.indexOf("")>-1) continue;
+ else
+ appendData();
+
+ } else {
+ String msg = "Error: Aufruf von Webservice für Bewegungsdaten "
+ + datentyp + " (" + xmlConfig + ") fehlgeschlagen";
+ System.out.println(msg);
+ log.severe(msg);
+ LogUtils.close("wc");
+ System.exit(-1);
+ }
+ System.gc();
+ }
+ closeFileAndTransform();
+ }
+
+ private String getMonatsoap(int monat) {
+ String tempsoap = soap;
+ if (monat == 0) {
+ int vorjahr = Integer.parseInt(jahr);
+ vorjahr--;
+ tempsoap = tempsoap.replaceAll("XXSTARTXX", vorjahr + "-01-01");
+ tempsoap = tempsoap.replaceAll("XXENDEXX", vorjahr + "-12-31");
+ }
+
+ if (monat >= 1 && monat <= 12) {
+ int jahrint = Integer.parseInt(jahr);
+ calendar.set(Calendar.YEAR, jahrint);
+ calendar.set(Calendar.MONTH, monat - 1);
+ String monatstr;
+ if (monat < 10)
+ monatstr = "0" + monat;
+ else
+ monatstr = monat + "";
+ tempsoap = tempsoap.replaceAll("XXSTARTXX", jahr + "-" + monatstr
+ + "-01");
+ int maxDay = calendar.getActualMaximum(Calendar.DATE);
+
+ tempsoap = tempsoap.replaceAll("XXENDEXX", jahr + "-" + monatstr
+ + "-" + maxDay);
+ }
+
+ if (monat == 13) {
+ int folgejahr = Integer.parseInt(jahr);
+ folgejahr++;
+ tempsoap = tempsoap.replaceAll("XXSTARTXX", folgejahr + "-01-01");
+ tempsoap = tempsoap.replaceAll("XXENDEXX", folgejahr + "-12-31");
+ }
+ return tempsoap;
+ }
+
+ private void readConfig() {
+
+ xmlConfig = GetOpts.getValue("-xmlconfig");
+ outfile = GetOpts.getValue("-out");
+ xslpfad = GetOpts.getValue("-xslpfad");
+ hsnr = GetOpts.getValue("-hsnr");
+ jahr = GetOpts.getValue("-jahr");
+ datentyp = GetOpts.getValue("-datentyp");
+ System.out.println("\n" + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString() + "\nHochschulnummer " + hsnr);
+ log.info("\nHochschulnummer " + hsnr);
+ if (GetOpts.isPresent("-nodelete"))
+ isDeleteTmpXmlFileWanted = false;
+ log.log(Level.INFO, "Geschaeftsjahr " + jahr);
+ System.out.println("Geschaeftsjahr " + jahr);
+
+ log.log(Level.INFO, "Verarbeite " + xmlConfig);
+ System.out.println("Verarbeite " + xmlConfig);
+ configDocument = XMLUtils.buildDocument(new File(xmlConfig));
+
+ }
+
+ private void appendData() throws Exception {
+ bfw.write(data);
+ bfw.flush();
+ }
+
+ private void initTempFile() throws Exception {
+ tempFile = File.createTempFile("webservicedata", ".xml");
+ // File f=new File("tmpwebservice.xml");
+ if (!isDeleteTmpXmlFileWanted) {
+ System.out.println("Temp Datei: " + tempFile.getAbsolutePath());
+ log.info("Temp Datei: " + tempFile.getAbsolutePath());
+ }
+ if (tempFile.exists())
+ tempFile.delete();
+ // FileWriter fw = new FileWriter(f);
+ fw = new PrintWriter(tempFile, "UTF-8");
+ // FileOutputStream fos = new FileOutputStream(f, false);
+ // BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(fos));
+
+ bfw = new BufferedWriter(fw);
+ bfw.write("\n");
+
+ }
+
+ private void closeFileAndTransform() throws Exception {
+ bfw.write("\n\n");
+ bfw.close();
+ fw.close();
+
+ SxTransformer sxTrans = new SxTransformer(log, outfile);
+ sxTrans.quellstring = tempFile.getAbsolutePath();
+ sxTrans.stylesheet = xslpfad + File.separator + "soap_to_csv_"
+ + datentyp + ".xsl";
+ sxTrans.params = "ignoreElements=EX_JEST";
+ sxTrans.transformFile("text");
+ //bei Fmiit auch HeaderDatei erzeugen
+ if (datentyp.equals("fmifiit"))
+ {
+
+ sxTrans.outfile=StringUtils.replace(outfile, ".", "hd.");
+ sxTrans.stylesheet=StringUtils.replace(sxTrans.stylesheet,"soap_to_csv_fmifiit.xsl","soap_to_csv_fmifihd.xsl");
+ String msg="Erzeuge zusaetzliche Header_Datei "+sxTrans.outfile;
+ log.log(Level.INFO, msg);
+ System.out.println(msg);
+ sxTrans.transformFile("text");
+ }
+ if (isDeleteTmpXmlFileWanted)
+ tempFile.delete();
+ }
+
+ private boolean isReplyOk() {
+ boolean result = false;
+ /**
+ * TODO eigentlich sicherheitshalber gucken unter
-
+ * I TYPE kommt aber nur einmal vor
+ */
+ if (!XMLUtils.hasANodeWithName(resultDocument, "TYPE")) {
+ System.out.println(data);
+ log.severe(data);
+ } else {
+ Node type = XMLUtils.getFirstNode(resultDocument, "TYPE");
+ if (XMLUtils.getTheValue(type).equals("I"))
+ result = true;
+ }
+ return result;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/WebserviceClientBewegungsdatenByFistl.java b/src/de/superx/bin/WebserviceClientBewegungsdatenByFistl.java
new file mode 100644
index 0000000..a37a32c
--- /dev/null
+++ b/src/de/superx/bin/WebserviceClientBewegungsdatenByFistl.java
@@ -0,0 +1,412 @@
+package de.superx.bin;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.net.Authenticator.RequestorType;
+import java.nio.charset.Charset;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.GregorianCalendar;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.SOAPConnection;
+import javax.xml.soap.SOAPConnectionFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.util.LogUtils;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+
+public class WebserviceClientBewegungsdatenByFistl extends AbstractWebserviceClient {
+ private Collection finanzstellen = new LinkedList();
+ private boolean isDBConnectionPossible = true;
+ private Document configDocument;
+ private XMLInputFactory factory = XMLInputFactory.newInstance();
+
+ private String hsnr;
+
+ private String xmlConfig, datentyp;
+ private String url;
+
+ private String soap;
+
+ private String outfilename;
+ private boolean columnNamesWritten = false, columnNamesHdWritten = false;
+ private File tmpFile, outFile, outFileHd;
+ private String jahr;
+ private PrintWriter fw, fwhd;
+ private BufferedWriter bfw, bfwhd;
+ private String dbpropfile;
+ private static final Logger log = Logger.getLogger("wc");
+
+ public static void main(String args[]) {
+ System.out
+ .println("SuperX-WebserviceClientBewegungsdatenByFistl Version 0.9.3");
+ WebserviceClientBewegungsdatenByFistl tc = new WebserviceClientBewegungsdatenByFistl();
+ tc.run(args);
+
+ }
+
+ public WebserviceClientBewegungsdatenByFistl() {
+
+ }
+
+ public void run(String args[]) {
+ try {
+
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+ // LogUtils.initRaw(log);
+ LogUtils.initRawFileDateTime("wc", "WebserviceClient.log", 100000,
+ 1, true, false);
+
+ log.setLevel(Level.FINEST);
+ log.getHandlers()[0].setLevel(Level.FINEST);
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-xmlconfig,-hsnr,-jahr,-out,-datentyp,-dbproperties");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ // System.err.println(usage);
+ System.exit(1);
+ }
+ readConfig();
+ readFinanzstellen();
+ perform();
+
+ String msg = " fertig: " + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString();
+ log.info(msg);
+ System.out.println(msg);
+ } catch (Exception e) {
+ log.severe(e.getMessage());
+ System.out.println("Error " + e.getMessage());
+ e.printStackTrace();
+ LogUtils.close("wc");
+ System.exit(1);
+ } finally {
+ LogUtils.close("wc");
+
+ }
+ }
+
+ private void perform() throws Exception {
+
+ Node n = XMLUtils.getFirstNode(configDocument, datentyp + "detailurl");
+ url = XMLUtils.getTheValue(n);
+ url = adaptURL(url);
+ n = XMLUtils.getFirstNode(configDocument, datentyp + "detailsoap");
+ soap = XMLUtils.getTheValue(n);
+ soap = soap.replace("XXHSNRXX", hsnr);
+ soap = soap.replace("XXJAHRXX", jahr);
+ System.out.println(datentyp + "\nSOAP Aufruf:\n" + soap);
+ //n = XMLUtils.getFirstNode(configDocument, datentyp + "detailreplacenode");
+
+ log.fine(datentyp + "\nSOAP Aufruf:\n" + soap);
+ initOutFile();
+ String msg="";
+ Iterator it = finanzstellen.iterator();
+ int i = 0;
+ while (it.hasNext()) {
+ String fistl = it.next();
+ String tmpsoap = soap.replace("XXFISTLXX", fistl);
+ i++;
+ if (i % 10 == 0)
+ System.out.print(i + " ");
+
+ tmpFile = createSoapFile(tmpsoap, url);
+ /*msg =" - empfangen ";
+ if (!isDeleteTmpXmlFileWanted)
+ msg += " (" + tmpFile+")";
+ msg+=" "+DateUtils.getNowString();
+ System.out.println(msg);
+*/
+ String nodeName = "EX_" + datentyp.toUpperCase();
+
+ if (isReplyOk()) {
+ String columnNames = getColumnNames(nodeName).toString();
+ if (!columnNamesWritten && !columnNames.equals("")) {
+ bfw.write(columnNames);
+ columnNamesWritten = true;
+ }
+ String data = getData(nodeName).toString();
+ if (!data.equals(""))
+ bfw.write(data);
+ bfw.flush();
+
+ // Header
+ if (datentyp.equals("fmifiit")) {
+ columnNames = getColumnNames("EX_FMIFIHD").toString();
+ if (!columnNamesHdWritten && !columnNames.equals("")) {
+ bfwhd.write(columnNames);
+ columnNamesHdWritten = true;
+ }
+ data = getData("EX_FMIFIHD").toString();
+ if (!data.equals(""))
+ bfwhd.write(data);
+ bfwhd.flush();
+ }
+ if (isDeleteTmpXmlFileWanted)
+ tmpFile.delete();
+
+ } else {
+ msg = "Error: Aufruf von Webservice für Bewegungsdaten "
+ + datentyp + " (" + xmlConfig + ") fehlgeschlagen";
+ System.out.println(msg);
+ System.out.println(StringUtils.readFile(tmpFile));
+ log.severe(msg);
+ LogUtils.close("wc");
+ System.exit(-1);
+ }
+
+ }
+ closeFile();
+ }
+
+
+
+ private void readConfig() {
+
+ xmlConfig = GetOpts.getValue("-xmlconfig");
+ outfilename = GetOpts.getValue("-out");
+
+ hsnr = GetOpts.getValue("-hsnr");
+ jahr = GetOpts.getValue("-jahr");
+ datentyp = GetOpts.getValue("-datentyp");
+ dbpropfile = GetOpts.getValue("-dbproperties");
+ System.out.println("\n" + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString() + "\nHochschulnummer " + hsnr);
+ log.info("\nHochschulnummer " + hsnr);
+ if (GetOpts.isPresent("-nodelete"))
+ isDeleteTmpXmlFileWanted = false;
+ log.log(Level.INFO, "Geschaeftsjahr " + jahr);
+ System.out.println("Geschaeftsjahr " + jahr);
+
+ log.log(Level.INFO, "Verarbeite " + xmlConfig);
+ System.out.println("Verarbeite " + xmlConfig);
+ configDocument = XMLUtils.buildDocument(new File(xmlConfig));
+
+ }
+
+ private void initOutFile() throws Exception {
+ outFile = new File(outfilename);
+ if (outFile.exists())
+ outFile.delete();
+ // FileWriter fw = new FileWriter(f);
+ fw = new PrintWriter(outFile);
+ // FileOutputStream fos = new FileOutputStream(f, false);
+ // BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(fos));
+
+ bfw = new BufferedWriter(fw);
+
+ if (datentyp.equals("fmifiit")) {
+
+ String hdfilename = StringUtils.replace(outfilename, ".", "hd.");
+ outFileHd = new File(hdfilename);
+ String msg = "Erzeuge zusaetzliche Header_Datei " + hdfilename;
+ log.log(Level.INFO, msg);
+ System.out.println(msg);
+ fwhd = new PrintWriter(outFileHd);
+ bfwhd = new BufferedWriter(fwhd);
+ }
+
+ }
+
+ private void closeFile() throws Exception {
+
+ bfw.close();
+ fw.close();
+
+ if (datentyp.equals("fmifiit")) {
+ bfwhd.close();
+ fwhd.close();
+ }
+
+ if (isDeleteTmpXmlFileWanted)
+ if (tmpFile.exists()) tmpFile.delete();
+ }
+
+ private boolean isReplyOk() throws XMLStreamException, IOException {
+ InputStream in = new FileInputStream(tmpFile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+ boolean checkReturn = false;
+ String result = "";
+ while (parser.hasNext()) {
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ if (parser.getLocalName().equals("RETURN")) {
+ checkReturn = true;
+
+ }
+ break;
+
+ case XMLStreamConstants.CHARACTERS:
+ if (checkReturn && !parser.isWhiteSpace()) {
+ result = parser.getText();
+ checkReturn = false;
+ }
+ break;
+ case XMLStreamConstants.END_DOCUMENT:
+
+ parser.close();
+ break;
+
+ }
+
+ parser.next();
+
+ }
+ in.close();
+ return result.equals("I");
+ }
+
+ private StringBuilder getData(String topnode) throws XMLStreamException,
+ IOException {
+ InputStream in = new FileInputStream(tmpFile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+ final String datumspattern = "(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)";
+
+ StringBuilder result = new StringBuilder();
+ boolean getData = false;
+ while (parser.hasNext()) {
+
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ String name = parser.getLocalName();
+ if (name.equals(topnode))
+ getData = true;
+ // Spaltennamen zu Debugzwecken anzeigen
+ // else if (getData && !name.equals("item"))
+ // result.append(prefix + "_" + parser.getLocalName());
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ if (getData && !parser.isWhiteSpace()) {
+ String data = parser.getText();
+
+ if (data.matches(datumspattern))
+ data = data.replaceAll(datumspattern, "$3.$2.$1");
+ else
+ data = purge(data);
+
+ result.append(data);
+ }
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (parser.getLocalName().equals(topnode))
+ getData = false;
+ else if (getData && parser.getLocalName().equals("item"))
+ result.append("\n");
+ else if (getData) {
+ result.append("^");
+ }
+ break;
+
+ case XMLStreamConstants.END_DOCUMENT:
+ parser.close();
+ break;
+ }
+ parser.next();
+ }
+ in.close();
+ // abschließendes ^ entfernen
+ //if (result.length() > 0) result.setLength(result.length() - 1);
+ return result;
+
+ }
+
+ private String getColumnNames(String topnode)
+ throws XMLStreamException, IOException {
+ InputStream in = new FileInputStream(tmpFile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+
+ String prefix = topnode.replaceAll("EX_", "");
+ StringBuilder result = new StringBuilder();
+ boolean getNames = false;
+ while (parser.hasNext()) {
+
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ String name = parser.getLocalName();
+ if (parser.getLocalName().equals(topnode))
+ getNames = true;
+ else if (getNames && !name.equals("item"))
+ result.append(prefix + "_" + parser.getLocalName() + "^");
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (parser.getLocalName().equals(topnode)||parser.getLocalName().equals("item"))
+ getNames = false;
+ break;
+
+ case XMLStreamConstants.END_DOCUMENT:
+ parser.close();
+ break;
+ }
+ parser.next();
+ }
+ in.close();
+ // abschließendes ^ entfernen
+ if (result.length() > 0)
+ result.setLength(result.length() - 1);
+ if (result.length() > 0)
+ result.append("\n");
+ return result.toString().toLowerCase();
+ }
+
+ private void readFinanzstellen() throws Exception {
+ if (isDBConnectionPossible) {
+ SxConnection myConnection = new SxConnection();
+ myConnection.setPropfile(dbpropfile);
+ Connection con = myConnection.getConnection();
+ Statement stm = con.createStatement();
+
+ ResultSet rs = stm
+ .executeQuery("select distinct fmfctr_fictr from gxstage_sap_sc11 -- where csks_kostl in ('8056100000','8056410000','8056121002')");
+ // gxstage_inst sind auch Hilfskostenstellen (Hierarchie enthalten)
+ while (rs.next()) {
+ String instnr = rs.getString(1);
+ finanzstellen.add(instnr);
+ }
+ rs.close();
+ stm.close();
+ con.close();
+
+ }
+ String msg = finanzstellen.size() + " Finanzstellen gefunden";
+ log.log(Level.INFO, msg);
+ System.out.println(msg);
+ }
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/WebserviceClientHier.java b/src/de/superx/bin/WebserviceClientHier.java
new file mode 100644
index 0000000..d1bb9a2
--- /dev/null
+++ b/src/de/superx/bin/WebserviceClientHier.java
@@ -0,0 +1,187 @@
+package de.superx.bin;
+
+import java.beans.Statement;
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.Iterator;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.soap.SOAPException;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.util.LogUtils;
+import de.memtext.util.XMLUtils;
+
+public class WebserviceClientHier extends AbstractWebserviceClient {
+
+ private String dbpropfile;
+ private String hsnr;
+ private String xmlConfig;
+ private String wsurl;
+ private String hierSOAP;
+ private Document document;
+ private static final Logger log = Logger.getLogger("wc");
+
+ private PreparedStatement pst_insert;
+ private Connection con;
+
+ public WebserviceClientHier() {
+
+ }
+
+ public static void main(String args[]) {
+ System.out.println("SuperX-WebserviceClientHier Version 0.9.5");
+ WebserviceClientHier tc = new WebserviceClientHier();
+ tc.run(args);
+
+ }
+
+ public void run(String args[]) {
+ try {
+
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+
+ // LogUtils.initRaw(log);
+ LogUtils.initRawFileDateTime("wc", "WebserviceClient.log", 100000,
+ 1, true, false);
+
+ log.setLevel(Level.FINEST);
+ log.getHandlers()[0].setLevel(Level.FINEST);
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-dbproperties,-xmlconfig,-hsnr");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ // System.err.println(usage);
+ System.exit(1);
+ }
+ readConfig();
+ prepareDbAndPreparedStatement();
+
+ readKostenstellen(hsnr,null);
+ con.close();
+ } catch (Exception e) {
+ log.severe(e.getMessage());
+ System.out.println("Error " + e.getMessage());
+ e.printStackTrace();
+ LogUtils.close("wc");
+ System.exit(1);
+ } finally {
+ LogUtils.close("wc");
+ }
+ }
+
+ private void prepareDbAndPreparedStatement() throws Exception {
+ SxConnection myConnection = new SxConnection();
+ myConnection.setPropfile(dbpropfile);
+ con = myConnection.getConnection();
+ java.sql.Statement st=con.createStatement();
+ st.execute("delete from gxstage_inst_hier");
+ st.close();
+ pst_insert = con
+ .prepareStatement("insert into gxstage_inst_hier (inst_nr, uebinst_nr,lname1,orgstruktur) values (?,?,?,-1)");
+
+ }
+
+ private void readKostenstellen(String kostenstelle,String parent)
+ throws Exception {
+ String soap = hierSOAP.replaceAll("XXKOSTLXX", kostenstelle);
+ StringBuffer result = readSOAP(soap, wsurl);
+ document = XMLUtils.buildDocumentFromString(result.toString(), false);
+ //System.out.println(result);
+ if (isReplyOk()) {
+ Node headert = XMLUtils.getFirstNode(document, "EX_SETHEADERT");
+ Node headertitem = XMLUtils.getChildNode(headert, "item");
+ String id = XMLUtils.getChildNodeValue(headertitem, "SETNAME");
+ String name = XMLUtils.getChildNodeValue(headertitem, "DESCRIPT");
+ String msg = " Kostenstelle " + id + " " + name + " gefunden";
+ System.out.println(msg);
+ log.log(Level.FINEST, msg);
+
+ updateDatabase(id, parent, name);
+ Node kids = XMLUtils.getFirstNode(document, "EX_SETNODE");
+ Iterator it = XMLUtils.getChildNodeIterator(kids);
+ while (it.hasNext()) {
+ Node item = (Node) it.next();
+ String unterkostenstelle = XMLUtils.getChildNodeValue(item,
+ "SUBSETNAME");
+ readKostenstellen(unterkostenstelle,kostenstelle);
+ }
+
+ } else {
+ String msg = "Error: Aufruf von Webservice für " + xmlConfig
+ + " fehlgeschlagen";
+ System.out.println(msg);
+ log.severe(msg);
+ LogUtils.close("wc");
+ System.exit(-1);
+ }
+ }
+
+ private void updateDatabase(String id, String parent, String name)
+ throws SQLException {
+
+
+ pst_insert.clearParameters();
+ pst_insert.setString(1, id);
+ pst_insert.setString(2, parent);
+ pst_insert.setString(3, name);
+ pst_insert.execute();
+
+ }
+
+ private boolean isReplyOk() {
+ boolean result = false;
+ /**
+ * TODO eigentlich sicherheitshalber gucken unter
-
+ * I TYPE kommt aber nur einmal vor
+ */
+ Node type = XMLUtils.getFirstNode(document, "TYPE");
+ if (XMLUtils.getTheValue(type).equals("I"))
+ result = true;
+ return result;
+ }
+
+ private void readConfig() {
+ dbpropfile = GetOpts.getValue("-dbproperties");
+
+ hsnr = GetOpts.getValue("-hsnr");
+ System.out.println("\n" + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString() + "\nHochschulnummer " + hsnr);
+ log.info("\nHochschulnummer " + hsnr);
+ xmlConfig = GetOpts.getValue("-xmlconfig");
+ if (GetOpts.isPresent("-nodelete"))
+ isDeleteTmpXmlFileWanted = false;
+ if (GetOpts.isPresent("-pause")) {
+ String p = GetOpts.getValue("-pause");
+ pause = Integer.parseInt(p);
+ System.out.println("Pause between soap calls " + pause);
+ }
+ log.log(Level.INFO, "Verarbeite " + xmlConfig);
+ System.out.println("Verarbeite " + xmlConfig);
+ Document dconf = XMLUtils.buildDocument(new File(xmlConfig));
+
+ Node n = XMLUtils.getFirstNode(dconf, "webservice");
+
+ n = XMLUtils.getFirstNode(dconf, "wsurl");
+ wsurl = XMLUtils.getTheValue(n);
+ wsurl = adaptURL(wsurl);
+ n = XMLUtils.getFirstNode(dconf, "hiersoap");
+ hierSOAP = XMLUtils.getTheValue(n);
+ hierSOAP = hierSOAP.replaceAll("XXHSNRXX", hsnr);
+
+ }
+
+}
diff --git a/src/de/superx/bin/WebserviceClientSummendaten.java b/src/de/superx/bin/WebserviceClientSummendaten.java
new file mode 100644
index 0000000..d5cb0cb
--- /dev/null
+++ b/src/de/superx/bin/WebserviceClientSummendaten.java
@@ -0,0 +1,274 @@
+package de.superx.bin;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.net.Authenticator.RequestorType;
+import java.nio.charset.Charset;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.SOAPConnection;
+import javax.xml.soap.SOAPConnectionFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import de.memtext.util.DateUtils;
+import de.memtext.util.GetOpts;
+import de.memtext.util.LogUtils;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+
+public class WebserviceClientSummendaten extends AbstractWebserviceClient {
+
+ private Collection finanzstellen = new LinkedList();
+ private Document resultDocument, configDocument;
+
+ private String hsnr;
+
+ private String xmlConfig, datentyp;
+ private String url, data;
+ private String soap, replaceNodeName;
+
+ private String xslpfad, outfile;
+ private boolean isDeleteTmpXmlFileWanted = true;
+
+ private String jahr;
+
+ private boolean isDBConnectionPossible = true;
+
+ private String dbpropfile;
+ private static final Logger log = Logger.getLogger("wc");
+
+ public static void main(String args[]) {
+ System.out.println("SuperX-WebserviceClientSummendaten Version 0.9.3");
+ WebserviceClientSummendaten tc = new WebserviceClientSummendaten();
+ tc.run(args);
+
+ }
+
+ public WebserviceClientSummendaten() {
+
+ }
+
+ public void run(String args[]) {
+ try {
+
+ XMLUtils.getExceptionHandler().setWithGui(false);
+ XMLUtils.getExceptionHandler().setExitWanted(true);
+ // LogUtils.initRaw(log);
+ LogUtils.initRawFileDateTime("wc", "WebserviceClient.log", 100000,
+ 1, true, false);
+
+ log.setLevel(Level.FINEST);
+ log.getHandlers()[0].setLevel(Level.FINEST);
+ GetOpts.setOpts(args);
+ String isdrin = GetOpts
+ .isAllRequiredOptionsPresent("-xmlconfig,-xslpfad,-hsnr,-jahr,-out,-datentyp");
+ if (isdrin != null) {
+ System.err.println("Folgende Optionen fehlen: " + isdrin);
+ // System.err.println(usage);
+ System.exit(1);
+ }
+ readConfig();
+ readFinanzstellen();
+ perform();
+
+ String msg = " fertig: " + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString();
+ log.info(msg);
+ System.out.println(msg);
+ } catch (Exception e) {
+ log.severe(e.getMessage());
+ System.out.println("Error " + e.getMessage());
+ e.printStackTrace();
+ LogUtils.close("wc");
+ System.exit(1);
+ } finally {
+ LogUtils.close("wc");
+
+ }
+ }
+
+ private void readFinanzstellen() throws Exception {
+ if (isDBConnectionPossible) {
+ SxConnection myConnection = new SxConnection();
+ myConnection.setPropfile(dbpropfile);
+ Connection con = myConnection.getConnection();
+ Statement stm = con.createStatement();
+
+ ResultSet rs = stm
+ .executeQuery("select distinct fmfctr_fictr from gxstage_sap_sc11 -- where csks_kostl in ('8056100000','8056410000','8056121002')");
+ // gxstage_inst sind auch Hilfskostenstellen (Hierarchie enthalten)
+ while (rs.next()) {
+ String instnr = rs.getString(1);
+ finanzstellen.add(instnr);
+ }
+ rs.close();
+ stm.close();
+ con.close();
+
+ }
+ String msg = finanzstellen.size() + " Finanzstellen gefunden";
+ log.log(Level.INFO, msg);
+ System.out.println(msg);
+ }
+
+ private void perform() throws Exception {
+
+ Node n = XMLUtils.getFirstNode(configDocument, datentyp + "sumurl");
+ url = XMLUtils.getTheValue(n);
+ url = adaptURL(url);
+ n = XMLUtils.getFirstNode(configDocument, datentyp + "sumsoap");
+ soap = XMLUtils.getTheValue(n);
+ soap = soap.replace("XXHSNRXX", hsnr);
+ soap = soap.replace("XXJAHRXX", jahr);
+ System.out.println(datentyp + "\n" + soap);
+ n = XMLUtils.getFirstNode(configDocument, datentyp + "sumreplacenode");
+ replaceNodeName = XMLUtils.getAttribValue(n, "from");
+
+ log.fine(datentyp + "\nSOAP Aufruf:\n" + soap);
+ StringBuffer data1 = new StringBuffer();
+ // Schleife über Kostenstellen
+ Iterator it = finanzstellen.iterator();
+ int i = 0;
+ while (it.hasNext()) {
+ String fistl = it.next();
+ i++;
+ if (i % 10 == 0)
+ System.out.print(i + " ");
+
+ String tmpsoap = soap.replace("XXFISTLXX", fistl);
+ String result = readSOAP(tmpsoap, url).toString();
+
+ resultDocument = XMLUtils.buildDocumentFromString(result,
+ false);
+ if (!isReplyOk()) {
+ String msg = "Error: Aufruf von Webservice fuer Summendaten "
+ + datentyp + " (" + xmlConfig + ") FISTL:" + fistl
+ + " fehlgeschlagen" +result;
+ System.out.println(msg);
+ log.severe(msg);
+ LogUtils.close("wc");
+ System.exit(-1);
+ }
+ if (result.indexOf("Es wurden 0000 Sätze gefunden!") > -1
+ || result.indexOf("Es wurden 0000 Belege gefunden!") > -1
+ || result.indexOf("Es wurden 00000 Belege gefunden!") > -1
+ || result.indexOf("") > -1
+ || result.indexOf("") > -1
+ || result.indexOf("") > -1)
+ continue;
+ data1.append(result);
+
+ }
+ System.out.println("");
+ data = data1.toString();
+
+ data = data.replaceAll("<\\?xml version=\"1.0\" encoding=\".*>", "");
+ data = purge(data);
+ data = StringUtils.replace(data, replaceNodeName, "response");
+
+ writeChangeXml();
+
+ }
+
+ private void readConfig() {
+
+ xmlConfig = GetOpts.getValue("-xmlconfig");
+ outfile = GetOpts.getValue("-out");
+ xslpfad = GetOpts.getValue("-xslpfad");
+ hsnr = GetOpts.getValue("-hsnr");
+ jahr = GetOpts.getValue("-jahr");
+ datentyp = GetOpts.getValue("-datentyp");
+ dbpropfile = GetOpts.getValue("-dbproperties");
+
+ System.out.println("\n" + DateUtils.getTodayString() + " "
+ + DateUtils.getNowString() + "\nHochschulnummer " + hsnr);
+ log.info("\nHochschulnummer " + hsnr);
+ if (GetOpts.isPresent("-nodelete"))
+ isDeleteTmpXmlFileWanted = false;
+ log.log(Level.INFO, "Geschaeftsjahr " + jahr);
+ System.out.println("Geschaeftsjahr " + jahr);
+
+ log.log(Level.INFO, "Verarbeite " + xmlConfig);
+ System.out.println("Verarbeite " + xmlConfig);
+ configDocument = XMLUtils.buildDocument(new File(xmlConfig));
+
+ }
+
+ private void writeChangeXml() throws Exception {
+ File f = File.createTempFile("webservicedata", ".xml");
+ // File f=new File("tmpwebservice.xml");
+ if (!isDeleteTmpXmlFileWanted) {
+ System.out.println("Temp Datei: " + f.getAbsolutePath());
+ log.info("Temp Datei: " + f.getAbsolutePath());
+ }
+ if (f.exists())
+ f.delete();
+ // FileWriter fw = new FileWriter(f);
+ PrintWriter fw = new PrintWriter(f, "UTF-8");
+ // FileOutputStream fos = new FileOutputStream(f, false);
+ // BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(fos));
+
+ BufferedWriter bfw = new BufferedWriter(fw);
+ bfw.write("\n");
+ bfw.write(data);
+
+ bfw.write("\n\n");
+ bfw.close();
+ fw.close();
+
+ SxTransformer sxTrans = new SxTransformer(log, outfile);
+ sxTrans.quellstring = f.getAbsolutePath();
+ sxTrans.stylesheet = xslpfad + File.separator + "sum_soap_to_csv_"
+ + datentyp + ".xsl";
+ sxTrans.params = "ignoreElements=EX_JEST";
+ sxTrans.transformFile("text");
+ if (isDeleteTmpXmlFileWanted)
+ f.delete();
+
+ }
+
+ private boolean isReplyOk() {
+ boolean result = false;
+ /**
+ * TODO eigentlich sicherheitshalber gucken unter
-
+ * I TYPE kommt aber nur einmal vor
+ */
+ if (!XMLUtils.hasANodeWithName(resultDocument, "TYPE")) {
+ System.out.println(data);
+ log.severe(data);
+ } else {
+ Node type = XMLUtils.getFirstNode(resultDocument, "TYPE");
+ if (XMLUtils.getTheValue(type).equals("I"))
+ result = true;
+ }
+ return result;
+ }
+
+}
\ No newline at end of file
diff --git a/src/de/superx/bin/WebserviceClientTest.java b/src/de/superx/bin/WebserviceClientTest.java
new file mode 100644
index 0000000..cb75725
--- /dev/null
+++ b/src/de/superx/bin/WebserviceClientTest.java
@@ -0,0 +1,177 @@
+package de.superx.bin;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+public class WebserviceClientTest extends AbstractWebserviceClient {
+ XMLInputFactory factory = XMLInputFactory.newInstance();
+ File tmpfile = new File("/tmp/soapdata1576848581935822407.xml"); //"/home/superx/tmp/bewmai.xml");
+
+ public void run() {
+ String url = "https://kpi-nsi.landbw.de/sap/xi/engine?type=entry&version=3.0&Sender.Service=WsHAWFmifiitGetSyn&Interface=http%3A%2F%2Fnsi-cc.bwl.de%2Fhaw%2Fpsm%5EMiFmifiitGetSynOut";
+ String soap = " \n"
+ + " \n"
+ + " \n"
+ + " \n"
+ + " 3001 \n"
+ + " 2015 \n"
+ + " 2014-05-01 \n"
+ + " 2014-05-31 \n"
+ + " \n"
+ + " \n"
+ + " \n" + " ";
+
+ try {
+ tmpfile=createSoapFile(soap, url);
+ System.out.println(tmpfile);
+ if (isReplyOk()) {
+ // System.out.println(getColumnNames("EX_FMIFIHD"));
+ System.out.println(getColumnNames("EX_FMIFIIT"));
+ System.out.println(getData("EX_FMIFIIT"));
+ // System.out.println(getData("EX_FMIFIHD"));
+
+ }
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ public static void main(String[] args) {
+ new WebserviceClientTest().run();
+
+ }
+
+ private StringBuilder getData(String topnode) throws XMLStreamException,
+ IOException {
+ InputStream in = new FileInputStream(tmpfile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+ final String datumspattern = "(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)";
+
+ StringBuilder result = new StringBuilder();
+ boolean getData = false;
+ while (parser.hasNext()) {
+
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ String name = parser.getLocalName();
+ if (name.equals(topnode))
+ getData = true;
+ // Spaltennamen zu Debugzwecken anzeigen
+ // else if (getData && !name.equals("item"))
+ // result.append(prefix + "_" + parser.getLocalName());
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ if (getData && !parser.isWhiteSpace()) {
+ String data = parser.getText();
+
+ if (data.matches(datumspattern))
+ data = data.replaceAll(datumspattern, "$3.$2.$1");
+ else
+ data = purge(data);
+
+ result.append(data);
+ }
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (parser.getLocalName().equals(topnode))
+ getData = false;
+ else if (getData && parser.getLocalName().equals("item"))
+ result.append("\n");
+ else if (getData) {
+ result.append("^");
+ }
+ break;
+
+ case XMLStreamConstants.END_DOCUMENT:
+ parser.close();
+ break;
+ }
+ parser.next();
+ }
+ in.close();
+ // abschließendes ^ entfernen
+ //if (result.length() > 0) result.setLength(result.length() - 1);
+ return result;
+
+ }
+
+ private StringBuilder getColumnNames(String topnode)
+ throws XMLStreamException, IOException {
+ InputStream in = new FileInputStream(tmpfile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+
+ String prefix = topnode.replaceAll("EX_", "");
+ StringBuilder result = new StringBuilder();
+ boolean getNames = false;
+ while (parser.hasNext()) {
+
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ String name = parser.getLocalName();
+ if (parser.getLocalName().equals(topnode))
+ getNames = true;
+ else if (getNames && !name.equals("item"))
+ result.append(prefix + "_" + parser.getLocalName() + "^");
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (parser.getLocalName().equals("item")||parser.getLocalName().equals(topnode))
+ getNames = false;
+ break;
+
+ case XMLStreamConstants.END_DOCUMENT:
+ parser.close();
+ break;
+ }
+ parser.next();
+ }
+ in.close();
+ // abschließendes ^ entfernen
+ if (result.length() > 0)
+ result.setLength(result.length() - 1);
+ result.append("\n");
+ return result;
+ }
+
+ private boolean isReplyOk() throws XMLStreamException, IOException {
+ InputStream in = new FileInputStream(tmpfile);
+ XMLStreamReader parser = factory.createXMLStreamReader(in);
+ boolean checkReturn = false;
+ String result = "";
+ while (parser.hasNext()) {
+ switch (parser.getEventType()) {
+ case XMLStreamConstants.START_ELEMENT:
+ if (parser.getLocalName().equals("RETURN")) {
+ checkReturn = true;
+
+ }
+ break;
+
+ case XMLStreamConstants.CHARACTERS:
+ if (checkReturn && !parser.isWhiteSpace()) {
+ result = parser.getText();
+ checkReturn = false;
+ }
+ break;
+ case XMLStreamConstants.END_DOCUMENT:
+
+ parser.close();
+ break;
+
+ }
+
+ parser.next();
+
+ }
+ in.close();
+ return result.equals("I");
+ }
+
+}
diff --git a/src/de/superx/bin/Wget.java b/src/de/superx/bin/Wget.java
new file mode 100644
index 0000000..edc8c75
--- /dev/null
+++ b/src/de/superx/bin/Wget.java
@@ -0,0 +1,117 @@
+package de.superx.bin;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedWriter;
+import java.io.DataInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+
+public class Wget {
+
+ public static void main(String[] args) {
+
+ if ((args.length != 2)) {
+ System.err.println("\nUsage: java de.superx.bin.Wget url Dateiname");
+ System.exit(1);
+ }
+
+ String url = args[0];
+ String filename = args[1];
+ if (filename.endsWith(".xls")) {
+ url += "&stylesheet=tabelle_xls.xsl&maxoffset=1000000&contenttype=application/vnd.ms-excel";
+ }
+ if (filename.endsWith(".pdf")) {
+ System.out.println("PDF derzeit nicht unterstuetzt.");
+ url += "&stylesheet=tabelle_fo_pdf.xsl&maxoffset=1000000&contenttype=application/pdf";
+ System.exit(1);
+ }
+ if (filename.endsWith(".xml")) {
+ url += "&stylesheet=tabelle_xml.xsl&maxoffset=1000000&contenttype=text/xml";
+ }
+
+ try {
+ //Bei DOS Parameterübergabe muss man "=" oder "&" mit dem Caret-Zeichen "^" escapen,
+ //daher hier ggf. wieder entfernen:
+ if(url.indexOf("^")>-1)
+ url=de.memtext.util.StringUtils.replace(url, "^", "");
+ System.out.println("Load URL: "+url);
+ if (filename.endsWith(".xls"))
+ getBinary(url, filename);
+ if (filename.endsWith(".html") || filename.endsWith(".htm")
+ || filename.endsWith(".xml"))
+ getText(url, filename);
+ } catch (Exception e) {
+ System.out.println("Fehler : " + e);
+
+ System.exit(1);
+ }
+ }
+
+ private static void getBinary(String url, String filename)
+ throws MalformedURLException, IOException, FileNotFoundException {
+ URL u = new URL(url);
+ URLConnection uc = u.openConnection();
+ String contentType = uc.getContentType();
+ int contentLength = uc.getContentLength();
+ // System.out.println(contentLength);
+ if (contentType.startsWith("text/") || contentLength == -1) {
+ throw new IOException(
+ "Keine Binärdatei oder keine Dateilaenge vom Server geliefert");
+ }
+ InputStream raw = uc.getInputStream();
+ InputStream in = new BufferedInputStream(raw);
+ byte[] data = new byte[contentLength];
+ int bytesRead = 0;
+ int offset = 0;
+ while (offset < contentLength) {
+ bytesRead = in.read(data, offset, data.length - offset);
+ if (bytesRead == -1)
+ break;
+ offset += bytesRead;
+ }
+ in.close();
+
+ if (offset != contentLength) {
+ throw new IOException("Nur " + offset
+ + " bytes gelesen; Erwartete " + contentLength + " bytes");
+ }
+
+ //
+ FileOutputStream out = new FileOutputStream(filename);
+ out.write(data);
+ out.flush();
+ out.close();
+ System.out.println("Datei "+filename +" gespeichert");
+ }
+
+ private static InputStream getText(String url, String filename)
+ throws MalformedURLException, IOException {
+ URL u;
+ StringBuffer sb = new StringBuffer();
+ InputStream is;
+ DataInputStream dis;
+ String s;
+ u = new URL(url);
+ is = u.openStream();
+ dis = new DataInputStream(new BufferedInputStream(is));
+ while ((s = dis.readLine()) != null) {
+ sb.append(s + "\n");
+ }
+ if (sb.indexOf("Session-Timeout erreicht") > -1)
+ throw new IOException("Authentifizierung fehlgeschlagen");
+ FileWriter fw = new FileWriter(filename);
+ BufferedWriter bfw = new BufferedWriter(fw);
+ bfw.write(sb.toString());
+ bfw.close();
+ fw.close();
+ System.out.println("Datei "+filename+" gespeichert");
+ return is;
+ }
+
+}
diff --git a/src/de/superx/bin/XUpdater.java b/src/de/superx/bin/XUpdater.java
new file mode 100644
index 0000000..8db7a8a
--- /dev/null
+++ b/src/de/superx/bin/XUpdater.java
@@ -0,0 +1,207 @@
+package de.superx.bin;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import de.memtext.util.ExceptionHandler;
+import de.memtext.util.StringUtils;
+import de.memtext.util.XMLUtils;
+import de.superx.common.DBServletException;
+
+public class XUpdater {
+ /**
+ * TODO Idee war einbau in SXSQLServer.executeAll aber Problem temp tables
+ * sind im preparedstatement nicht bekannt müsste für Batchmode auch
+ * angepasst werden if (sqlstmt.indexOf("") > -1) { try {
+ * XUpdater.execute(mandantenID, sqlstmt); } catch (DBServletException e) {
+ * errorstring = e.toString(); e.printStackTrace(); } } else {
+ *
+ * @param mandantenID
+ * @param content
+ * @param databaseAbbr
+ * PG/IDS
+ * @return
+ * @throws SQLException
+ * @throws DBServletException
+ */
+ public String execute(Connection con, String databaseAbbr, String content,
+ Logger logger) throws SQLException {
+ String sql="";
+ String comment = "";
+ try {
+ content = content.trim();
+ // Altlast
+ ExceptionHandler old = XMLUtils.getExceptionHandler();
+ ExceptionHandler2 newE = new ExceptionHandler2();
+ XMLUtils.setExceptionHandler(newE);
+ Document doc = XMLUtils.buildDocumentFromString(content, false);
+ if (doc == null) {
+ XMLUtils.setExceptionHandler(old);
+ throw new IllegalArgumentException("Ungültiges XML Dokument");
+ }
+ if (newE.hasException()) {
+ XMLUtils.setExceptionHandler(old);
+ throw new IllegalArgumentException("Ungültiges XML Dokument"
+ + newE.getException());
+ }
+
+
+ Statement stm = con.createStatement();
+ stm.execute("create temp table tmp_once(col1 integer)");
+ stm.execute("insert into tmp_once values (1)");
+ sql="Einzel-SQL";
+ executeSqlList("sql",databaseAbbr, logger,doc, stm);
+
+ NodeList list2 = doc.getElementsByTagName("text");
+ for (int i = 0; i < list2.getLength(); i++) {
+ Node n = list2.item(i);
+ String table = XMLUtils.getAttribValue(n, "table");
+ String field = XMLUtils.getAttribValue(n, "field");
+ String where = XMLUtils.getAttribValue(n, "where");
+ // getChildNodeValues -- Inhalt aller Unterknoten, weil \n vor
+ // CDATA als eigener Knoten interpretiert werden kann
+ if (!XMLUtils.hasValue(n)
+ || XMLUtils.getChildNodeValues(n).trim().equals("")) {
+ comment += "NOTIZ: Kein Inhalt für "
+ + table
+ + " "
+ + field
+ + " "
+ + where
+ + (XMLUtils.getChildNodeValues(n).trim().equals("") ? " (vor CDATA kein Leerzeichen o Umbruch!)"
+ : "") + "
";
+ } else {
+ String fieldcontent = XMLUtils.getChildNodeValues(n);
+ if (fieldcontent.equals("null")) {
+ sql="update " + table + " set " + field
+ + "=null where " + where;
+
+ stm.executeUpdate(sql);
+ } else {
+ fieldcontent = StringUtils.replace(fieldcontent,
+ "CDATASTART", "");
+
+ sql="update "
+ + table + " set " + field + "=? where " + where;
+ PreparedStatement pst = con.prepareStatement(sql);
+ pst.setString(1, fieldcontent);
+ pst.executeUpdate();
+ pst.close();
+ }
+ }
+ }
+ NodeList list3 = doc.getElementsByTagName("themenbaum");
+ for (int i = 0; i < list3.getLength(); i++) {
+ Node n = list3.item(i);
+ String maskentid = XMLUtils.getAttribValue(n, "maskentid");
+ String knoten = XMLUtils.getAttribValue(n, "parentname");
+
+ sql = "create temp table tmp_themenbaum (tid serial, name char(255) not null, maskeninfo_id integer, parent integer, gueltig_seit date, gueltig_bis date, erlaeuterung char(240)); \n";
+ stm.executeUpdate(sql);
+ sql = "insert into tmp_themenbaum (tid,name,maskeninfo_id,gueltig_seit,gueltig_bis) select max(T.tid)+1, M.name, "
+ + maskentid
+ + ", date_val('01.01.1900'), date_val('01.01.3000') from maskeninfo M, themenbaum T where M.tid="
+ + maskentid + "::integer group by 2,3,4,5 ;\n";
+ stm.executeUpdate(sql);
+ sql = "update tmp_themenbaum set parent=(select tid from themenbaum where name='"
+ + knoten + "'); \n";
+ stm.executeUpdate(sql);
+ sql = "insert into themenbaum (tid,name,maskeninfo_id,parent,gueltig_seit,gueltig_bis) select tid,name,maskeninfo_id,parent,gueltig_seit,gueltig_bis from tmp_themenbaum; \n";
+ stm.executeUpdate(sql);
+ sql = "drop table tmp_themenbaum";
+
+ stm.executeUpdate(sql);
+ }
+
+ // postsql
+ executeSqlList("postsql",databaseAbbr, logger, doc, stm);
+
+ sql="drop table tmp_once";
+ stm.executeUpdate(sql);
+ stm.close();
+ con.close();
+
+ comment = "Keine Fehler aufgefallen ("+de.memtext.util.DateUtils.getNowString()+")
" + comment;
+ }
+ catch (SQLException e)
+ {
+
+ throw new SQLException("Fehler bei "+sql+"\n"+e);
+
+ }
+ return comment;
+ }
+
+ /**
+ * @param databaseAbbr
+ * @param logger
+ * @param sql
+ * @param doc
+ * @param stm
+ * @return
+ * @throws SQLException
+ */
+ private void executeSqlList(String sqlElem,String databaseAbbr, Logger logger, Document doc, Statement stm) throws SQLException {
+ String sql;
+ NodeList list = doc.getElementsByTagName(sqlElem);
+
+ for (int i = 0; i < list.getLength(); i++) {
+ Node n = list.item(i);
+ String database = "";
+ if (XMLUtils.hasAttrib(n, "database"))
+ database = XMLUtils.getAttribValue(n, "database");
+ if (database != null && !database.equals("")
+ && !database.equals("PG") && !database.equals("IDS"))
+ throw new IllegalArgumentException(
+ "als database-Attribut hier nur PG oder IDS erlaubt");
+
+ if (database.equals("")||database.equals(databaseAbbr)) {
+ sql = XMLUtils.getTheValue(n);
+ logger.log(Level.FINER, " execute SQL from XUpdater:" + sql);
+
+ try
+ {
+ stm.execute(sql);
+ }
+ catch (Exception e)
+ {
+ throw new SQLException("Fehler bei SQL:"+sql);
+ }
+ }
+ }
+
+
+
+ }
+
+ static class ExceptionHandler2 extends ExceptionHandler {
+ private Throwable e = null;
+
+ public void clear() {
+ e = null;
+ }
+
+ public void handle(String txt, Throwable e) {
+ this.e = e;
+ }
+
+ public boolean hasException() {
+ return e != null;
+
+ }
+
+ public Throwable getException() {
+ return e;
+ }
+ }
+}
diff --git a/src/de/superx/bin/fm/EtlStarter.java b/src/de/superx/bin/fm/EtlStarter.java
new file mode 100644
index 0000000..7944e07
--- /dev/null
+++ b/src/de/superx/bin/fm/EtlStarter.java
@@ -0,0 +1,217 @@
+package de.superx.bin.fm;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+import org.apache.log4j.SimpleLayout;
+import org.apache.log4j.WriterAppender;
+import org.dom4j.Document;
+import org.dom4j.DocumentException;
+import org.dom4j.Element;
+import org.dom4j.io.SAXReader;
+import org.pentaho.di.core.JndiUtil;
+import org.pentaho.di.core.KettleEnvironment;
+import org.pentaho.di.core.Result;
+import org.pentaho.di.core.database.DatabaseMeta;
+import org.pentaho.di.core.exception.KettleException;
+import org.pentaho.di.core.logging.LogLevel;
+import org.pentaho.di.job.JobMeta;
+import org.pentaho.di.metastore.DatabaseMetaStoreUtil;
+import org.pentaho.metastore.stores.memory.MemoryMetaStore;
+
+import de.superx.servlet.SuperXManager;
+import de.superx.servlet.SxPools;
+import freemarker.template.SimpleScalar;
+import freemarker.template.TemplateModelException;
+import freemarker.template.TemplateTransformModel;
+
+public class EtlStarter implements TemplateTransformModel {
+
+ public static final String PARAM_KEY_COMP = "component";
+ public static final String PARAM_KEY_STEP = "etl_step";
+ public static final String PARAM_LOGLEVEL = "log_level";
+ private static Logger logger = Logger.getLogger(EtlStarter.class);
+
+ private LogLevel logLevel = LogLevel.BASIC;
+
+ @Override
+ public Writer getWriter(Writer paramWriter, Map paramMap) throws TemplateModelException, IOException {
+ logger.info("**EtlStarter**");
+ SimpleScalar componentSc = ((SimpleScalar) paramMap.get(PARAM_KEY_COMP));
+ SimpleScalar etl_stepSc = (SimpleScalar) paramMap.get(PARAM_KEY_STEP);
+ SimpleScalar log_levelSc = (SimpleScalar) paramMap.get(PARAM_LOGLEVEL);
+ String component = componentSc.getAsString();
+ String etl_step = etl_stepSc.getAsString();
+ if (component == null || component.isEmpty()) {
+ throw new TemplateModelException("Missing parameter " + PARAM_KEY_COMP);
+ }
+ if (etl_step == null || etl_step.isEmpty()) {
+ throw new TemplateModelException("Missing parameter " + PARAM_KEY_STEP);
+ }
+ // check for additional params which will be passed to kettle job
+ paramMap.remove(PARAM_KEY_COMP);
+ paramMap.remove(PARAM_KEY_STEP);
+ paramMap.remove(PARAM_LOGLEVEL);
+
+ if (log_levelSc != null) {
+ this.logLevel = LogLevel.valueOf(log_levelSc.getAsString());
+ }
+
+ Map params = new HashMap();
+ for (Object key : paramMap.keySet()) {
+ SimpleScalar value = (SimpleScalar) paramMap.get(key);
+ params.put((String) key, value.getAsString());
+ logger.info("PARAM: " + key + " -> " + value.getAsString());
+ }
+
+ String moduleDir=SuperXManager.getModuleDir()+ File.separator + component + File.separator;
+ if (!(new File(moduleDir)).exists()) {
+ throw new TemplateModelException("Component not found: " + component);
+ }
+ File componentXml = new File(moduleDir + File.separator + "conf" + File.separator + component + ".xml");
+ if (!componentXml.canRead()) {
+ throw new TemplateModelException("Cannot read component xml for " + component);
+ }
+ SAXReader reader = new SAXReader();
+ Element etl;
+ try {
+ Document document = reader.read(componentXml);
+ etl = (Element) document
+ .selectSingleNode("//module/etl/etl-step[@id='" + etl_step + "']/action/kettle-job-embedded");
+ } catch (DocumentException e) {
+ throw new TemplateModelException(e);
+ }
+ if (etl == null) {
+ throw new TemplateModelException(
+ "Didn't find kettle-job-embedded in etl-step with id " + etl_step + " for component " + component);
+ }
+ String fileAttr = etl.attributeValue("file");
+ String jobFilePath = moduleDir + fileAttr.substring(fileAttr.indexOf('/') + 1);
+ logger.info("Kettle job: " + jobFilePath);
+ kettleCallEmbedded(jobFilePath, params);
+ return null;
+ }
+
+ /**
+ * Abarbeiten des Kettle Jobs mit kettle (Embedded).
+ *
+ * @param jobfile
+ * Dateiname des Jobs
+ * @param jobtype
+ * ktr=Transformation, kjb=Job
+ * @param params
+ * Parameter
+ * @throws Exception
+ */
+ final StringBuffer kettleCallEmbedded(final String jobfile, final Map jobParams) {
+ return kettleCallEmbedded("default",jobfile, jobParams, true);
+ }
+
+ /**
+ * Abarbeiten des Kettle Jobs mit kettle (Embedded).
+ *
+ * @param jobfile
+ * Dateiname des Jobs
+ * @param params
+ * Parameter
+ * @param isPostgres - für Metainformationen, wenn false dann wird Informix genommen
+ * @return StringBuffer mit Logging für Ausgabe im Browser
+ * @throws Exception
+ */
+ public final StringBuffer kettleCallEmbedded(final String mandantenID,final String jobfile, final Map jobParams, boolean isPostgres) {
+ StringWriter writer = new StringWriter();
+ WriterAppender appender = new WriterAppender( new SimpleLayout(), writer );
+ org.apache.log4j.Level oldLevel=logger.getLevel();
+ logger.setLevel(org.apache.log4j.Level.ALL);
+ logger.addAppender( appender );
+
+ try {
+ // usually we initialize kettle env in EdustoreManager
+ // but this may not have happened if HIS1 not running
+ if (!KettleEnvironment.isInitialized()) {
+ try {
+ KettleEnvironment.init();
+ } catch (KettleException e) {
+ logger.error("Couldn't initialize KettleEnvironment!", e);
+ }
+ }
+ JndiUtil.initJNDI();
+ MemoryMetaStore metastore = new MemoryMetaStore();
+ //Dies hatte für Mandantenbetrieb nicht funktioniert, daher Umstellung auf SxPool , s.u.
+ //DataSourceProviderFactory.setDataSourceProviderInterface(new KettleDataSourceProvider(mandantenID,logger));
+ /*
+ * get all db connections configured in databases.xml as
+ * DataSource's by name
+ */
+
+ // Enumeration dbNames =
+ // this.dbhandlerPool.getLogicalDatabaseNames();
+ List dbNames = Arrays.asList(new String[] { "eduetl" });
+ for (String dbName : dbNames) {
+ // Dies hatte für Mandantenbetrieb nicht funktioniert, daher Umstellung auf SxPool , s.u.
+
+ //DatabaseMeta dbmeta = new DatabaseMeta(dbName, isPostgres ? "POSTGRESQL" : "INFORMIX", "JNDI", null, dbName, "1521", null, null);
+ DatabaseMeta dbmeta=SxPools.get(mandantenID).getKettleDatabaseMeta();
+ DatabaseMetaStoreUtil.createDatabaseElement(metastore, dbmeta);
+
+ logger.info("Init pdi database connection " + dbName+" (DBName:"+dbmeta.getDatabaseName()+")");
+ }
+
+ JobMeta jobMeta = new JobMeta(null, jobfile, null, metastore, null);
+ org.pentaho.di.job.Job job = new org.pentaho.di.job.Job(null, jobMeta);
+ job.setLogLevel(this.logLevel);
+ String[] params = jobMeta.listParameters();
+ for (String param : params) {
+ logger.info("Job-Param: " + param);
+ logger.info(" -> defaults to " + jobMeta.getParameterDefault(param));
+ }
+ job.copyParametersFrom(jobMeta);
+ // to be able to track progress
+ job.setInteractive(true);
+ if (jobParams != null) {
+ for (String param : jobParams.keySet()) {
+ String value = jobParams.get(param);
+ logger.info("PARAM " + param + " = " + value);
+ jobMeta.setParameterValue(param, value);
+ }
+ }
+ job.activateParameters();
+ job.start();
+ job.waitUntilFinished();
+ Result result = job.getResult();
+ String outcome = "\nJob " + jobfile + " executed with result: " + result.getResult() + " and "
+ + result.getNrErrors() + " errors\n";
+ logger.info(outcome);
+ if (result.getNrErrors() > 0) {
+ logger.info(result.getNrErrors() + " Errors executing Kettle job " + jobfile);
+ String logText = result.getLogText();
+ logger.error(logText);
+ throw new RuntimeException("Errors in Kettle job " + jobfile + ":\n" + logText);
+ }
+ } catch (Exception ex) {
+ logger.error("Error executing Kettle job " + jobfile, ex);
+ throw new RuntimeException(ex);
+ } finally {
+ logger.removeAppender(appender);
+ logger.setLevel(oldLevel);
+ }
+
+ return writer.getBuffer();
+ }
+
+ public static void main(String args[]) {
+ String jobfile = "file:///home/superx/data-integration/exceltest.kjb";
+ Map jobParams = new HashMap