* @throws ConfigurationChangeException Falls das System-Objekt nicht erstellt werden konnte.
	 */
	private void handleSystemObject(ImportObject importObject) throws ConfigurationChangeException {
		final SystemObjectProperties property = importObject.getProperties();
		try {
			final SystemObjectType systemObjectType = (SystemObjectType)getObject(property.getType());
			if(systemObjectType == null) throwNoObjectException(property.getType());

			SystemObject systemObject = importObject.getSystemObject();
			if(systemObject != null) {
				// es gibt bereits ein Objekt - prüfen, ob der Typ übereinstimmt - wenn nicht, dann muss ein neues Objekt angelegt werden.
				if(systemObject.getType() != systemObjectType) {
					// handelt es sich um ein in Bearbeitung erstelltes Objekt, dann muss es aus der EditingObjects-Map entfernt werden.
					final Collection<CheckedObject> objects = _editingObjects.get(importObject.getConfigurationArea());
					for(CheckedObject object : objects) {
						if(object.getSystemObject() == systemObject) {
							objects.remove(object);
							break;
						}
					}

					// Objekt muss jetzt schon auf ungültig gesetzt werden, damit ein neues Objekt mit gleicher Pid erstellt werden kann
					// in Bearbeitung erstellte Objekte werden direkt gelöscht.
					
					((ConfigSystemObject)systemObject).simpleInvalidation();
					systemObject = null;
					_dissolveReference = true;
				}
				else {
					setSystemObjectKeeping(systemObject);
				}
			}
			if(systemObject == null) {
				// Objekt muss neu erstellt werden
				if(systemObjectType.isConfigurating()) {
					final ConfigurationObjectType configurationObjectType = (ConfigurationObjectType)systemObjectType;
					systemObject = importObject.getConfigurationArea().createConfigurationObject(
							configurationObjectType, property.getPid(), property.getName(), null
					);
					_debug.finer("Konfigurierendes Objekt mit Pid '" + property.getPid() + "' wurde erstellt.");
				}
				else {
					// falls Datensätze am dynamischen Objekt gespeichert werden sollen, müssen diese schon hier berücksichtigt werden
					final ConfigurationConfigurationObject configurationObjectProperties = (ConfigurationConfigurationObject)property;
					final List<DataAndATGUsageInformation> dataAndATGUsageInformation = new LinkedList<DataAndATGUsageInformation>();
					for(ConfigurationObjectElements configurationObjectElements : configurationObjectProperties.getDatasetAndObjectSet()) {
						if(configurationObjectElements instanceof ConfigurationDataset) {
							ConfigurationDataset configurationDataset = (ConfigurationDataset)configurationObjectElements;
							// prüfen, ob es die Atg und den Asp gibt. Es müssen aktuelle Objekte sein.
							final AttributeGroup atg = _dataModel.getAttributeGroup(configurationDataset.getPidATG());
							if(atg == null) throwNoObjectException(configurationDataset.getPidATG());
							final Aspect asp = _dataModel.getAspect(configurationDataset.getPidAspect());
							if(asp == null) throwNoObjectException(configurationDataset.getPidAspect());

							final AttributeGroupUsage atgUsage = atg.getAttributeGroupUsage(asp);
							// Exception, falls es keine ATGV gibt
							if(atgUsage == null) {
								final StringBuilder errorMessage = new StringBuilder();
								errorMessage.append("Datensatz kann nicht am Objekt '").append(property.getPid());
								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());
							}
							// alle notwendigen und optional nicht änderbaren Datensätze werden hier gespeichert.
							if(atgUsage.getUsage() != AttributeGroupUsage.Usage.ChangeableOptionalConfigurationData) {
//							if(atgUsage.getUsage() == AttributeGroupUsage.Usage.ChangeableRequiredConfigurationData
//							   || atgUsage.getUsage() == AttributeGroupUsage.Usage.RequiredConfigurationData) {
								final Data data = AttributeBaseValueDataFactory.createAdapter(atg, AttributeHelper.getAttributesValues(atg));
								data.setToDefault();
								fillData(data, configurationDataset.getDataAnddataListAndDataField());
								dataAndATGUsageInformation.add(new DataAndATGUsageInformation(atgUsage, data));
							}
						}
						else {
							throw new IllegalStateException(
									"Beim dynamischen Objekt '" + property.getPid() + "' wurde eine Menge angegeben. Dies ist nicht erlaubt."
							);
						}
					}

					// Der zu nutzende dynamische Typ muss ein aktueller Typ sein. Falls er gerade erst importiert wurde, kann er nicht verwendet werden, da
					// das Objekt sofort gültig würde, ohne einen aktuellen Objekt-Typen.
					final DynamicObjectType dynamicObjectType = (DynamicObjectType)_dataModel.getObject(property.getType());
					if(dynamicObjectType != null) {
						_debug.finer("Dynamisches Objekt mit pid '" + property.getPid() + "' wird erstellt. Datensätze", dataAndATGUsageInformation);
						systemObject = importObject.getConfigurationArea().createDynamicObject(
								dynamicObjectType, property.getPid(), property.getName(), dataAndATGUsageInformation
						);
						_debug.finer("Dynamisches Objekt mit der Pid '" + property.getPid() + "' wurde erstellt.");
					}
					else {
						final String errorMessage = "Das dynamische Objekt mit der Pid '" + property.getPid() + "' konnte nicht erzeugt werden, "
						                            + "da der Typ des Objekts erst in der nächsten Version des Konfigurationsbereichs aktiviert wird.";
						_debug.error(errorMessage);
						throw new IllegalStateException(errorMessage);
					}
				}
			}
			// Namen überprüfen
			if(_objectDiffs.isNameDifferent(property.getName(), systemObject.getName())) {
				systemObject.setName(property.getName());
			}

			// Info überprüfen
			if(_objectDiffs.isInfoDifferent(property.getInfo(), systemObject.getInfo())) {
				setInfo(systemObject, property.getInfo());
			}
			importObject.setSystemObject(systemObject);
		}
		catch(ConfigurationChangeException ex) {
			final String errorMessage = "Das System-Objekt '" + property.getPid() + "' konnte nicht korrekt erstellt werden";
			_debug.error(errorMessage);
			throw new ConfigurationChangeException(errorMessage, ex);
		}