* @throws ConfigurationChangeException Falls das System-Objekt nicht vervollständigt werden konnte.
	 */
	private void completeSystemObject(ImportObject importObject) throws ConfigurationChangeException {
		final ConfigurationArea configurationArea = importObject.getConfigurationArea();
		final SystemObject systemObject = importObject.getSystemObject();
		final SystemObjectType objectType = systemObject.getType();
		final ConfigurationConfigurationObject property = (ConfigurationConfigurationObject)importObject.getProperties();
		try {
			// Set in der alle verwendeten ATGV gespeichert werden, damit alle Datensätze gelöscht werden können, die nicht vorhanden sein dürfen.
			final Set<AttributeGroupUsage> usedAtgUsages = new HashSet<AttributeGroupUsage>();

			// Datensätze und Mengen werden gespeichert
			for(ConfigurationObjectElements elements : property.getDatasetAndObjectSet()) {
				if(elements instanceof ConfigurationDataset) {
					ConfigurationDataset dataset = (ConfigurationDataset)elements;
					if(dataset.getPidATG().equals("atg.konfigurationsVerantwortlicherLaufendeNummer")) {
						throw new IllegalStateException(
								"Dieser Datensatz '" + dataset.getPidATG() + "' darf nicht importiert werden. Er wird nur intern verwendet."
						);
					}
					// Attributgruppe, Aspekt und AttributgruppenVerwendung ermitteln
					final AttributeGroup atg = (AttributeGroup)getObject(dataset.getPidATG());
					if(atg == null) throwNoObjectException(dataset.getPidATG());
					final Aspect asp = (Aspect)getObject(dataset.getPidAspect());
					if(asp == null) throwNoObjectException(dataset.getPidAspect());

					final AttributeGroupUsage atgUsage = getAttributeGroupUsage(atg, asp);
					// Exception, falls es keine ATGV gibt
					if(atgUsage == null) {
						final StringBuilder errorMessage = new StringBuilder();
						errorMessage.append("Datensatz kann nicht am Objekt '").append(systemObject.getPidOrNameOrId());
						errorMessage.append("' gespeichert werden. Zu der Attributgruppe '").append(atg.getPid()).append("' und dem Aspekt '");
						errorMessage.append(asp.getPid()).append("' gibt es  keine Attributgruppenverwendung zur Speicherung des Datensatzes.");
						_debug.error(errorMessage.toString());
						throw new ConfigurationChangeException(errorMessage.toString());
					}

					// Merken, zu welchen ATGV Datensätze existieren sollen
					usedAtgUsages.add(atgUsage);
					// bei dynamischen Objekten und notwendig und nicht änderbaren DS nachfolgenden Part überspringen
					if(!objectType.isConfigurating() && (atgUsage.getUsage() == AttributeGroupUsage.Usage.RequiredConfigurationData
					                                     || atgUsage.getUsage() == AttributeGroupUsage.Usage.OptionalConfigurationData)) {
						// tue nix
					}
					else {

						// Falls der Datensatz unterschiedlich ist, wird er neu abgespeichert
						boolean datasetDifferent = _objectDiffs.isDatasetDifferent(dataset, systemObject);
//						if(atg.getPid().equals("atg.benutzerParameter")) {
//							System.out.println("atgUsage.getValidSince() = " + atgUsage.getValidSince());
//							System.out.println("atgUsage.getNotValidSince() = " + atgUsage.getNotValidSince());
//							System.out.println("atg = " + atg);
//							System.out.println("asp = " + asp);
//							System.out.println("systemObject.getPid() = " + systemObject.getPid());
//							System.out.println("############### datasetDifferent = " + datasetDifferent);
//						}
						if(datasetDifferent) {
							Data data = AttributeBaseValueDataFactory.createAdapter(atg, AttributeHelper.getAttributesValues(atg));
							data.setToDefault();
//						printData(data);
							fillData(data, dataset.getDataAnddataListAndDataField());
//						printData(data);
							// das Data wird am System-Objekt gespeichert
							systemObject.setConfigurationData(atgUsage, data);
						}
					}
				}
				else if(elements instanceof ConfigurationObjectSet) {
					ConfigurationObjectSet configurationObjectSet = (ConfigurationObjectSet)elements;

					// dynamische Objekte können keine Mengen haben
					if(!objectType.isConfigurating()) {
						// es ist ein dynamisches Objekt!
						final String errorMessage = "Dynamische Objekte können keine Mengen haben. Es sind aber welche angegeben.";
						_debug.error(errorMessage);
						throw new IllegalArgumentException(errorMessage);
					}

					final ConfigurationObject configObject = (ConfigurationObject)systemObject;
					ObjectSet objectSet = configObject.getObjectSet(configurationObjectSet.getName());
					if(_objectDiffs.isSystemObjectSetDifferent(configurationObjectSet, objectSet)) {
						ObjectSetType objectSetType = null;
						// Mengenverwendungen ermitteln
						final Collection<ObjectSetUse> objectSetUses = getObjectSetUses(objectType);
						for(ObjectSetUse objectSetUse : objectSetUses) {
							if(objectSetUse.getObjectSetName().equals(configurationObjectSet.getName())) {
								objectSetType = objectSetUse.getObjectSetType();
								break; // da gefunden
							}
						}
						if(objectSetType == null) {
							final StringBuilder errorMessage = new StringBuilder();
							errorMessage.append("Der Typ '").append(objectType.getPidOrNameOrId()).append("' dieses Objektes '");
							errorMessage.append(systemObject.getPidOrNameOrId()).append("' unterstützt die Menge '").append(configurationObjectSet.getName());
							errorMessage.append("' nicht.");
							_debug.error(errorMessage.toString());
							throw new IllegalArgumentException(errorMessage.toString());
						}

						final String importManagementPid = configurationObjectSet.getManagementPid();
						// Menge ist verschieden oder nicht vorhanden
						if(objectSet != null) {
							boolean versionedChange = false;
							if(objectSet instanceof MutableSet) {
								final AttributeGroup dynamicSetPropertiesAtg = _dataModel.getAttributeGroup("atg.dynamischeMenge");
								if(dynamicSetPropertiesAtg != null) {
									final Aspect asp = _dataModel.getAspect("asp.eigenschaften");
									final AttributeGroupUsage atgUsage = getAttributeGroupUsage(dynamicSetPropertiesAtg, asp);
									String managementPid = "";
									final Data data = objectSet.getConfigurationData(atgUsage);
									if(data != null) managementPid = data.getTextValue("verwaltung").getValueText();
									if(!managementPid.equals(importManagementPid)) {
										versionedChange = true;
									}
								}
							}


							// Typ überprüfen
							if(objectSet.getObjectSetType() != objectSetType) {
								versionedChange = true;
							}
							if(versionedChange) {
								configObject.removeSet(objectSet);
								objectSet = null;
							}
						}
						if(objectSet == null) {
							// neue Menge anlegen
							objectSet = (ObjectSet)configurationArea.createConfigurationObject(objectSetType, "", configurationObjectSet.getName(), null);
							// Menge dem Objekt hinzufügen
							configObject.addSet(objectSet);
							_debug.finer(
									"Menge " + configurationObjectSet.getName() + " dem SystemObjekt mit der Pid '" + systemObject.getPid() + "' hinzugefügt."
							);
						}
						else {
							setSystemObjectKeeping(objectSet);
						}

						boolean ignoreElements = false;
						if(objectSet instanceof MutableSet) {
							final AttributeGroup dynamicSetPropertiesAtg = _dataModel.getAttributeGroup("atg.dynamischeMenge");
							if(dynamicSetPropertiesAtg == null) {
								if(!importManagementPid.equals("")) {
									_debug.warning(
											"Zugriff auf Verwaltungsinformationen von dynamischen Mengen nicht möglich, da die eingesetzte Version des Bereichs"
											+ " kb.metaModellGlobal zu alt ist (mindestens Version 10 notwendig)."
									);
								}
							}
							else {
								final Aspect asp = _dataModel.getAspect("asp.eigenschaften");
								final AttributeGroupUsage atgUsage = getAttributeGroupUsage(dynamicSetPropertiesAtg, asp);
								String managementPid = "";
								final Data data = objectSet.getConfigurationData(atgUsage);
								if(data != null) managementPid = data.getTextValue("verwaltung").getValueText();
								if(!managementPid.equals(importManagementPid)) {
									Data newData = AttributeBaseValueDataFactory.createAdapter(
											dynamicSetPropertiesAtg, AttributeHelper.getAttributesValues(dynamicSetPropertiesAtg)
									);
									newData.getTextValue("verwaltung").setText(importManagementPid);
									objectSet.setConfigurationData(atgUsage, newData);
									if(!importManagementPid.equals("")) ignoreElements = true;
								}
							}
						}
						else {
							if(!importManagementPid.equals("")) {
								_debug.warning(
										"Angabe der verwaltenden Konfiguration wird bei der nicht dynamischen Menge " + objectSet.getName() + " am Objekt "
										+ systemObject.getPidOrNameOrId() + " im Bereich " + configurationArea.getPidOrNameOrId() + " ignoriert"
								);
							}
						}

						// prüfen, ob die hinzuzufügenden Elemente in der Menge erlaubt sind (wird beim hinzufügen der Elemente überprüft)
						Set<SystemObject> setElements = new LinkedHashSet<SystemObject>();
						final String[] elementPids = configurationObjectSet.getElements();
						if(elementPids.length != 0) {
							if(ignoreElements) {
								_debug.warning(
										"Wegen der Angabe der verwaltenden Konfiguration werden die bei der dynamischen Menge " + objectSet.getName()
										+ " am Objekt " + systemObject.getPidOrNameOrId() + " im Bereich " + configurationArea.getPidOrNameOrId()
										+ " angegebenen Elemente ignoriert"
								);
							}
							else {
								for(String pid : elementPids) {
									final SystemObject object = getObject(pid);
									if(object == null) throwNoObjectException(pid);
									setElements.add(object);
								}
							}
						}
						final List<SystemObject> elementsInSet = objectSet.getElements();
						// überflüssige Elemente entfernen
						for(SystemObject object : elementsInSet) {
							if(!setElements.contains(object)) {
								objectSet.remove(object);
							}
						}
						// Elemente hinzufügen
						for(SystemObject object : setElements) {
							if(!elementsInSet.contains(object)) {
								objectSet.add(object);
							}
						}
					}
					else {
						// Menge muss nicht geändert werden -> aber es wird beibehalten
						setSystemObjectKeeping(objectSet);
					}
				}
			}

			// nicht mehr benötigte Datensätze entweder gelöscht oder auf null gesetzt, je nachdem, ob das Objekt in Bearbeitung ist
			// oder bereits freigegeben/aktiviert wurde
			if(objectType.isConfigurating()) {
				final Collection<AttributeGroupUsage> usedAttributeGroupUsages = systemObject.getUsedAttributeGroupUsages();
				for(AttributeGroupUsage atgUsage : usedAttributeGroupUsages) {
					if(!usedAtgUsages.contains(atgUsage) && !ComparePropertiesWithSystemObjects.isHiddenInExport(atgUsage)) {
						// die ATGV wurde nicht verwendet und entspricht nicht atg.info oder atg.konfigurationsVerantwortlicherLaufendeNummer -> Datensatz löschen
						// bei einem in Bearbeitung befindlichen Objekt werden die Datensätze richtig gelöscht.
						if(getEditingObject(systemObject.getConfigurationArea(), systemObject.getPid()) != null) {
							((ConfigSystemObject)systemObject).removeConfigurationData(atgUsage);
						}
						else {
							// bei einem zuvor freigegebenen Objekt werden die Datensätze nur auf null gesetzt.
							((ConfigSystemObject)systemObject).createConfigurationData(atgUsage, null);
						}
					}
				}
			}
			else {
				// es handelt sich um ein dynamisches Objekt - notwendige DS werden hier nicht betrachtet (sie dürfen nicht gelöscht werden)
				for(AttributeGroupUsage atgUsage : systemObject.getUsedAttributeGroupUsages()) {
//					System.out.println("############### Betrachte atgUsage = " + atgUsage);
//					System.out.println("atgUsage.getValidSince() = " + atgUsage.getValidSince());
//					System.out.println("atgUsage.getNotValidSince() = " + atgUsage.getNotValidSince());
					if(atgUsage.getUsage() == AttributeGroupUsage.Usage.ChangeableRequiredConfigurationData
					   || atgUsage.getUsage() == AttributeGroupUsage.Usage.RequiredConfigurationData) {
						// nicht weiter beachten
//						System.out.println("-> bleibt, weil notwendig");
					}
					else {
						if(!usedAtgUsages.contains(atgUsage) && !ComparePropertiesWithSystemObjects.isHiddenInExport(atgUsage)) {
							// die ATGV wurde nicht verwendet -> muss also gelöscht werden
							((ConfigSystemObject)systemObject).createConfigurationData(atgUsage, null);
//							System.out.println("-> wird auf null gesetzt");
						}
//						else {
//							System.out.println("-> bleibt");
//						}
					}
				}
			}

			if(objectType.isConfigurating()) {
				// Default-Parameter-Datensätze hinzufügen
				if(_objectDiffs.isDefaultParameterDifferent(property.getDefaultParameters(), systemObject)) {
					setDefaultParameterDataset(property.getDefaultParameters(), systemObject);
				}
			}
		}
		catch(Exception ex) {
			final String errorMessage = "Das System-Objekt mit der Pid '" + property.getPid() + "' konnte nicht vollständig erstellt werden";
			_debug.error(errorMessage, ex);
			throw new ConfigurationChangeException(errorMessage, ex);
		}
	}